Vox: The AI-Native Programming Language

Pre-1.0 Research Prototype · Workspace v0.6.0 · Apache-2.0

One Language for Database, Server, UI, and AI Agents

Write one .vox file and run it immediately in a sandboxed interpreter, or compile it into a SQLite/Turso schema, a Rust (Axum) backend, and a TypeScript/React frontend — with no null values and every error checked at compile time.

Get Started →Try in Browser ↓Syntax Reference GitHub ↗

Why Vox

When you build a web application in mainstream languages, you usually write the same idea four separate times:

A database table (in SQL or an ORM migration).
A backend data struct and API route (in Rust, Go, Python, or Node).
A network client that serializes JSON over HTTP.
A frontend interface (in TypeScript/React) that unpacks that JSON and renders it.

Mainstream languages predate large language models (LLMs) by decades. They tolerate implicit state — null pointers, undeclared exceptions, and schemas restated three or four times across the stack. Experienced developers keep those layers in sync by habit, but for both beginning programmers and statistical AI code generators, every boundary is a place where field names drift, types mismatch, or error handling gets skipped. A million-token context window doesn’t help when most of it is glue code.

A diagram illustrating the complexity of traditional web development fragmentation.

Fragmentation in Traditional Web Development
Traditional development requires restating data models and logic across frontend, API, backend, and database layers. This duplication creates maintenance overhead and increases the risk of integration drift.

Vox is what falls out when you design the language after the model:

Declare data once. One table declaration generates the SQL schema, the backend types, the HTTP wire format, and the TypeScript client.
No null, no uncaught exceptions. Missing values use Option[T] (Some(x) or None) and operations that can fail return Result[T] (Ok(x) or Error(msg)). The compiler refuses code that ignores an error.
One file, clear boundaries. Database queries (query / mutation), server endpoints (server), UI components (component), durable workflows (workflow / activity), and AI agent tools (tool / resource) live in a single .vox grammar with one consistent rule: bare keywords open scopes, and @decorators modify declarations.

Try it

Edit the code below and click Run to execute it in the sandboxed Vox interpreter (vox run --interp --caps deterministic).

Vox — Language at a Glance

// One declaration → schema, wire format, typed client
table Task {
  title: str
  done:  bool
}

query get_tasks() to int {
  return len(db.Task.all())
}

tool "Mark a task complete" complete(id: Id[Task]) to Result[str] {
  db.Task.delete(id)?
  return Ok("done")
}

fn main() to Result[str] {
  let id = db.Task.insert({ title: "Write Vox in the browser", done: false })?
  print("Tasks queued: " + str(get_tasks()))
  let status = complete(id)?
  print("Tasks remaining: " + str(get_tasks()))
  return Ok(status)
}

How to Read the Example Above (For Beginners)

table Task { ... } creates a database table with title (text) and done (true/false) columns, plus an automatic typed ID (Id[Task]) so you can never accidentally pass a user ID where a task ID is expected.
query get_tasks() to int defines a read-only database query returning an integer (int).
tool "..." complete(...) to Result[str] defines a function that both your program and AI assistants (via the Model Context Protocol) can call. Its return type Result[str] means it either succeeds with Ok("done") or returns an Error. The ? after db.Task.delete(id)? automatically returns early if the database step fails.
fn main() to Result[str] is the script entry point when you click Run or execute vox run in your terminal.

How the Vox Suite Works

Vox combines the language with an AI-native toolchain in one repository. Six pillars connect the workflow from writing code to running agents:

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.

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.

3. Durable Workflows

First-class workflow and activity blocks persist call ordinals, signals, and timers to a SQLite journal so long-running jobs can resume after crashes.

4. Verified Agent Harness

A built-in MCP server and orchestrator issue cryptographic HMAC receipts for tool calls, lock shared resources in the task hopper, and route across live OpenRouter and local models.

5. Trusted Knowledge Base

vox kb indexes curated docs with Tantivy and SKOS taxonomy facets while quarantining unverified web scrapes and agent notes as Untrusted in a review inbox.

6. Native ML & Eval (MENS)

Pure-Rust (Candle) QLoRA training across Metal, CUDA, and CPU plugins, paired with seeded multi-turn compiler-feedback evaluation (vox model eval-compare).

→ Deep dive into the compiler pipeline and IR stages: Compiler Architecture

Tradeoffs: When Vox Fits (and When It Doesn’t)

We want you to know the costs of Vox’s design before you invest time learning it:

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, and frontend UI without wiring up four separate tools.	Full-stack codegen targets Rust (Axum) + React/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 beginners 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, agent harness, and 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.

Current State & Stability

Surfaces are graded honestly by what works today versus what is still a prototype (last reviewed 2026-10-13):

Surface	Status	What Works Today & Known Caveats
Compiler & Type Checker (`vox check`)	🟣 Mature / Working	Lexer, recursive-descent parser, 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 96 and `Clavis` secret resolution (`vox_secrets`).
Curated Knowledge Base (`vox kb`)	🔵 Stable / Working	Tantivy 0.22 lexical search, SKOS taxonomy facets, and four-tier trust filtering (`SystemVerified` → `Untrusted` inbox quarantine).
Full-Stack Codegen (`vox build`, `vox compile`)	🟡 Preview / Prototype	Emits React/TSX, typed Axum handlers, DB mutations, and Tauri desktop projects. Needs a local Vox source checkout (`VOX_REPO_ROOT`) to compile generated Rust servers.
Durable Runtime (`workflow` / `activity`)	🟡 Preview / Prototype	Host-bridge execution with SQLite journal replay, activity call ordinals, signals, and timers (ADR-019, ADR-021).
Agent Harness & Operator GUI (`vox mcp`, `vox-gui`)	🟡 Preview / Prototype	MCP server with HMAC tool receipts, task-hopper resource locks, live OpenRouter model routing, `⌘K` capability palette, and Remote Axis (TOFU TLS).
Local ML & Eval (`vox mens`, `eval-compare`)	🟠 Emergent / Prototype	Seeded multi-turn benchmark harness (`eval-compare`) is working; QLoRA training runs on Metal/CUDA/CPU plugins, with no published model weights yet.

→ Full per-component status tables and audit links: Stability Matrix · v1.0 Release Criteria

Documentation Map

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 · Durable Workflows
Follow task recipes	External App Bootstrap · AI Agents & MCP · Troubleshooting FAQ
Understand the design	Why Vox for AI · Compiler Architecture · General FAQ
Look up exact details	Syntax Reference · CLI Reference · Decorators · Stability Matrix
Contribute or audit	Where Things Live · Contributor Hub · Agents Policy (`AGENTS.md`)

Community, Stewardship & License

Stewardship. Stewarded by the Vox Foundation (in formation) and backed by the community via Open Collective with a public ledger.
License. Apache 2.0 — free for personal, academic, and commercial use with attribution.
Links. GitHub Repository · GitHub Issues · RSS Feed · LLM Discovery Index (/llms.txt)