> ## 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.
# What still has to be built
> A summary of LANGUAGE-TRACKER.md, the language's one tracker of what Mzizi still needs before it is a working programming language, against Python, Go, C++, TypeScript and Rust. Mzizi has no expressions, bindings, callable functions, loops, error handling, modules or standard library yet.
**Mzizi is not yet a working programming language.** It has no expressions, bindings,
callable functions, loops, error handling, modules or standard library yet. Only a
`service` lowers to Rust, as a local Rust + axum package; no component lowers, and there
is no Workers, Containers or WebAssembly target.
[`LANGUAGE-TRACKER.md`](https://github.com/mzizi-dev/mzizi/blob/main/LANGUAGE-TRACKER.md), at
the root of `mzizi-dev/mzizi`, is the one list of what Mzizi still needs before it can be
called a working programming language, stacked against the languages it aims to replace. By
the owner's decision of 30 September 2026 it is the ultimate tracker: **if a capability is not
✅ there, Mzizi does not have it, whatever any other page says.** These docs take every
capability claim from it. This page summarises it at language `main` `62a0f32`; read the
file for the evidence behind each row.
Status in the tracker is what the code on `main` does, never what an RFC designs:
| Mark | Meaning |
| - | - |
| ✅ | On `main`, tested in CI |
| 🟡 | Partly there: a narrow form exists, or it exists in an open PR only |
| 📝 | Designed in an RFC, not implemented |
| ❌ | Neither designed nor implemented |
## Where Mzizi stands today
What exists is the front end of a language whose first domain is UI components:
* **Syntax:** 23 keywords (`compiler/src/lex.rs`), one component per file.
* **Types:** `bool`, `int`, `text`, enums with data columns, records, `list(T)`, `option(T)`
and `event(T)` ([RFC-0008](/rfcs)).
* **Toolchain:** `mz check` (with `--agent`), `mz fix`, `mz contract`, `mz outline`, and
`mz build` for a service only; a recovering parser, a resolver and a content-addressed
IR. See [the compiler](/compiler).
* **Written in Mzizi:** nine [primitives](/primitives), two component examples and one
service, `examples/registry.mz`.
* **The backend slice** ([RFC-0011](/rfcs), language PRs #29–#33): a
`service` with HTTP routes and handlers, checked by `mz check`, run in process by
`mz contract`, and lowered by `mz build` to a local Rust + axum package, which CI compiles,
tests and serves. The `mzizi-be` benchmark arm, the probe crate `mzprobe` and backend task
B1 exist; no backend episode has run.
What does not exist yet is almost everything a general-purpose program needs. A `fn` body is
not modelled beyond `emit`, which is why the public benchmark suites are blocked: they need
functions.
## Against the languages Mzizi aims to replace
Mzizi's column from the tracker, condensed. The tracker also gives each incumbent's answer
(Python, Go, C++, TypeScript and Rust have every one of the first rows).
| Area | Mzizi today |
| - | - |
| Expressions, variables, functions, loops | ❌ `fn` is a name plus `emit` |
| Numbers | 🟡 `int` only |
| Text operations | ❌ `text` is a type only |
| Collections | 🟡 `list`, `option`; no map, set or tuple |
| User types | 🟡 enums with data, records; no methods, traits or generics |
| Error handling | ❌ contracts check behaviour; they are not error handling |
| Modules and imports | ❌ one component per file |
| Standard library | ❌ |
| Concurrency | ❌ |
| Compiles to something that runs | 🟡 a `service` lowers to a local Rust + axum package, which CI compiles, tests and serves; no component lowers |
| Uses the host ecosystem | ❌ no Rust crate interop |
| Package manager | ❌ |
| Formatter, editor support | ❌ canonical form designed in RFC-0001 |
| Tests | 🟡 `mz contract` for contracts; no `mz test` |
| Diagnostics built for agents | ✅ `mz check --agent`, `mz fix` |
| Contracts on everything | ✅ components; 🟡 services, run in process by `mz contract`, `ensure` tested over generated requests, not proven |
| Spec and stability | ❌ the RFCs are design, not a reference |
The two ✅ rows are where Mzizi is different on purpose. Every other row is work.
## The work, tier by tier
Each row in the tracker has a "done when" acceptance test, and turns ✅ only when that test is
on `main` and green.
| ID | Capability | Status |
| - | - | - |
| C1 | Expressions and operators | ❌ |
| C2 | Bindings: named values, scope, shadowing | ❌ |
| C3 | Functions: parameters, return types, calls, recursion | 🟡 |
| C4 | Control flow as expressions, loops, early return | 🟡 |
| C5 | Numbers: floats or decimals, overflow and division | 🟡 |
| C6 | Text operations | ❌ |
| C7 | Collections: maps, sets, tuples and their operations | 🟡 |
| C8 | User types: methods, interfaces or traits, generics | 🟡 |
| C9 | Error handling: a result type and propagation | ❌ |
| C10 | A program entry point that runs (`mz run hello.mz`) | ❌ |
| ID | Capability | Status |
| - | - | - |
| P1 | Modules and imports across files | ❌ |
| P2 | Standard library | ❌ |
| P3 | Lowering all code to Rust (today a `service` only) | 🟡 |
| P4 | `mz build` / `mz run` produce a runnable program (a service only) | 🟡 |
| P5 | Errors mapped back to `.mz` | ❌ |
| P6 | Rust interop: call crates, mix `.mz` and `.rs` | ❌ |
| P7 | Capabilities enforced | 🟡 |
| P8 | State and I/O | ❌ |
| P9 | Concurrency | ❌ |
| P10 | Memory model: no borrows, lifetimes or ownership at the surface | 📝 |
| P11 | Targets: native, WebAssembly, Cloudflare Workers, Containers | 🟡 |
| ID | Capability | Status |
| - | - | - |
| H1 | **The harness, the core of the language: what the agent reads** | 🟡 |
| H2 | The skills fold into the harness | 📝 |
| T1 | Agent diagnostics | ✅ |
| T2 | Formatter / canonical form | 📝 |
| T3 | Editor support: a language server | ❌ |
| T4 | Tests: `mz test` beside `mz contract` | 🟡 |
| T5 | Package management | ❌ |
| T6 | Documentation generator | 🟡 |
| T7 | Playground or REPL | ❌ |
| T8 | Debugging | ❌ |
| T9 | Language reference | ❌ |
| T10 | Releases and stability: a published `mz` | ❌ |
The harness (H1) is the core of the language, what the agent reads. Of it, only the agent
protocol (`mz check --agent`, `mz fix`) exists; the rest is
[RFC-0012](/rfcs), a draft.
## What each step unlocks for the benchmark
Phase 0's goal cannot be tested beyond what the language can express
([the benchmark](/benchmark)):
| Task family | Needs | Status |
| - | - | - |
| UI components against Dioxus, Leptos and React | What exists today | Runnable now. Two pilots on 2026-09-27, against Dioxus only, showed no advantage |
| Backend handlers (B1 routing) against TypeScript, Python, Go, C++ and Rust | A `service` | Not yet runnable: the runner does not score an episode with probes, and B2–B5 and the other-language arms do not exist. Nothing measured |
| Public suites (MultiPL-E, EvalPlus) | C1–C10 and part of P2 | **Blocked: Mzizi has no functions yet** |
| Aider polyglot, BaxBench | Tier 1, P1, P2, P8 | Blocked |
The kill-criterion run has not happened. Nothing in the tracker is a claim that Mzizi is
better than any language; it lists what has to exist before that can be measured.
## Milestones
All of Tier 1 ✅. This unblocks the public suites. Not reached.
Tier 1 plus P1–P6 ✅: you can write a general program in several files, use a Rust crate,
and build and run it. **Only at M2 does the tracker say Mzizi is a working programming
language.** Not reached.
The rest of Tier 2 and Tier 3 ✅, and the kill criterion run and published. Not reached.