Vox

Live in production

A programming language designed so you describe your data once and get a matching database, server, and client.

Vox showing its documentation home page with a guide sidebar and the language overview

Current status

Open-source Rust compiler and language documentation live at voxlang.org.

Overview

Programming language and full-stack toolchain where defining your data model once automatically generates the database schema, backend API routes, and typed frontend client.

Why it was built

Modern web apps force teams to write the same data structure four times—in database migrations, backend models, API validators, and frontend types—creating bugs every time a field changes.

Why it helps

Lets humans and AI coding assistants build complete, type-checked web applications in a single `.vox` file with APIs that stay in sync and strict compile-time error handling.

What you can do

Declare-once data models that generate database tables, server endpoints, and TypeScript clients
Fast Rust-built compiler, type checker (`vox check`), and sandboxed script runner (`vox run`)
Built-in editor autocomplete (LSP) and AI assistant integration out of the box
Public open-source language specification and interactive documentation at voxlang.org

Vox • Core Technology & Feature Architecture

AI-Native Rust Programming Language, P0–P5 Type System & Socrates Gate

Compiles single-file .vox specifications (table, query, mutation, component, routes, @mcp.tool) into full-stack Axum + React + TanStack Start + Turso applications with built-in epistemic confidence gating.

vox-compiler + HirModule

Declare-Once Full-Stack Rust, TypeScript & Turso SQL Codegen

Lowers declarative table, query, mutation, workflow, component, and routes constructs through a unified HIR pipeline into type-safe Rust Axum handlers, SQLite/Turso DDL schemas, and typed React clients.

P0–P5 Language Design

Structural UI Invariants & Zero Syntax Ambiguity

Makes invalid states unrepresentable at compile time (contrast-checked color types, overflow-checked geometry, local layer kinds instead of arbitrary z-index integers) with one canonical syntax shape per concept.

vox-socrates + vox-mens

Five-Signal Epistemic Gate & Native QLoRA Memory

Fuses evidence quality, citation coverage, logprobs, semantic entropy, and self-consistency into answer/hedge/clarify/abstain decisions while Mens trains local Candle QLoRA adapters on verified golden .vox programs.

vox-mcp + vox-clavis + ludus

Zero-Trust Secret Vault, MCP Tool Mesh & Ludus Quests

Exposes compiler diagnostics and AST symbol search over MCP, classifies tool side-effects (read_only, local_mutation, external_side_effect), guards secrets via Clavis, and gamifies engineering milestones via Ludus.

Vox • Single-File Full-Stack Compiler (`HirModule`) Explorer

Inspect golden `.vox` programs and their generated Rust Axum + Turso + React output

Source: examples/golden/blog_fullstack.vox

table Post {
    title: str
}

query list_posts() to int {
    return len(db.Post.all())
}

mutation publish_post(title: str) to Result[str] {
    db.Post.insert({ title: title })?
    return Ok("published")
}

component BlogHome() {
    state n: int = 0
    view: column() {
        text() { "blog" }
        link(href="/console") { "Open studio" }
    }
}

routes {
    "/" to BlogHome
}

Deterministic Compiler Output (`vox check` → `HirModule`)

-- 1. Turso / SQLite DDL (vox-db)
CREATE TABLE IF NOT EXISTS post (id INTEGER PRIMARY KEY, title TEXT NOT NULL);

// 2. Rust Axum Router & Handler (vox-compiler -> HirModule)
app.route("/api/query/list_posts", get(handle_list_posts))
   .route("/api/mutation/publish_post", post(handle_publish_post));

// 3. Typed React + TanStack Client RPC
export async function publishPost(title: string): Promise<Result<string>>

Before & After Engineering AuditCompiler & Epistemic Verification4 files → 1 .vox spec · P0 compile-time UI/SQL safety

Single-file .vox declaration vs. 4-layer full-stack boilerplate

Comparison focus

Before: 4 separate files (~145 lines, 4 schema drift points)

Traditional stacks duplicate the same Post schema across SQL migrations, ORM models, Express/Axum route validators, and untyped frontend fetch() calls.

// 1. migrations/001.sql + 2. schema.ts + 3. routes.ts + 4. api.ts
CREATE TABLE posts (id INT PRIMARY KEY, title TEXT NOT NULL);
app.post("/api/posts", async (req, res) => {
  const body = req.body as any; // untyped drift risk
  await db.insert(posts).values({ title: body.title });
});

