> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mzizi.dev/llms.txt
> Use this file to discover all available pages before exploring further.
# Mzizi: a general-purpose programming language
> Built to make Rust better, the way TypeScript makes JavaScript better: no borrows, lifetimes or ownership in the language you write, with the harness at the core, the layer an agent reads. That is the goal Phase 0 measures, not a result. Its goal is to be used instead of TypeScript, Python and C++. It is a Phase 0 prototype, and the first two pilots showed no advantage.
**Read [Status](/status) first.** Mzizi is a Phase 0 research prototype. Its goal is a
goal, not a result. The language's front end exists in its toolchain and is tested: a lexer, a recovering parser, a name and type resolver, an
agent diagnostic protocol, contract evaluation, a content-addressed IR and nine primitives
written in Mzizi. A first backend slice is in: a `service` with HTTP routes and handlers,
which `mz build` lowers to a local Rust + axum package. No component lowers yet, and nothing
renders. **Mzizi has no expressions, bindings, callable functions, loops, error handling,
modules or standard library yet** ([what still has to be built](/tracker)). Two small pilots
of the benchmark ran on 2026-09-27, and **neither showed an advantage** ([results](/pilots)).
The run that tests the kill criterion has not happened.
**Built to make Rust better, the way TypeScript makes JavaScript better.** How: no borrows,
lifetimes or ownership in the language you write ([RFC-0001](/rfcs) §1.8), with the harness
at the core, the layer an agent reads. "Makes Rust better" is the goal Phase 0 measures, not
a result.
*Mzizi* means **root**. **Mzizi is a programming language**, and these docs lead with it.
Its goal is to be the language people choose instead of TypeScript, Python and C++.
**Rust is to Mzizi what JavaScript is to TypeScript: its platform.** Mzizi is designed to
lower to Rust ([RFC-0001](/rfcs) §5), and Mzizi Roots is its component model, the way React
is JavaScript's. The aim is that Mzizi does Rust better: you write Mzizi instead of
TypeScript, Python or C++, and get Rust underneath. Today only a `service` lowers, to a
local Rust + axum package, so that is the goal Phase 0 is measured on, not something Mzizi
does today.
**What is which:**
* **The language** is its syntax, type system, semantics, and contracts as a language
feature.
* **The harness** is the core of Mzizi: the layer an agent reads and works through. It covers
the language as an agent sees it (grammar, types, contracts, canonical form), the agent
protocol (`mz check --agent`, its diagnostics and fixes; RFC-0001 §4), and the plugin
host that the toolchain, the CLI, the MCP server and plugins attach to natively. Part of
it exists today, in the toolchain, as `mz check --agent`'s output. The harness as a whole
is designed, not built: its design is [RFC-0012](/rfcs), a draft. It lives in the language
repository, `mzizi-dev/mzizi`, and the agent-tools packages (the CLI, the MCP server,
`fundi`) are its clients.
* **The toolchain** is built to support it: the `mz` compiler that implements it (with its
IR, its diagnostic protocol, `mz fix` and `mz contract`), the CLI, the MCP server, the
skills and the Phase 0 benchmark harness (`benchmarks/harness/`, not the harness above).
They are meant to attach to the harness. The compiler is not the language.
* **The components** are built to support it too: Mzizi Roots and the registry, the
language's UI layer and where its output is meant to land.
## The claim worth defending
No language in wide use today, TypeScript, Python, C++ and Rust included, was designed for
an agent iterating against a compiler. They assume a human is typing, reading docs and
holding context in their head. The bet is that this is the wrong assumption for where
development is going, and that a language whose syntax, type system and diagnostics are
designed for machine authorship is the answer. The charter states it as Mzizi's "single
sharp edge": syntax, a type system and a compiler feedback loop "designed for machine
authorship, not just human ergonomics".
Then a correction that matters more than the original claim. RFC-0001 was written by a
frontier model optimising for its own experience, and [RFC-0002](/rfcs) withdrew that
target:
> **The design target is small models.** A 7B open-weight model running locally, not a
> frontier model with a million-token context. Frontier capability is improving on its own;
> the language cannot help there and does not need to.
That inversion is why token efficiency is a first-order goal, why `end component button`
echoes the name back, and why the grammar is small and closed rather than familiar and open.
It is also why the second pilot matters: it tested that design target, and the \~7B model
did worse in Mzizi than in Dioxus.
## Phase 0's goal
**Phase 0 has one goal: to build Mzizi as a programming language, measured against the
best existing language for each kind of task.** That is
[RFC-0009](https://github.com/mzizi-dev/mzizi/blob/main/design/RFC-0009-comparison-benchmark.md),
and [charter v0.4](/charter) §4 states it. Two task families gate, on held-out tasks with a
\~7B model:
| Family | What the agent writes | Measured against |
| - | - | - |
| `ui-spec` | UI components, from a language-neutral `spec.md` | Rust with Dioxus and with Leptos, TypeScript with React (all exist; Leptos and React have never run) |
| `backend` | HTTP handlers and services, scored by HTTP probes | TypeScript (Hono), Python (FastAPI), Go, C++20 and Rust (axum), none added yet. The Mzizi arm, `mzizi-be`, exists and has never run |
Nothing has been measured against that goal yet. The two pilots of 2026-09-27, which ported
registry UI components into Mzizi and Dioxus, were the first tests inside Phase 0, not its
goal. See [the benchmark](/benchmark) for every arm and its state.
## Where Mzizi is heading
**Direction, not shipped.** These are the owner's stated goals as of 29 September 2026.
RFC-0009, RFC-0010 and RFC-0011 in
[`design/`](https://github.com/mzizi-dev/mzizi/tree/main/design) design them. Read
[the roadmap](/roadmap) for how they relate to the phases, and
[what still has to be built](/tracker) for what exists.
* **The whole stack, not only the UI.** Mzizi is meant to build the backend as well as the
interface. Mzizi's own backend infrastructure is meant to be built with it. The first slice
exists (a `service` that lowers to a local Rust + axum package); no Mzizi backend is ported.
* **Two frontend shapes.** Astro with Mzizi UI ([Mzizi Roots](/roots/overview)) underneath,
or pure Rust end to end.
* **Contracts everywhere.** Everything built carries a contract: components, language
functions and backend handlers. Today components and services carry contracts; a
service's run in process, tested over generated requests, not proven.
* **A wider benchmark.** The benchmark will extend to TypeScript and React on UI tasks, and to
TypeScript, Python, Go, C++ and Rust on backend tasks. Today it has Dioxus, Leptos and
React arms for UI components and the `mzizi-be` arm for the backend; only the Dioxus arm has
ever run, and the other-language backend arms are not added yet.
* **A higher bar.** The kill criterion is now Mzizi against the best existing language for
each kind of task, aiming to rank with the top languages. It has not been measured.
* **Every result published.** Every benchmark run lands in
[`benchmarks/results/`](https://github.com/mzizi-dev/mzizi/tree/main/benchmarks/results),
whichever way it falls.
## Where to start
What exists, what is tested, what has been measured, and what is still a design.
The language tracker: what Mzizi still needs against Python, Go, C++, TypeScript and
Rust, and milestones M1 and M2.
The two Phase 0 pilots, reported as they came out: no advantage shown.
Nine named failure modes an agent hits writing Rust UI code, and the syntax decision
that answers each one.
Real `.mz` source with real contracts, gated in CI, and why primitives are copied files
and not crates.
The toolchain's compiler, which implements the language: `mz check --agent`, `mz fix`,
`mz contract`, `mz outline` and `mz build` (a service only), and the NDJSON protocol
written for a reader holding zero file context.
Content addressing: one architectural decision that answers seven of eight named
reading barriers.
## What supports the language
The compiler, the benchmark, the MCP server, the CLI and the skills. Free to use, with
no sign-in.
Mzizi's own UI and server components, being rebuilt in Rust for the agentic web. In
progress.
The API at `api.mzizi.dev`, where data lives, and the console.
## What Mzizi is not
The charter is explicit about its non-goals:
* **Not its toolchain or its components.** The compiler, the CLI, the MCP server, the skills
and Mzizi Roots support the language; none of them is the language.
* **Not a rendering engine.** Phase 1 is interop with an existing renderer (Dioxus today).
Rebuilding one buys the language nothing.
* **Not a tensor runtime.** ML inference is a declared capability backed by Candle.
* **Not a post-quantum cryptography project.** Named as a future thread and out of scope.
* **Not tied to one web framework.** The compiled artifact is meant to be WASM, and native
for desktop. Astro with Mzizi Roots underneath is one of the two frontend paths, beside
pure Rust end to end, and needs no compiler work beyond Phase 1's self-contained artifact.
## Ownership
Mzizi owns and operates the language, its toolchain and its components: the compiler, the
registry, the design system, the docs and the API. Nyuchi operates the console and the revenue products. Copyright notices
name the **Bundu Foundation** as the parent copyright holder; Mzizi is not a separate legal
entity. The [charter](/charter) states the line and the [ecosystem map](/ecosystem) follows
it repository by repository.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.