Skip to content

Vox

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.

Vox — Single-file full-stack programming language, capability-sandboxed interpreter, and AI-native verification suite

Build in One Voice

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:

  • table Task → Turso / SQLite schema (Id[Task])
  • query & mutation → Typed Rust Axum API
  • component TaskBoard() → Reactive React 19 TSX
  • tool “complete_task” → MCP Agent Schema

Build the 5-Min App →

15-Min: Agent Harness & Vox Axis GUI

Launch the multi-agent harness & native Tauri 2 desktop workbench (vox-axis ↗):

  • Step 1: Replayable workflow & activity journals
  • Step 2: Clavis vox secrets & capability sandboxing
  • Step 3: Multi-dock Loquela posture controls (Alt+1..4)
  • Step 4: VRBS ROMA 3D/2.5D simulator & 32 workbench views

For desktop & harness setup, open #axis-workbench →

.voxCompiler Playground
1 .vox File -> 4 Targets1.vox.voxCompilerRuntimeSQLRustTargets
example.vox ×
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);
}

Why Vox

A typical web app restates one domain model in four places:

  1. A database schema (SQL or an ORM migration).
  2. A backend (Rust, Go, Python, or Node) that validates and serves it.
  3. A wire contract, usually JSON.
  4. A frontend (TypeScript/React) that reads that JSON.

Names and types can drift at each boundary. People and coding agents both spend time keeping the copies aligned.

One field written four times: SQL completed_at, Rust Option DateTime, JSON completedAt null, and TypeScript isDone, beside one Vox table that emits done: bool to every layer

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.

Two Execution Lanes for One .vox File

Vox Dual Execution Lanes: Capability-Sandboxed Interpreter (vox run --caps) vs Full-Stack Native Compiler (vox build)

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.

Two Execution Lanes for One .vox File, diagram 17 nodes, 6 edges: One .vox Source File → vox check (Type & Error…; vox check (Type & Error… → vox run (Instant Sandbo…; vox check (Type & Error… → SQLite / Turso Schema; vox check (Type & Error… → Rust (Axum) HTTP Server; vox check (Type & Error… → TypeScript / React UI; vox check (Type & Error… → …One .vox Source Filevox check (Type & ErrorChecker)vox run (Instant SandboxedInterpreter)SQLite / Turso SchemaRust (Axum) HTTP ServerTypeScript / React UIMCP Agent Tools
Diagram source
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.


How the Vox Suite Works

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 WebP tour of the Vox Language & Verification Suite: Single-file .vox grammar projection, Dual execution lanes, Durable workflows & cryptographic MCP receipts, Empirical benchmark + MENS QLoRA, and 6-layer crate architecture

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 Axis (vox-gui): Native Tauri 2 Workbench & VRBS ROMA Simulator

Vox 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.

Animated WebP tour of Vox Axis: VRBS ROMA Codebase Simulator, Imperium Blast-Radius Inspector, Mission Control Dashboard, Multi-Dock Chat + Aqueduct Cascade, MENS Corpus Studio, Needs You DAG, and Enforced Theme Contract

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.

Key Operator Surfaces (VRBS ROMA, AQVAEDUCTUS, Multi-Dock Chat & MENS Studio)

VRBS ROMA 3D/2.5D Isometric Codebase Civilization Simulator and Forma Urbis 7-Tier Astrolabe Radar
gamify · VRBS ROMA

3D/2.5D Codebase Civilization Simulator

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.

Imperium Prefecture Dock and Dependency Blast-Radius DAG Inspector
ImperiumInspector.tsx

Blast-Radius DAG & Monument Inspector

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.

Multi-Dock Responsive Chat Workbench with VRBS ROMA Simulator and AQVAEDUCTUS Cascade
chat · Loquela (Alt+1..4)

Multi-Dock Chat & Posture Steering

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.

AQVAEDUCTUS 3-Tier Hydraulic Verification Cascade and Parallel Agent Execution Braid
harness · AQVAEDUCTUS

3-Tier Hydraulic Verification Cascade

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).

Inline Dual-Theme Verification (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:

Vox Axis Light Theme: Sunlit Imperial Carrara White and Gold (arcane)
Light Default · arcane

Sunlit Imperial Carrara White & Gold

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).

Vox Axis Dark Theme: Minimalist Grey-Blue Slate (slate)
Dark Mode · slate

Minimalist Grey-Blue Slate & High-Contrast AAA

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).


Ecosystem Separation of Concerns (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):

RepositoryRole in the Vox SuiteCanonical Scope & Documentation SSOT
vox-foundation/voxCore 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-axisNative 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.orgPublic Portal, Docs Engine & /v1/eval SandboxThis 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 FleetOptional 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).

Tradeoffs & Current Stability (Progressive Deep Dive)

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)

TradeoffWhy You Might Like VoxWhy You Might Wait or Pick Another Tool
Opinionated Stack vs. Bring-Your-Own FrameworkYou 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 ScriptingEvery 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 Codegenvox 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 StabilityYou 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)

SurfaceStatus (2026-11-10)What Works Today & Known Caveats
Compiler & Type Checker (vox check)🟣 Mature / WorkingLexer, 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 / WorkingRuns .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 / WorkingSQLite/Turso engine at schema baseline 97 and Clavis secret resolution (vox_secrets).
Curated Knowledge Base (vox kb)🔵 Stable / WorkingTantivy 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 / PrototypeEmits 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 / PrototypeVoxDbTracker 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 / Prototype376-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 / PrototypeSeeded 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


Self-Maintaining Documentation & Architecture Map

Organized by the Diátaxis framework — structured around what you want to accomplish:

GoalStart Here
Learn step by stepInstalling Vox · Getting Started · First Full-Stack App · Full-Stack Walkthrough · Durable Workflows
Follow task recipesVox Axis Desktop Workbench · AI Agents & MCP · External App Bootstrap · Troubleshooting FAQ
Understand the designWhy Vox for AI · Compiler Architecture · Empirical Vox vs. TS Benchmark · General FAQ
Look up exact detailsSyntax Reference · CLI Reference · Decorators · Stability Matrix
Contribute or auditWhere Things Live · Flywheel & Multi-Repo SSOT · Contributor Hub · Agents Policy (AGENTS.md)

Community, Stewardship & License