1. Unified Schema & Types
One table declaration drives SQLite/Turso tables, Rust structs, HTTP handlers, and TypeScript clients. Option[T] and Result[T] replace null and exceptions. Syntax →
Pre-1.0 Research Prototype · v6.8 / Workspace v0.6.0 · Apache-2.0
Vox
One .vox module declares relational schemas, server queries, reactive UI components, durable workflows, and MCP agent tools — projected without drift across SQLite/Turso, Rust (Axum), and React/TypeScript, and supervised in the Vox Axis desktop workbench.
Missing values are Option[T]. Fallible calls return Result[T]. Code that ignores either case does not type-check. Verified across 16,491 CI tests and 32 GUI workbench surfaces.
60s: Zero-Install Playground
Execute a typed .vox program right here in your browser via the capability-sandboxed interpreter (—caps deterministic).
Run that now
Zero Cargo build wait. Edit example.vox below and inspect Turso SQL, Rust Axum, and React TSX in lockstep.
Open 60s Sandbox →
5-Min: Single-File Full-Stack App
Start the 5-Min Single-File Full-Stack App. Unite your schema, backend routes, reactive UI, and agent tool in one module:
Build the 5-Min App →
15-Min: Agent Harness & Vox Axis GUI
Launch the multi-agent harness & native Tauri 2 desktop workbench (vox-axis ↗):
For desktop & harness setup, open #axis-workbench →
import voxlang.vox;
// Sandbox: Tasks queued: 1 | Tasks remaining: 0 -> Ok("done")
────────────────────────────────────────────────────────
export SQL (Turso) {
CREATE TABLE task (id PRIMARY KEY, title TEXT, done INT);
}A typical web app restates one domain model in four places:
Names and types can drift at each boundary. People and coding agents both spend time keeping the copies aligned.

One field, written four times
completed_at, completedAt, and isDone are the same fact. Each boundary renames it or changes its type. A Vox table states it once, and every layer keeps that name and type.
These are the choices that follow from that, and what each one buys.
One declaration, projected. A second schema, written by hand, drifts, and an agent copying it drifts the same way. A table is the source. SQL, the server types, the JSON shape, and the TypeScript client are generated from it. vox build emits SQLite/Turso, Rust (Axum), and React/TypeScript, because one stack is what the tests can actually cover. Django, Vue, and other frameworks are outside that path.
Missing values and failures are typed. Generated code skips a failure it cannot see. Option[T] is Some(x) or None. Result[T] is Ok(x) or Error(msg). Code that ignores either case does not type-check. ? returns the error to the caller.
Ids are typed. A task id and a user id are different facts. A boundary takes Id[Task] rather than a bare string, so the two cannot be swapped.
Keywords open scopes. Decorators modify them. table, query, mutation, server, component, workflow, activity, tool, and resource each open a scope. @auth, @pure, @durable, and @uses change how a declaration runs. One spelling means people and agents copy the same form. A new behavior is a decorator, so the keyword list stays stable.
The same file runs now, or compiles. Scripts, repo automation, and the browser playground should start without a Rust build. A shipped app should be ordinary Rust and TypeScript. vox run interprets the file. --caps is the list of effects the host grants (filesystem, network, and the rest). vox build emits the database, the server, and the client from that same file. The two executors are still being matched, and a generated server build needs a Vox source checkout (VOX_REPO_ROOT).
A tool is a function in the same file. An agent tool kept in a side schema drifts like a hand-written JSON contract. tool is a typed function plus a short description. The program and an MCP client call that declaration, and a failure comes back as Result.
.vox File
Instant Sandboxed Interpretation (vox run —caps) vs. Full-Stack Native Emission (vox build) — The same type-checked AST lowers either to the in-memory capability-gated evaluator or to standalone SQLite/Turso DDL, Rust/Axum server handlers, React 19 / TSX components, and MCP tool schemas.
graph { direction: right node Source: "One .vox Source File" node Check: "vox check (Type & Error Checker)" node Interp: "vox run (Instant Sandboxed Interpreter)" node SQL: "SQLite / Turso Schema" node Server: "Rust (Axum) HTTP Server" node UI: "TypeScript / React UI" node MCP: "MCP Agent Tools" Source -> Check Check -> Interp Check -> SQL Check -> Server Check -> UI Check -> MCP}What do Option[T] and Result[T] mean if I’m coming from Python or JavaScript?
In JavaScript or Python, any variable might secretly be null, undefined, or None, causing your app to crash while a user is clicking around.
Option[T] is a box that explicitly says: “this value might be missing.” It is either Some(value) or None. The Vox compiler makes sure you check both cases before using it.Result[T] is a box for steps that might fail (like saving to a database). It returns either Ok(value) or Error(message). Adding ? to the end of a call (like db.Task.insert(…)?) means: “if this succeeds, unwrap the value; if it fails, stop and return the error immediately.”Read more in the Syntax Reference or try the “2. No Null / Safe Errors” tab in the playground above.
Empirically testing whether a single-file language improves LLM code generation (82.0% Pass@1 vs. 68.0% TypeScript, N = 100, McNemar p = 0.0031) required building the surrounding agent orchestrator, trust-tiered knowledge base, operator workbench, and pure-Rust QLoRA training suite:

