Systems programming has been dominated by C for 50 years. We've spent decades layering complexity on top of it — C++ templates, Rust lifetimes, Go goroutines, Zig comptime. Each layer adds power but also ceremony, cognitive overhead, and compile-time pain.

Zeta goes back to first principles. Instead of inheriting C's baggage and papering over it, we asked: what does a systems language look like if you start from Stepanov's algebraic foundations and refuse to compromise on any axis?

The answer: a language that compiles itself in 14 milliseconds. A language with a complete standard library that ships as a single 8 MB binary. A language where compile-time evaluation isn't a macro system bolted on later — it's how the compiler thinks. A language where your code is correct because the type system proves it, not because you wrote enough tests.

Zeta is designed for the problems that matter: high-frequency trading engines, game engines, embedded systems, browser runtimes, scientific computing, distributed infrastructure. Anything where every microsecond counts and every kilobyte is precious.

"Surgical violence against complexity."

fn fib(n: i64) -> i64 {
    if n <= 1 { return n; }
    return fib(n - 1) + fib(n - 2);
}

fn main() -> i64 {
    println_i64(fib(40));
    return 0;
}

struct Point { x: i64, y: i64 }

fn magnitude(p: Point) -> f64 {
    return sqrt((p.x * p.x + p.y * p.y) as f64);
}

fn main() -> i64 {
    let p = Point { x: 3, y: 4 };
    println_f64(magnitude(p)); // 5.0
    return 0;
}

const FACTORIAL_10: i64 = comptime {
    fn fact(n: i64) -> i64 {
        if n <= 1 { return 1; }
        return n * fact(n - 1);
    }
    fact(10)
};

fn main() -> i64 {
    println_i64(FACTORIAL_10); // 3628800
    return 0;
}

fn main() -> i64 {
    let v = Vec::new();
    v.push(10);
    v.push(20);
    v.push(30);

    for i in 0..v.len() {
        println_i64(v[i]);
    }
    return 0;
}