Systems programming,
reimagined.

Memory safety without garbage collection. The borrow checker prevents data races, use-after-free, and double-free at compile time.

fn transfer(data: Vec<u8>) {
    let owned = data;  // moved
    // data is no longer valid here
    process(&owned);   // borrow
}

Exhaustive pattern matching with algebraic data types. The compiler guarantees every case is handled.

match sensor.read() {
    Reading::Ok(val) => process(val),
    Reading::Err(e) => log_error(e),
    Reading::Timeout => retry(),
}

Zero-cost abstractions via monomorphization. Trait-based polymorphism without vtable overhead in hot paths.

trait Sensor<T: Numeric> {
    fn read(&self) -> T;
    fn energy_cost(&self) -> Picojoules;
}

8-effect bitfield tracks side effects at the type level. IO, allocation, network, compute — the compiler knows what your function does.

#[effects(compute, memory)]
fn matrix_mul(a: &Mat, b: &Mat) -> Mat {
    // IO not allowed here
}