Zeta (programming language)

Zeta
Paradigm	Generic, systems, functional, concurrent, imperative, structured
Designed by	Dr. Roy Murphy
Developer	Zeta Foundation
First appeared	November 27, 2025 (2025-11-27)
Stable release	v0.3.0 / January 20, 2026 (2026-01-20)
Typing discipline	Affine, static, strong, inferred, nominal
Scope	Lexical
OS	Cross-platform
License	MIT
Filename extensions	.z
Website	z-lang.org
Influenced by
Rust, Haskell, Erlang, Zig, OCaml, Julia, Lisp, COBOL, Forth, MATLAB, JavaScript, TypeScript, Python

Zeta is a systems programming language designed for high-performance, safe, and concurrent software development. It emphasizes algebraic data types, affine ownership models, and actor-based concurrency, drawing inspiration from languages such as Rust, Haskell, Erlang, Zig, OCaml, Julia, Lisp, COBOL, Forth, MATLAB, JavaScript, TypeScript, and Python. Zeta's type system integrates concepts from semiring theory to enable optimized algebraic operations, while its borrow checker enforces memory safety without a garbage collector. The language targets LLVM for code generation, supporting just-in-time (JIT) and ahead-of-time (AOT) compilation.

First released on November 27, 2025, Zeta achieved true self-hosting in January 2026. The latest release, v0.3.0 "The Dawn of True Self-Hosting" (January 20, 2026), completes the bootstrap: the compiler now compiles itself almost entirely in Zeta, with only minimal Rust glue remaining for the runtime and JIT. The Zeta compiler is ~3,100 lines and compiles itself in 14 ms on high-end hardware. This milestone builds on rapid progress in JIT execution, concurrency, optimizations, ergonomics, and code-generation maturity.

Zeta's syntax is concise and expression-oriented, with a focus on immutability by default and explicit mutability via borrowing. It supports traits via "concepts" and their implementations, enabling both nominal and structural dispatch. The language is designed for systems-level tasks like operating systems, embedded devices, and distributed systems, with built-in support for constant-time cryptography and standard library embeddings for networking and I/O.

History

Zeta was created by Dr. Roy Murphy, a mathematician, cryptographer, computer scientist, and programmer, who sought to create a language implementing the foundational abstractions in Alexander Stepanov's Elements of Programming in practical form.

The initial prototype was released on November 27, 2025, with rapid iteration leading to self-hosting by January 2026. Development milestones are tracked in the project's development plan on GitHub.

Release History

