Stage 1 (axiom-lang) & Stage 2 (axiom-ui) Live in Production

Software Written by AI Agents. Verified by Mathematics.

Axiom replaces human-era boilerplate, silent AI placeholder stubs, ambient dependency privileges, and 250 MB Electron bundles with a 3-layer verified programming stack that compiles directly to kilobyte-scale W3C WebAssembly and Linux x86_64 machine code — with zero rustc and 1-draw-call hardware GPU rendering.

6.84 KB Gzipped 4-Window GPU Desktop OS (workspace.wasm)
1,000,000 Virtualized GPU Spreadsheet Cells @ 0.50 ms Layout
1 Draw Call Unified WebGL2 SDF + HiDPI Font Atlas Compositor
100% Z3 Compile-Time Anti-Stub SMT Proofs & Non-Zero Guards
0 Ambient I/O Unforgeable axiom.passport Capability Gatekeeper

Why Human-Era Languages Break When AI Writes the Code

Python, TypeScript, C++, Go, and Rust were shaped around human typing habits and manual code review. Autonomous multi-agent engineering exposes three structural flaws:

1. Silent Stubs Compile Cleanly Solved by Telos

An LLM agent can return balance without deducting amount or emit a placeholder stub, and traditional typecheckers accept it. In Axiom, Microsoft Z3 proves every postcondition (ens) mathematically before a node can enter the graph — or rejects it with an exact counterexample.

2. Hidden Supply-Chain Privileges Solved by Flux

In npm or Cargo ecosystems, a transitive helper 15 levels deep can read ~/.ssh or open outbound sockets. In Axiom, functions live in a fileless 256-bit content-addressed graph with explicit capability arrows -[Net("api.bank.com"), Mem]-> and opaque Secret<T> taint pipes.

3. Electron & DOM Bloat Solved by Strata + UI

Shipping 250 MB of Chromium + V8 + CSS reflow just to render tables and windows wastes gigabytes of RAM and millions of LLM context tokens. Axiom compiles directly to 15–30 KB standalone WebAssembly driving hardware WebGL2 in a single instanced draw call.

The Three Orthogonal Layers of Project Axiom

Instead of juggling separate languages for specifications, backends, shaders, and UI, Axiom separates software strictly by the physics of computation — all three layers are implemented natively in aminadav-ai/axiom-lang:

Axiom.Telos Intent & Proofs

Preconditions (req), postconditions (ens), division-by-zero prevention, scroll/layout bounds, and vacuous-precondition reward-hacking checks proved mechanically at compile time via Z3 SMT.

Axiom.Flux Semantic Graph

De Bruijn normalized, SHA-256 content-addressed functions (zero import collisions, automatic cross-repo deduplication), capability effect arrows, Secret<T> exfiltration blocking, and deterministic axiom.passport manifests.

Axiom.Strata Bare Silicon & GPU

Bounded loops (while cond max N), deterministic 8 MiB hardware-masked linear memory, static zero-copy string pools, -[Mem, Gpu]-> streams, and direct zero-rustc emission to .wasm and 1.45 KB Linux x86_64 ELF64 binaries.

Compile-Time Z3 Anti-Stub Rejection Axiom.Telos
fn withdraw_stub(balance: i64, amount: i64) -> i64
  req balance >= amount && amount > 0
  ens result == balance - amount && result >= 0
{
  balance // <-- AI agent forgot to deduct `amount`!
}

// Compiler Output (Rejected in 42ms):
// error [E050_CONTRACT_VIOLATION]: Postcondition #1 failed
//   counterexample: { amount = 1, balance = 1, result = 1 }
Unforgeable Compiler Security Passport Axiom.Flux
=== AXIOM SECURITY PASSPORT ===
Node:               #768a631876e7 (checkout)
Touches Secret<T>:  YES
Capabilities:
  [CAP]  Audit                via: checkout -> send_bank_wire
  [CAP]  Net("api.mybank.com") via: checkout -> send_bank_wire
Secret Data-Flow Pipes:
  [PIPE] Secret<str> -> Net.post("api.mybank.com")
  [SAFE] Disk / Log / Unpinned Leaks: 0 (proved by taint checker)

Stage 2 Live Showcase: axiom-ui Zero-DOM Hardware GPU Suite

Four complete desktop-class applications written 100% in Axiom without a single HTML widget or CSS layout rule. Click any preview to run the live WebAssembly binary right on this page, or open it full-screen:

Axiom Grid 1,000,000-cell GPU spreadsheet screenshot
21.65 KB Wasm 7.93 KB Gzip 1,000,000 Cells

Axiom Grid v1.0 — 1M-Cell GPU Spreadsheet

Excel-class 1,000 × 1,000 (A1..ALL1000) virtualized spreadsheet with live =SUM, =AVG, =MAX & cell arithmetic, emerald dependency highlighting, editable fx bar, live bound Q1–Q4 GPU charts, and Strata Time-Travel.

Fullscreen GitHub Repo
Axiom Workspace 4-window GPU desktop OS screenshot
20.57 KB Wasm 6.84 KB Gzip 1 Draw Call

Axiom Workspace v1.0 — "The Electron Killer"

Multi-window GPU Desktop OS featuring 4 overlapping, draggable, hardware-clipped resizable windows: live Flux Secret<T> Taint Graph, Electron vs Axiom RAM Stress-Test, Z3 Safe-Division Calculator, SDF Shader Studio, and full-OS Time-Travel.

Fullscreen GitHub Repo
Axiom Capsule Browser prototype screenshot
21.21 KB Wasm 7.04 KB Gzip 0.14 ms HTML Parse

Axiom Capsule Browser v1.0 — Future + Legacy Web

