The Language That Speaks First to LLMs

One .vox file. Auto-generated database, server, and browser UI — with zero nulls, no boilerplate, and a built-in AI training pipeline.

Get Started Syntax Reference GitHub

“Is it a fact — or have I dreamt it — that, by means of electricity, the world of matter has become a great nerve, vibrating thousands of miles in a breathless point of time?” — Nathaniel Hawthorne, The House of the Seven Gables (1851)

Try it live

Write and execute Vox code directly from the browser.

Vox — Language at a Glance

// One declaration → schema, API, typed client
@table type Task {
    title:    str
    done:     bool
    priority: int
}

// Compile-enforced: every caller handles both branches
@endpoint(kind: query)
fn get_tasks() to List[Task] {
    return db.Task.all()
}

// Expose to AI agents via MCP
@mcp.tool "Mark a task complete"
fn complete(id: Id[Task]) to Result[Unit] {
    db.Task.delete(id)
    return Ok(Unit)
}

Why Vox?

Mainstream languages predate LLMs by decades. They accept implicit state — nulls, exceptions, schemas restated three times across the stack. That’s tractable for humans; it’s a minefield for a statistical code generator.

Vox collapses the common cases. One @table declaration becomes a schema, an API, and a typed client. Errors are values, not exceptions. Browser interactivity is opt-in at explicit boundaries where you need it. Durable execution, MCP tool exposure, and a local training pipeline are built in — not glued on top.

Five Core Pillars

Pillar 1: Single Source of Truth. @table type Task { … } — one declaration becomes SQL migrations, typed API surface, and a typed client. No schema drift across layers.

Pillar 2: Compile-Time Determinism. Result[T] and explicit match — unhandled error branches are compiler failures. Null is not a valid state.

Pillar 3: React Interop via Components and Endpoints. Vox compiles component declarations to plain React/TSX and @endpoint declarations to typed server functions plus a generated vox-client.ts. Import components or call endpoints over the generated RPC bridge — see architecture/external-frontend-interop-plan-2026.

Pillar 4: Durable State & Agent Interoperability. Checkpointing and supervised restart come from vox-workflow-runtime. In source, use @durable on fn and bare workflow / activity / actor blocks per AGENTS.md (Grammar Unification). @mcp.tool exposes functions to MCP-compatible clients.

Pillar 5: Local Training (MENS). vox populi runs QLoRA fine-tunes and OpenAI-compatible serving in native Rust — no Python glue in the default path.

The Language at a Glance

// vox:skip
// One declaration → schema + API + typed client
@table type Task {
    title:    str
    done:     bool
    priority: int
    owner:    str
}

// Compile-enforced: every caller handles both branches
@endpoint(kind: server)
fn get_task(id: Id[Task]) to Result[Task] {
    let row = db.Task.find(id)
    match row {
        Some(t) -> Ok(t)
        None    -> Error("not found")
    }
}

// Expose to AI agents via Model Context Protocol
@mcp.tool "Complete a task by ID"
fn complete_task(id: Id[Task]) to Result[Unit] {
    db.Task.delete(id)
    return Ok(Unit)
}

Stability

Surfaces are tracked by how reproducibly an LLM can target them.

🟢 Stable — contract locked; output on this surface is reproducible across sessions.
🟡 Preview — functionally complete; implementation may still shift.
🚧 Experimental — under active design; not for deployment.

Domain	Tier	What it covers
Compiler engine	🟢 Stable	AST, HIR, type checker, LSP, code generation pipeline.
Surface syntax	🟡 Preview	Decorator + bare-keyword rules in `AGENTS.md`: `@endpoint(kind: …)`, `@durable` on `fn`, bare `workflow` / `activity` / `actor`.
`@table` & data layer	🟢 Stable	Schema, migrations, `db.*` query builder, wire types.
Endpoints (`@endpoint`)	🟡 Preview	Unified shape: `@endpoint(kind: query)`, `server`, or `mutation`.
Agent tooling	🟢 Stable	`@mcp.tool` / `@mcp.resource`, MCP protocol compliance.
Stub detection / AI-laziness gates	🟡 Preview	`vox stub-check` and related CI gates for placeholder code.
RAG & knowledge curation	🟡 Preview	`vox scientia` retrieval, Socrates guards.
Durable execution	🟡 Preview	Grammar includes orchestration blocks and `@durable`; runtime and distributed stories still maturing pre-1.0.
Local training (MENS)	🟡 Preview	Hardware coverage still expanding.
Web UI & rendering	🟡 Preview	`component`, `state_machine`, WebIR, plus React/TSX interop and `vox-client.ts`.
Distributed node mesh	🚧 Experimental	Cross-machine routing is pre-1.0 design.

As of v0.5, 2026. See v1.0 criteria and the GUI-native roadmap; changes also land in the repository CHANGELOG.md.

Documentation

Organized by the Diátaxis framework — structured by user intent, not by feature.

Intent	Start here
Learning	Getting Started · First full-stack app
Task recipes	How-To Guides · AI Agents & MCP
Understanding	Why Vox for AI · Compiler architecture
Reference	CLI · Decorators
Architecture	Research index · Where things live · Contributor hub

Community, Backing & License

Open Collective. Community-backed via Open Collective — every dollar raised and spent is public.

License. Apache 2.0 — commercial use permitted, patent rights granted, modifications allowed with attribution.

Get involved. GitHub Discussions · RSS Feed · Contributor Hub