Version	Date	Notes	Summary of Changes
v0.0.0	November 27, 2025	Initial release	Initial prototype release: Core parser (nom), AST, resolver with type inference/trait resolution, affine borrow checker, MIR, LLVM codegen with JIT; algebraic semiring structures; actor runtime; TimingOwned constant-time guarantees; hybrid traits; defer RAII; standard library embeddings.
v0.0.1	December 4, 2025	Pre-release	Initial alpha release with core compiler: parser, resolver, MIR, LLVM codegen, minimal actor/std runtime.
v0.0.2	December 7, 2025	Pre-release	Self-hosting JIT bootstrap; affine checking; TimingOwned constant-time; type inference/generics/structural; semiring CTFE; actor M:N scheduler; LLVM/SIMD/MLGO improvements.
v0.0.3	December 13, 2025	Pre-release	Unified String type; affine ownership in MIR; semiring operations and CTFE; specialization cache; async with Tokio/mpsc; bootstrap JIT; generics/hybrid dispatch/enums/structs.
v0.0.4	December 14, 2025	Pre-release	Unified str with concatenation, f-strings, rich methods; implicit borrows; zero-cost Vec<u8> interop; structural dispatch.
v0.0.5	December 15, 2025	Pre-release	Unified string support with rich operations; ABI/safety checks; CTFE semiring folding; affine moves; async actor runtime; bootstrap pipeline; optimizations (SIMD/MLGO).
v0.0.6	December 17, 2025	Pre-release	Error propagation (? and Result); dictionary/map support; single-line functions; complex assignments; parsing/AST/resolver/borrow checker/MIR/codegen updates.
v0.0.7	December 17, 2025	Pre-release	Full annotations audit and documentation update; Cargo.toml bump; no breaking changes.
v0.0.8	December 18, 2025	Pre-release	Actor runtime enhancements (global channel map, reqwest HTTP GET, simulated TLS); codegen parameter init fixes; MIR error propagation improvements.
v0.0.9	December 19, 2025	Pre-release	Bug fixes in parser, code generation, and resolver; full enum support; trait resolution and generics for Result/Map; MIR implementation for generics, error propagation, DictLit/Subscripts; monomorphization extraction.
v0.1.0	December 25, 2025		Major refactor into modular layers (frontend/middle/backend/runtime); CacheSafe TBAA/TimingOwned; thin monomorphization; Affine checker 2.0; actor runtime with M:N threads. Comprehensive testing suite added.
v0.1.1	December 27, 2025		Full f-string interpolation with nested expressions; defer statements with RAII lowering; internal fixes for MIR/codegen/TBAA; Rust 2024/Inkwell 7.1/LLVM 21.1/nom 8.0 compatibility. Core language features complete.
v0.1.2	December 28, 2025		Advanced trait resolution with associated types; parametric generics/monomorphization for Result<T>/Map<K,V>; full compile-time function evaluation (CTFE); expanded stable ABI checks with specialization cache. Semantic analysis phase complete.
v0.1.3	December 28, 2025		Algebraic SemiringFold fusion for +/* chains; proper RAII defer lowering (LIFO cleanup); full Result<?> propagation via TryProp MIR; native dictionary literals and subscripting with host map intrinsics. MIR extensions checklist complete.
v0.1.4	December 28, 2025		Pure LLVM str_concat implementation (malloc + memcpy); MLGO-driven optimization pipeline with Grok-recommended passes; full SIMD vectorization of SemiringFold chains; native target configuration and aggressive optimizations. Up to 3.2× speedup on algebraic workloads and 40% smaller binaries. Codegen checklist complete.
v0.1.5	December 29, 2025		"The Optimizer": Full CTFE of binary operations, call chains, and const functions with new CTFE cache; SemiringFold fusion of multiplication chains in MIR for enhanced vectorization; persistent disk caching of monomorphized/specialized functions; codebase cleanup (Mir derives Default, all Clippy warnings resolved). Prepares for concurrency enhancements in v0.1.6.
v0.1.6	December 31, 2025		"The Concurrency Revolution is Here!": Robust actor system with global channel registry, real HTTP GET (reqwest + rustls), single global Tokio runtime.
v0.1.7	January 4, 2026		"Ergonomics Revolution!": Rich string methods, + for concatenation, implicit &str conversions, visual MIR dumps, DWARF metadata.
v0.2.0	January 5, 2026		"The Self-Hosting Dawn!": Core compiler components (parser, AST, borrow checker, resolver, MIR, runtime interfaces) ported to pure Zeta; modular self-hosted structure.
v0.2.1	January 14, 2026		"The Execution Breakthrough!": Real JIT execution from Zeta IR; enhanced emission for locals/calls/branches/dict ops; full host mappings.
v0.2.2	January 20, 2026		"The Bootstrap Breakthrough": Full frontend (parser, AST, borrow checker), middle-end (resolver, CTFE, MIR), backend (LLVM IR emission), and runtime ported to Zeta; non-trivial programs with actors/maps/strings run natively.
v0.2.3	January 20, 2026		"The Execution Horizon": Real execution of Zeta-emitted LLVM IR via full Inkwell-backed JIT; IR loaded, optimized, and executed in-memory with global host function mapping.
v0.3.0	January 20, 2026	Latest release	"The Dawn of True Self-Hosting": Full self-hosted bootstrap achieved; compiler written almost entirely in Zeta (~3,100 LOC); minimal Rust glue for runtime/JIT; affine borrow checker, MIR lowering, and semiring fusion implemented in Zeta; binary identity milestone; compiles itself in 14 ms.

Syntax

Zeta's syntax is C-like but minimalist. Keywords are lowercase, identifiers follow standard conventions, and comments use // or /* */.

Declarations

let x: i64 = 42; // Explicit type
let y = 3.14; // Inferred as f32
let y = y?;
let mut z: i64 = 0; // Mutable

Functions:

fn add<T>(a: T, b: T) -> T {
    a + b
}

Strings

String literals use double quotes. F-strings provide interpolation, and + is sugar for concatenation:

let greeting = "Hello, world!";
let name = "Zeta";
let version = 0.1.5;
let msg = f"Hello {name} v{version}! 🚀";
let concat = "Part one" + " " + "part two";
let lower = msg.to_lowercase();
let len = msg.len(); // i64
let replaced = msg.replace("Zeta", "World");
let bytes: Vec<u8> = msg.as_bytes();
let from_bytes = str::from_bytes(bytes);

Control flow and expressions

Binary operations desugar to concept methods:

let sum = a.add(b); // Equivalent to a + b

Pattern matching:

match value {
    Some(x) => x,
    None => 0,
}

Implementations

The reference implementation zetac is written in Rust (2024 Edition) using Inkwell 0.8.0 with LLVM 21.1 and nom 8.0. Features include JIT execution, thin monomorphization, semiring folding, string literal globals, concat chain optimization, and MLGO-guided passes.

See also

• Rust
• Haskell
• Erlang
• Nim
• Elements of Programming