Working prototype of axiom-web: executes verified .axw capsules natively on GPU, halts spyware capsules before Wasm byte 0 via axiom.passport (with network-stripped sandbox mode), and sanitizes legacy HTML in pure Axiom with zero JS executed.

Fullscreen GitHub Repo
Axiom-UI interactive component gallery screenshot
15.34 KB Wasm 5.38 KB Gzip 0.20 ms Layout

Axiom-UI v1.0 — Core Engine & Widget Gallery

Unified 1-Draw-Call SDF & HiDPI 3-style Font Atlas engine: native GPU keyboard text input, tactile SDF switches, sliders, real-time anti-aliased vector waveform, Z3 layout proof inspector, 3 live themes, and 120-frame UI Time-Travel.

Fullscreen GitHub Repo

Stage 1 Live Showcase: True-3D Hardware GPU Games & Taint Inspector

Three complete browser games featuring procedural 256×256 bump-mapped textures, real-time lighting, Web Audio synthesis, and deterministic physics — written 100% in Axiom with zero game engine and zero rustc:

Axiom Slipgate 3D shooter screenshot
30.38 KB Wasm 11.66 KB Gzip WebGL2 3D FPS

Axiom Slipgate v2.0 GPU HD

Quake-inspired true-3D polygonal citadel shooter with procedural bump-mapped stonework, multi-tier walkable terraces (Space jump), exact 3D ray-box pillar cover, sculpted 3D Shambler/Knight/Grunt enemies, and cylindrical Super-Shotgun.

Fullscreen GitHub Repo
Axiom Lion Herd 3D savanna game screenshot
17.87 KB Wasm 7.24 KB Gzip 10,284 3D Tris

Axiom Lion Herd v3.0 GPU HD

True-3D sculpted savanna plateau with 8 procedural bump-mapped materials, 14 autonomous Merino sheep with flocking physics, sculpted 3D maned lion, golden roar shockwave ring, acacia trees, and real-time directional sun shadows.

Fullscreen GitHub Repo
Axiom Color Lines 98 3D refractive glass puzzle screenshot
15.32 KB Wasm 5.82 KB Gzip 3D Refraction

Axiom Color Lines 98 v3.0 GPU HD

Carved Nero Marquina & Crema Marfil marble board with 3D refractive glass jewel spheres, colored floor caustics, animated parabolic 3D BFS hop trajectories with synthesized audio clicks, and turn-by-turn Time-Travel.

Fullscreen GitHub Repo
Axiom compiler Secret<T> payment inspector screenshot
32.30 KB Wasm Z3 8/8 Proved Secret<T> Guard

Axiom Compiler & Taint Flight Recorder

Interactive showcase of Axiom.Flux semantic deduplication (two AI agents writing differently named functions converge to identical hash #3fca26293539), Secret<str> redaction, and Time-Travel replay.

Fullscreen GitHub Repo

Measured Engineering Benchmarks

Side-by-side comparison between conventional Electron / Chromium + Virtual-DOM stacks and verified Axiom binaries running in production today:

Production metrics measured across Axiom v0.2 and Axiom-UI v1.0 artifacts
Dimension Legacy Electron / DOM + JS Axiom v0.2 + Axiom-UI v1.0 Measured Gain
Desktop / UI App Payload 180 MB – 300 MB bundle 15.34 KB – 21.65 KB Wasm (5–8 KB gzip) > 10,000× smaller
Runtime Memory Footprint 450 MB – 950 MB (V8 + Blink DOM) 8.00 MiB deterministic Strata slab -98.7% RAM
1,000,000-Cell Grid Layout DOM thrashing / multi-frame GC stalls 0.50 ms single-pass virtualized GPU emit Zero DOM nodes
GPU Compositing Calls Dozens of layer passes & CSS reflows 1 gl.drawArraysInstanced call / frame 60–120 FPS locked
AI Placeholder Stub Defense Compiles silently if types match Compile-time Z3 SMT proof obligation Counterexample in ms
Supply-Chain Security Ambient filesystem & network access Embedded axiom.passport + Secret<T> pipes Halted before byte 0
Native Linux Executable Multi-megabyte toolchain + libc 1.45 KB direct x86_64 ELF64 (zero rustc) 2.97 ms codegen

The 7-Stage Axiom Master Roadmap

Axiom is engineered step-by-step toward a complete self-hosted, mathematically verified computing stack:

Stage 1 — axiom-langCOMPLETED

Content-addressed Flux graph, Z3 Telos contract prover, Secret<T> taint checker, and direct zero-rustc Strata Wasm & Linux x86_64 ELF64 compilers + 3 true-3D WebGL2 games.

Stage 2 — axiom-uiCOMPLETED

Zero-DOM, Zero-CSS 1-Draw-Call WebGL2 SDF & HiDPI Font Atlas UI engine powering axiom-grid (1M cells), axiom-workspace (4-window Desktop OS), and axiom-capsule-browser.

Stages 3 & 4 — axiom-studio (+ shell)NEXT UP

Ultra-lightweight native AI-agent IDE built on axiom-ui with integrated natural-language command shell, Cyrillic/UTF-8 GPU typography, live Z3 & Passport inspector, and multi-model Gemini 4 agent loop.

Stage 5 — axiom-webPROTOTYPE LIVE

Standalone capability-gated .axw capsule player combined with zero-JS Legacy HTML Clean-Reader (prototype live today in axiom-capsule-browser).

Stage 6 — axiom-zeroPLANNED

Full compiler, canonicalizer, and verifier self-hosting directly on Axiom.Strata.

Stage 7 — axiom-osPLANNED

Bootable minimal live-USB capability operating system running verified Axiom capsules directly on hardware.