Rue: A Quick Reference (and How It Came to Be)

How it came about

Steve Klabnik is about as close to “the person who taught you Rust” as it gets. He co-authored The Rust Programming Language, the official book that introduced more people to the language than probably anything else, spent thirteen years on Rust’s core team, and led its documentation team. For most of that time, he was openly skeptical of AI coding tools.

That changed in 2025. Last December, on his thirteenth Rust anniversary, Klabnik started building Rue — a new systems programming language — and wrote most of its roughly 100,000-line compiler with Claude in about eleven days.

Rue’s premise is a direct response to the hardest part of Rust: the borrow checker. Klabnik’s framing for the project was a simple question — what if Rust wasn’t trying to compete with C and C++ for maximum performance? What if you gave up a little bit of that performance in exchange for real ease of use?

The result eliminates the borrow checker entirely. In its place, Rue uses inout parameters that temporarily transfer ownership, similar to how Swift handles it, aiming for memory safety without garbage collection — while sitting in the design gap between low-level systems languages and higher-level, garbage-collected ones (“higher level than Rust, lower level than Go,” as the project describes itself).

The project is open source at github.com/rue-language/rue, currently at version 0.1.0. It’s explicitly early-stage and not for production use — syntax, semantics, and the standard library are all still changing — but it compiles straight to native machine code (x86-64 and AArch64, no LLVM, no VM, no interpreter) and already has a working lexer, parser, semantic analysis, and code generation pipeline.

Quick reference

Everything below has been verified by actually running it through the compiler.

Setup

bash

# Install Dotslash (bootstraps Buck2 and the Rust toolchain for you)
curl -LSfs "https://github.com/facebook/dotslash/releases/latest/download/dotslash-ubuntu-22.04.$(uname -m).tar.gz" | sudo tar fxz - -C /usr/local/bin

# Clone and build
git clone https://github.com/rue-language/rue.git
cd rue
scripts/rue build

# Run a file
scripts/rue exec myprogram.rue

Rue code always has to live in a .rue file — it can’t be typed directly at a shell prompt. Write it with an editor (nano file.rue) or a heredoc (cat > file.rue << 'EOF' ... EOF), then run it with scripts/rue exec file.rue.

Hello world

rue

fn main() -> i32 {
    @dbg("Hello, Rue!");
    0
}

@dbg(...) is the built-in debug-print — works on strings, integers, and other basic values without any imports.

Imports and println

rue

const std = @import("std");

fn main() -> i32 {
    println("x = " + @to_string(42));
    0
}

Rue has no implicit standard-library prelude — println requires importing std first. @to_string converts values (like integers) into strings so they can be concatenated with +.

Integer types

rue

let x: i32 = 42;
let big: i64 = 1000000000000;
let index: u64 = 0;
let byte: u8 = 255;

Signed: i8, i16, i32, i64. Unsigned: u8, u16, u32, u64. The number is the bit width; u types can’t go negative.

Type inference

rue

let x = 42;    // inferred as i32 (the default)
let y = true;  // inferred as bool

Integer literals default to i32 when there’s no other context.

Booleans

rue

let flag: bool = true;
if flag {
    println("flag is true");
}

Mutability

Variables are immutable by default:

rue

let x = 42;
x = 43;   // compile error: E0203, cannot assign to immutable variable

Use let mut to allow reassignment:

rue

let mut count = 0;
count = count + 1;
count = count + 1;
println("count = " + @to_string(count)); // count = 2

What’s next

The tutorial in the repo (website/content/tutorial/) continues from here — functions, control flow, arrays, structs, enums, and Rue’s inout/borrowing model, which is the whole point of the language.