Most modern programming languages rely on massive external toolchains.

Many use LLVM for code generation. Others depend on large runtimes, garbage collectors, or extensive third-party infrastructure.

Rux takes a different approach.

Rux is a statically typed systems programming language focused on performance, control, and simplicity. It compiles directly to native machine code and is built with minimal external dependencies.

Lightweight by Design

One of Rux's goals is keeping the toolchain simple and lightweight.

The compiler itself is approximately 3 MB in size and includes its own package manager, allowing developers to manage projects and dependencies without installing a collection of separate tools.

Rather than relying on a large ecosystem of external components, Rux aims to provide a streamlined experience out of the box.

Built Without LLVM

Many modern programming languages rely on LLVM for optimization and code generation.

Rux takes a different path.

Instead of using LLVM, Rux implements its own compilation pipeline and backend. This provides complete control over code generation, compiler architecture, and future language development.

For developers interested in compilers and systems programming, it also means the entire compilation process remains visible and understandable without depending on a massive external framework.

Current Platform Support

Rux currently targets x86-64 (x64) systems.

Support for additional architectures may be explored in the future, but the current focus is on building a solid and reliable foundation for the language, compiler, and tooling.

Batteries Included

Rux ships with an integrated package manager, similar in spirit to Cargo for Rust.

Creating projects, managing packages, and building applications can all be done through a unified toolchain rather than requiring multiple external utilities.

No Dependency Hell

Modern development often involves downloading gigabytes of dependencies before writing a single line of code.

Rux aims to avoid that.

The compiler is designed to be lightweight and self-contained. Building and using Rux does not require a large collection of external libraries or frameworks.

This makes the project easier to build, easier to understand, and easier to contribute to.

Designed for Systems Programming

Rux is intended for developers who want direct control over their software.

The language provides:

• Native compilation
• Strong static typing
• Structs and enums
• Interfaces
• Pointers and references
• Foreign Function Interface (FFI)
• Inline assembly
• Modules and packages

These features allow developers to write low-level software while maintaining a modern and readable syntax.

A Simple Example

import Std::Io::Print;

func add(a: i64 b: i64) -> i64 {
    return a + b;
}

func Main() -> int {
    Print(add(23929,4729));
    return 0;
}

The goal is not to create the shortest syntax possible.

The goal is clarity.

Code should be easy to read, understand, and maintain.

Why Rux Exists

Rux explores a simple idea:

What happens when you build a systems programming language from the ground up without relying on LLVM, heavyweight runtimes, or large dependency chains?

The result is a language focused on explicit behavior, predictable performance, and complete control over the compilation process.

Current Development

Rux is actively developed and continues to gain new features and improvements.

Recent releases have introduced modules, packages, interfaces, tuples, slices, enums, and many other language features while continuing to improve compiler performance and developer experience.

But we need to be real, Rux is still unstable, and under development. There are a lot of bugs.

Final Thoughts

The programming language ecosystem is full of experimentation, and that's a good thing.

Rux represents one approach: a modern systems language that prioritizes simplicity, native performance, and a fully independent compiler architecture.

Despite being young, the project has already attracted hundreds of GitHub stars, multiple contributors, community members, and independent reviews from developers interested in compiler and language design

If you're interested in systems programming, compilers, or language design, Rux is a project worth exploring.

Learn more at https://rux-lang.dev