After: Single 28-line blog_fullstack.vox module (0 drift)

Declaring table, query, mutation, component, and routes once in .vox deterministically generates the Turso SQL migration, Rust Axum handler, and typed client RPC.

table Post { title: str }
query list_posts() to int { return len(db.Post.all()) }
mutation publish_post(title: str) to Result[str] {
  db.Post.insert({ title: title })?
  return Ok("published")
}
routes { "/" to BlogHome }

CV & VLM rubric shift: 0.7545 → 0.961 (+0.2065 · Sharpness +55.7% · PSNR 45.03 dB)

Grounding gate: Negation parity & evidence verified

Interactive walkthrough

Step through how Vox works without creating an account or installing local dependencies.

Entry & problem context

Maturity: Live in production

Modern web apps force teams to write the same data structure four times—in database migrations, backend models, API validators, and frontend types—creating bugs every time a field changes.

Programming language and full-stack toolchain where defining your data model once automatically generates the database schema, backend API routes, and typed frontend client.

Shared platform architecture sandbox

Test the live cross-language single source of truth shared across TypeScript, Python, and Rust.

Evidence grounding & negation parity check

Source evidence passageAssistant claim snippet to verify

Grounding tier: RejectedPolarityFlip (grounded: false, overlap: 1)

Socrates epistemic decision: clarify (confidence: 0.425)

Dual-gate write receipt verifier (DAWRI) & FTT math healer

Assistant response draftSimulate committed database write receipt (committedWrites.length > 0)

Unbacked claim stripped: true

Sanitized output: No profile changes were committed in this turn.

FTT verbatim math healer: EV 142, σ 133.5515, gist positive_ev_with_downside

Hick-Hyman EIG chips: Remote or hybrid? · Target salary floor? · Company stage? (lockout: false)

Semiotic Brand Identity & Federated SoC Governance

Peircean Brand Mark, Multi-Size Squint Test & 3-Tier SoC Boundary

SoC tier: oss_public16px rubric: 96.7% (PASS)

16px · 32px · 48px squint test

Motif: ast_wave_nexus

Iconic sign: Acoustic voice waveform morphing into a 3-node compiler abstract syntax tree (AST)

Indexical cue: Speech-to-code deterministic compilation and multi-agent MCP orchestration

Symbolic archetype: Indigo polyglot systems architecture and sovereign developer toolchain

SoC Boundary & Epistemic Retrieval Guardrails

Visibility & ceiling: public_oss (max tier: oss_public)

Boundary policy: Flagship public open-source AI-native language & runtime (`vox-foundation/vox`) — receives oss_public primitives only.

4-gram shingle novelty: 100.0% (non-redundant >15%) · Retired symbol trap: Clear (0 retired symbols)

GitHub Profile & Source Activity

Engineering Velocity & Open-Source Hygiene

Synced from @brbrainerd and @vox-foundation via the GitHub GraphQL API (GET /api/github/stats).

GitHub Profile vox-foundation/vox

Annual GitHub activity

13,842+

3,229 public · 10,136 private revisions

Curated portfolio history

19,523+

Revisions across 32 curated projects

Pull requests & reviews

463 PRs

Merged across 70 first-party codebases

Vox historyRust

7,200 revisions

12,636 tracked source files · Updated 2026-10-14

Language distribution across curated projectsWeighted by revision history & source volume

TypeScript38.9% (12 projects)

Rust36.9% (1 project)

Python11.3% (8 projects)

JavaScript4.7% (2 projects)

Lua4.1% (1 project)

Public open-source codebases on GitHub

vox-foundation/voxRust · 7,200 rev

Single-file full-stack programming language and Rust compiler that generates database schemas, server routes, and typed clients from one declaration.

#programming-language#rust#compiler#full-stack#lsp

brbrainerd/govSimTypeScript · 435 rev

Interactive political economy simulator with ECS civic rights, institutional modeling, policy levers, and multi-regime scenarios.

#simulation#political-economy#typescript#ecs#strategy-game

brbrainerd/neurogeckoHTML · 6 rev

Interactive 3D macaque brain atlas and stereo surgical view planner rendered in browser WebGL.

#neuroscience#webgl#threejs#brain-atlas#3d-visualization

brbrainerd/brFrameTypeScript · 23 rev

Single-binary Rust and React kiosk shell for Raspberry Pi digital photo frames with remote mobile upload.

#rust#raspberry-pi#kiosk#embedded#react

Open Vox Source on GitHub Browse all projects