Animated Language, Compiler & Verification Suite Tour (vox-foundation/vox) — Cycling through single-file .vox projection, dual execution lanes, durable workflow replay & BLAKE3/HMAC tool receipts, empirical multi-turn compiler feedback benchmarks, and the 6-layer zero-cycle workspace architecture (L0–L5).
1. Unified Schema & Types
One table declaration drives SQLite/Turso tables, Rust structs, HTTP handlers, and TypeScript clients. Option[T] and Result[T] replace null and exceptions. Syntax →
2. Two Execution Lanes
Use vox run for instant, capability-sandboxed script execution in memory, or vox build to emit a standalone Rust (Axum) server and React/TSX frontend. Full-Stack Walkthrough →
3. Durable Workflows
First-class workflow and activity blocks persist call ordinals, signals, and timers to a SQLite journal so long-running jobs resume deterministically after crashes. Workflows →
4. Verified Agent Harness
A built-in 376-tool MCP server and orchestrator issue cryptographic HMAC receipts for tool calls, lock shared files in the task hopper, and route across live OpenRouter and local models. Agent Guide →
5. Trusted Knowledge Base
vox kb indexes curated docs with Tantivy 0.22 and W3C SKOS taxonomy facets while quarantining unverified web scrapes as Untrusted until cleared by the 5-stage Socrates gate. CLI Docs →
6. Native ML & Eval (MENS)
Pure-Rust (Candle) QLoRA training across Metal, CUDA, and CPU plugins, paired with McNemar + Holm compiler-feedback evaluation (vox model eval-compare). Public adapters: Qwen3 0.6B, 1.7B, 4B, and the index. Architecture →
vox-gui): Native Tauri 2 Workbench & VRBS ROMA SimulatorVox Axis (Workbench Guide) is the native Tauri 2 desktop operator console and spatial codebase simulator for the Vox ecosystem. Every one of its 32 workbench views is generated from contracts/operations/catalog.v1.yaml (SURFACE_REGISTRY) and verified via Playwright (axeViolations: 0) across 1280×800, 1440×900, and 1920×1080.

Vox Axis Flagship Workbench Tour (vox-foundation/vox-axis) — Real Playwright captures cycling through the VRBS ROMA 3D/2.5D Codebase Simulator, Imperium Prefecture Blast-Radius Inspector, Mission Control, Multi-Dock Chat, AQVAEDUCTUS 3-Tier Hydraulic Verification Cascade, MENS QLoRA Studio, and the 4-Profile WCAG Theme Contract.
VRBS ROMA, AQVAEDUCTUS, Multi-Dock Chat & MENS Studio)
Projects topological crate layers (L0–L5), Tarjan SCCs, and live git churn onto an interactive isometric metropolis with autonomous A* magistrate patrols (LEGIO-01..03) and the bottom-right FORMA VRBIS 7-Tier Astrolabe Radar.

Clicking any monument opens the bounded Imperium Prefecture dock, showing upstream providers, downstream blast radius, per-file +LoC / -LoC diff slabs, and 1-click [CHECK], [✓ TEST], and [TEST IMPACTED] dispatch controls.

