Reussir Programming Language

Expressive by default

Rust-like Syntax.Memory Managed

Highly optimized RC. Every value is managed by Reussir’s reference-counting runtime.

Prototype without lifetime noise. Humans and coding agents get a familiar, Rust-like surface for moving quickly.

Built to grow. Rust-style monomorphization and a familiar module system carry the same model into larger programs.

A cheerful orange crab in front of a colorful geometric shield marked with lambda — Adapted from RustWeek artwork by Paige Losare-Lusby · CC BY-SA 4.0

list_reverse.rr

enum List<T> {
    Nil,
    Cons(T, List<T>)
}

fn reverse_impl(list: List<i32>, acc: List<i32>) -> List<i32> {
    match list {
        List::Nil => acc,
        List::Cons(x, xs) =>
            reverse_impl(xs, List::Cons{x, acc})
    }
}

pub fn reverse(list: List<i32>) -> List<i32> {
    reverse_impl(list, List::Nil{})
}

rrc list_reverse.rr -O3 -o list_reverse.o

fingertree.rr

enum FingerTree {
    Empty,
    Single(Elem),
    Deep(Digit, FingerTree, Digit)
}

fn snoc(tree: FingerTree, x: Elem) -> FingerTree {
    match tree {
        FingerTree::Empty => FingerTree::Single{x},
        FingerTree::Single(a) => FingerTree::Deep{
            Digit::One{a}, FingerTree::Empty, Digit::One{x}
        },
        FingerTree::Deep(prefix, middle, Digit::One(a)) =>
            FingerTree::Deep{
                prefix, middle, Digit::Two{a, x}
            },
        FingerTree::Deep(prefix, middle, Digit::Two(a, b)) =>
            FingerTree::Deep{
                prefix, middle, Digit::Three{a, b, x}
            },
        FingerTree::Deep(prefix, middle,
                         Digit::Three(a, b, c)) =>
            FingerTree::Deep{
                prefix, middle, Digit::Four{a, b, c, x}
            },
        FingerTree::Deep(prefix, middle,
                         Digit::Four(a, b, c, d)) =>
            FingerTree::Deep{
                prefix,
                snoc(middle, Elem::Node3{a, b, c}),
                Digit::Two{d, x}
            }
    }
}

rrc fingertree.rr -O3 -o fingertree.o

region.rr

struct [regional] Cell<T> {
    value: T
}

regional fn make_cell(x: u64) -> [flex] Cell<u64> {
    Cell{value: x}
}

fn freeze_cell() -> Cell<u64> {
    regional {
        let cell: [flex] Cell<u64> = make_cell(42);
        cell
    }
}

// Region-local storage freezes into a managed value.

rrc region.rr --emit mlir -o region.mlir

Optimize the abstraction

Embrace Functional Programmingwith Lightning Speed

Reuse analysisThreads explicit storage tokens through branches, regions, and loops.
IR-level beta reductionFolds closure chains and loop-carried lambdas after inlining exposes them.
Tail recursion modulo consTurns constructor-fed recursion into loops with first-class constructor contexts.
Invariant-group analysisProves projected loads immutable so LLVM can keep and reuse their values.
Whole-program devirtualizationSpecializes closure dispatch with guarded direct calls and a safe indirect fallback.
Uniqueness-carrying recursionProves fresh recursive values and outlines fast paths with known-unique inputs.

Cross-language benchmark suite

Time & peak RSS

Mean time

milliseconds · log scale

Peak RSS

MiB · log scale

11 Reussir workloads at -Oaggressive, reported as 10-run means. Long labels are shortened; hover or focus for the full workload.

Memory, made visible

At the Bleeding Edge of Memory Management

Storage-token reuse

Reverse without reallocating

list_reverse.rr

fn reverse_impl(list: List<i32>, acc: List<i32>) -> List<i32> {
    match list {
        List::Nil => acc,
        List::Cons(x, xs) =>
            reverse_impl(xs, List::Cons{x, acc})
    }
}

decrement → token → reconstructed Cons

Regional graph memory

Build cycles, freeze safely

regional_dlist.rr

struct [regional] DLLink<T> {
    val: T,
    next: [field] DLLink<T>,
    prev: [field] DLLink<T>
}

fn build() -> DLLink<i32> {
    regional {
        let a = DLLink{val: 1, next: Nullable::Null{}, prev: Nullable::Null{}};
        let b = DLLink{val: 2, next: Nullable::Null{}, prev: Nullable::Null{}};
        b->prev := Nullable::NonNull{a};
        a->next := Nullable::NonNull{b};
        a
    }
}

mixed regional graph

Built for Human and Agent Ergonomics

One feedback loop, two layers

Compiler feedback

Errors that point to the repair

demo.rr

rrc demo.rr --emit hir

Error: unknown function `lenght`; did you mean `length`?
   ╭─[ demo.rr:6:5 ]
   │
 6 │     lenght(42)
   │     ─────┬────
   │          ╰────── unknown function `lenght`;
   │                  did you mean `length`?
───╯

Precise spans and ranked suggestions give a person—or an agent—a small, explicit repair target instead of a vague compiler failure.

source-local
actionable
consistent

Programmable compilation

Keep the compiler strategy beside the program

inline transform

#[transform_anchor]
pub fn target() -> [i64; 4, 16] {
    core::intrinsic::array::splat<[i64; 4, 16]>(7)
}

transform [{
    %stores = transform.structured.match
        ops{["memref.store"]} in %target
        : (!transform.any_op)
          -> !transform.op<"memref.store">
    %outer = transform.get_parent_op %stores {
        op_name = "scf.for", nth_parent = 2 : i64,
        deduplicate
    } : (!transform.op<"memref.store">)
      -> !transform.op<"scf.for">
    transform.loop.unroll_and_jam %outer {factor = 2}
        : !transform.op<"scf.for">
    transform.yield
}];