Zeta v1.0.1: The Foundational Release — Pure Zeta, Self-Hosting, Ready
May 3, 2026 — Roy Murphy
v1.0.1 is here. This isn't just another version bump. This is the first release of Zeta where every line of the compiler — every lexer rule, every MIR pass, every LLVM codegen path — is written in Zeta itself. The Rust bootstrap is gone. The scaffolding is gone. What remains is pure, self-hosted Zeta — a language that compiles itself, runs everything, and asks nothing of you but your code.
If you've been watching Zeta from the sidelines, now is the moment to get your hands dirty. v1.0.1 is a foundational release — not a beta, not a prototype, but a production-ready compiler with a full standard library, WebAssembly support, compile-time evaluation, SIMD, an actor runtime, and the same performance that's been winning benchmarks since day one. It ships as a single static binary with zero dependencies. Download it, run it, and feel what a language built from first principles actually does.
What Changed: The Rust Bootstrap is Dead
Every previous version of Zeta relied on a Rust bootstrapper to get off the ground. The parser was Rust. The type checker was Rust. The codegen was Rust. v0.3.0 proved Zeta could compile itself, but the Rust skeleton was still in the closet. Not anymore.
v1.0.1 removes every Rust source file. The src/ directory now holds 51+ pure Zeta source files — the frontend, the middle-end, the backend, the runtime, the standard library, the test suite. The compiler binary in bin/zetac was compiled by Zeta from Zeta code. If you clone the repo and run ./bin/zetac src/main.z -o zetac, you get the same compiler back. That's the full bootstrap loop, closed forever.
The Language: Designed, Not Accumulated
Zeta didn't evolve by bolting features onto a C heritage. It was designed from Alexander Stepanov's algebraic foundations — every abstraction is mathematically grounded, every optimization is provable, and nothing exists that doesn't earn its keep.
Strong Static Typing with Inference
fn add(x: i64, y: i64) -> i64 {
return x + y;
}
fn infer() {
let x = 42; // inferred i64
let y = 3.14; // inferred f64
let b = true; // inferred bool
}Algebraic Data Types
Structs, enums, tuples — the full toolkit for modeling data without ceremony.
struct Point { x: i64, y: i64 }
enum Option<T> {
Some(T),
None,
}
fn origin() -> Point {
return Point { x: 0, y: 0 };
}Generics, Concepts & Specialization
Parametric polymorphism with concept constraints, monomorphization, and concept-based refinement hierarchies from Stepanov's Elements of Programming.
fn identity<T>(x: T) -> T { return x; }
fn max<T: Ord>(a: T, b: T) -> T {
if a >= b { return a; }
return b;
}First-Class Functions & Closures
Functions are values. Closures capture their environment. Higher-order programming is not a library trick — it's baked into the type system.
fn make_adder(n: i64) -> (i64) -> i64 {
return fn(x: i64) -> i64 { x + n };
}Compile-Time Evaluation (CTFE)
Execute arbitrary Zeta code at compile time with comptime blocks. Algebraic semiring fusion enables mathematical optimization during compilation — your runtime gets the result for free.
const FACTORIAL_10: i64 = comptime {
fn fact(n: i64) -> i64 {
if n <= 1 { return 1; }
return n * fact(n - 1);
}
fact(10)
};
// FACTORIAL_10 = 3628800 — zero runtime costThe Standard Library: Three Tiers, 20+ Modules
v1.0.1 ships with a comprehensive standard library organized in three tiers:
- Tier 1 — Core:
std::mem,std::ptr,std::cmp,std::hash,std::iter,std::vec,std::string,std::option,std::result - Tier 2 — Systems:
std::fs,std::path,std::net,std::sync,std::io - Tier 3 — Advanced:
std::char,std::time::Duration,std::process::Command,std::thread,std::collections,std::ffi
Every module is written in self-hosted Zeta. Every function is available without extern blocks or FFI glue. If you can write it in C, you can write it in Zeta — and it will compile faster and run leaner.
WebAssembly: First-Class Target
Pass --target wasm32 and Zeta compiles straight to WebAssembly through the same LLVM codegen that produces native binaries. No runtime, no polyfills, no JavaScript glue — just a ~4 kB .wasm module that runs in any Wasm runtime.
# Same source, two targets:
./bin/zetac hello.z -o hello # native binary
./bin/zetac --target wasm32 hello.z -o hello # WebAssemblyError Messages That Actually Help
Every compiler error has a unique code (E1001–E9015). 175+ distinct codes covering syntax, type mismatches, resolution failures, and codegen issues — each with a human-readable explanation and a suggestion for how to fix it. No more cryptic one-liners in a terminal.
error[E2001]: type mismatch: expected i64, found str
┌─ src/main.z:12:13
│
7 │ let x: i64 = "hello";
│ ^^^^^^^ expected i64, found strCorrectness by Default
Precondition and postcondition assertions are baked into the language:
fn divide(a: i64, b: i64) -> i64 {
pre(b != 0, "division by zero");
return a / b;
}
Loop invariants, mathematical property annotations (#[commutative], #[associative], #[identity]), and a concept refinement lattice that mirrors Stepanov's algebraic hierarchy — from Regular through Semigroup, Monoid, Group, to Ring. Not a linter. Not a proof assistant bolted on the side. Built in from the ground up.
Why This Matters
Every new systems language promises to be better than C. Most deliver marginal improvements at the cost of complexity — lifetimes, borrow checkers, trait gymnastics, build system baggage. Zeta doesn't play that game.
v1.0.1 proves that a language can be minimal, safe, fast, and self-hosting without sacrificing any of those properties. The compiler compiles itself in milliseconds. The binaries are kilobytes. The feature set is comprehensive but not bloated. The standard library covers everything you need to build real software — networking, filesystems, threading, SIMD, WebAssembly.
This is not a research project. This is not a toy. This is a production-ready systems programming language that ships today.
Get Started in 30 Seconds
git clone https://github.com/murphsicles/zeta.git
cd zeta
./bin/zetac examples/hello.z -o hello
./hello
No package manager. No dependency hell. No curl | sh. Just a binary and your code.
"The language that will outlive its bootstrap."
v1.0.1 is the foundation. Everything builds on top from here — the package ecosystem, the MLGO integration, the SIMD autotuner, the distributed runtime. But the foundation is pure Zeta, and it will never need to be laid again.
Download it. Try it. Break it. Tell us what you think on GitHub. The future of systems programming isn't coming — it's here, it's self-hosted, and it's called Zeta.