Responsive multi-dock tiling (FOCUS, SPLIT CODE, MULTI-AGENT, TACTICAL MAP ⌘M) with multi-model consensus, git LCA branch diffing, BPE compaction receipts, and cryptographic HMAC tool chips.

Visualizes live model routing as a 3-tier Roman hydraulic sluice cascade (CURSUS I · Fast Local MENS, CURSUS II · Balanced Hybrid, CURSUS III · Deep Frontier) flowing through 4 verification gates (AST PARSE → TYPECHECK → TOESTUB → TEST SUITE).
Light Carrara Marble vs. Dark Minimalist Slate)Every .tsx, .ts, and .css file in Vox Axis is statically gated by vox-code-audit detector vox/ui/theme-contract-drift (Severity::Error) and the unified 4-token typography contract (--font-display, --font-serif, --font-sans, --font-mono), guaranteeing WCAG 2.1 contrast (≥ 4.5:1) and axeViolations: 0 across both light and dark profiles:

Honed Carrara marble surfaces (#FAF6EE), burnished gold mouldings (#C59B27), deep espresso ink (#1C140C), classical Cinzel / Palatino typography, and emerald laurel working signets (#1B6B3A). Also ships with Travertine Daylight (glacier).

Distraction-free basalt/slate dark palette (#0c0e10 / #15191c / #1f262b), crisp Inter + tabular monospace geometry, steel-blue active indicators, and zero marble textures. Also ships with High Contrast Obsidian & Gold (high-contrast, WCAG AAA).
vox-foundation)To keep incremental Rust compile times fast, isolate frontend and documentation toolchains, and enforce a strict air-gap around optional remote telemetry while keeping vox 100% standalone offline, the suite is federated across four repositories governed by README-SYNC-MAP and vox ci cross-repo-parity (55 BLAKE3-verified shared schemas):
| Repository | Role in the Vox Suite | Canonical Scope & Documentation SSOT |
|---|---|---|
vox-foundation/vox | Core Language, Compiler, Harness & ML | .vox parser/typechecker (vox check), capability-sandboxed interpreter (vox run --caps), full-stack Rust/React codegen (vox build), 376-tool MCP server (vox mcp), VoxDb (v97), pure-Rust Candle QLoRA (vox mens), 33 crates.io crates, and the 48-row suite status matrix. |
vox-foundation/vox-axis | Native Tauri 2 Desktop Workbench (vox-gui) | All 32 SURFACE_REGISTRY operator views, the VRBS ROMA 3D/2.5D Codebase Simulator, AQVAEDUCTUS hydraulic verification cascade, 4-profile WCAG theme contract, and Local IPC / Remote TOFU SPKI-pinned TLS transport (Workbench Guide). |
vox-foundation/voxlang.org | Public Portal, Docs Engine & /v1/eval Sandbox | This Astro 7.4 + Starlight 0.42 site (voxlang.org), vox-doc-pipeline compiler-verified .vox doctests, Diátaxis + W3C SKOS taxonomy (kb-taxonomy.v1.yaml), /voxup bootstrap scripts, and the Coolify eval.voxlang.org /v1/eval deterministic browser sandbox. |
vox-foundation/vox-ops (Private) | Optional Telemetry Ingest & Cloud GPU Fleet | Optional remote OTLP/ClickHouse telemetry receiver (vox-ops-telemetry-ingest) and commercial spot GPU broker adapters (vox-plugin-cloud: RunPod, Vast.ai, Together AI). Zero compile or runtime dependencies from vox (vox ci standalone-sovereignty). |
We grade every Vox surface honestly by what works today versus what is still a research prototype. Expand either table below when evaluating Vox for a project:
When Vox Fits (and When You Should Pick Another Tool)
| Tradeoff | Why You Might Like Vox | Why You Might Wait or Pick Another Tool |
|---|---|---|
| Opinionated Stack vs. Bring-Your-Own Framework | You want one .vox file to generate your database schema, backend API, reactive UI, and MCP tools without wiring up four separate frameworks. | Full-stack codegen targets Rust (Axum) + React 19 / TypeScript + SQLite/Turso. If you need a Python/Go backend or Vue/Svelte frontend, Vox won’t emit it. |
| Compile-Time Strictness vs. Loose Scripting | Every possible failure (Result[T]) and optional value (Option[T]) is checked before the program runs — catching bugs that LLMs and humans often miss. | You must handle Ok/Error and Some/None explicitly instead of writing quick untyped code that ignores errors. |
| Interpreter vs. Full-Stack Codegen | vox run runs scripts immediately with zero Rust compile wait and --caps sandboxing; vox build emits native Rust and TypeScript. | Compiling a generated Rust server outside the Vox repo currently requires building vox from a local source checkout (VOX_REPO_ROOT). |
| Pre-1.0 Research Velocity vs. Long-Term Stability | You can inspect an active AI-native language, 32-surface operator workbench (Vox Axis), and QLoRA evaluation lab with candid in-tree audits. | Vox is pre-1.0 prototype software. Syntax and CLI flags still evolve, and there are no prebuilt binary releases yet. |
Surface-by-Surface Stability Matrix (verified 2026-11-10; full 48-row tables in the repository README)
| Surface | Status (2026-11-10) | What Works Today & Known Caveats |
|---|---|---|
Compiler & Type Checker (vox check) | 🟣 Mature / Working | Lexer, recursive-descent parser (57 EBNF rules), HIR lowering, bidirectional type checker, and @ai(structured_output = T) JSON-Schema emission. |
Script Interpreter & Sandbox (vox run) | 🔵 Stable / Working | Runs .vox scripts, table/query/tool modules, repo automation (scripts/*.vox), and this page’s browser sandbox (--caps deterministic). |
Database & Secrets (vox-db, vox secrets) | 🔵 Stable / Working | SQLite/Turso engine at schema baseline 97 and Clavis secret resolution (vox_secrets). |
Curated Knowledge Base (vox kb) | 🔵 Stable / Working | Tantivy 0.22 lexical + RRF hybrid search, W3C SKOS taxonomy facets, and four-tier trust filtering (SystemVerified → Untrusted inbox quarantine). |
Full-Stack Codegen (vox build, vox compile) | 🟡 Preview / Prototype | Emits React 19 / TSX, typed Axum handlers, DB mutations, and Tauri 2 desktop projects. Needs a local Vox source checkout (VOX_REPO_ROOT) to compile generated Rust servers. |
Durable Runtime (workflow / activity) | 🟡 Preview / Prototype | VoxDbTracker SQLite journal replay, activity call ordinals, workflow.version patches, signals, and timers (ADR-019, ADR-021). |
Agent Harness & Vox Axis GUI (vox mcp, vox-gui) | 🟡 Preview / Prototype | 376-tool MCP server with HMAC tool receipts, hopper resource locks, 32 catalog-generated Axis views, VRBS ROMA 3D/2.5D simulator, 4-profile WCAG theme contract, and Remote Axis (TOFU TLS). |
Local ML & Eval (vox mens, eval-compare) | 🟠 Emergent / Prototype | Seeded multi-turn benchmark harness (eval-compare, 82.0% vs 68.0% TS Pass@1) is working. QLoRA training runs on Metal, CUDA, and CPU. Public adapters: 0.6B, 1.7B, 4B, index. |
→ Full 48-row dated tables: vox-foundation/vox README Status · vox-foundation/vox-axis 32-Screen Tour · Stability Matrix · v1.0 Release Criteria
Organized by the Diátaxis framework — structured around what you want to accomplish:
| Goal | Start Here |
|---|---|
| Learn step by step | Installing Vox · Getting Started · First Full-Stack App · Full-Stack Walkthrough · Durable Workflows |
| Follow task recipes | Vox Axis Desktop Workbench · AI Agents & MCP · External App Bootstrap · Troubleshooting FAQ |
| Understand the design | Why Vox for AI · Compiler Architecture · Empirical Vox vs. TS Benchmark · General FAQ |
| Look up exact details | Syntax Reference · CLI Reference · Decorators · Stability Matrix |
| Contribute or audit | Where Things Live · Flywheel & Multi-Repo SSOT · Contributor Hub · Agents Policy (AGENTS.md) |
vox-foundation/vox · vox-foundation/vox-axis · vox-foundation/voxlang.org · GitHub Issues · RSS Feed · LLM Discovery Index (/llms.txt)