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 f9bea2b (tagged v0.13.0, 1 November 2026; the file is the same as at v0.12.0);
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:
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)andevent(T)(RFC-0008). - Toolchain:
mz check(with--agent),mz fix,mz contract,mz outline,mz build,mz runandmz harness; a recovering parser (blocks nest at most 64 deep, past which oneMZ0411), a resolver and a content-addressed IR. See the compiler. - Written in Mzizi: nine primitives, two component examples and one
service,
examples/registry.mz. - The backend slice (RFC-0011, language PRs #29–#33): a
servicewith HTTP routes and handlers, checked bymz check, run in process bymz contract, and lowered bymz buildto a local Rust + axum package, which CI compiles, tests and serves. Themzizi-bebenchmark arm, the probe cratemzprobeand backend task B1 exist; no backend episode has run.
program (RFC-0013, released to main on 8 October
2026): fn main, functions with typed parameters and recursion, let, var and assignment,
int, float, bool and text with the numeric methods and the text methods, when / else when, match, for each over a list or range, while, break, continue, enums with
columns, list, map and set with their methods, records with methods and always
invariants, result(T, E) with error and try, and print. mz run lowers it to a
dependency-free Rust package, builds it and runs it, and CI runs eight example programs against
their committed output. See Programs.
The tracker marks every Tier 1 row, C1–C10, ✅ as of the fourth release. C6 came last: its
methods that return an option or a list reached main with that release. P4 and H1 stay 🟡: a
general program cannot be written yet, and the plugin host and the generated skills are not
built.
What does not exist yet: option(T) written as a type and narrowing it, methods that change
their record (changes self), records that hold themselves, generics, modules, a standard
library, concurrency, lowering for a component, and most of Tier 2 and Tier 3.
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).
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 onmain and green.
Tier 1: the core language (write any program)
Tier 1: the core language (write any program)
Tier 2: real programs (build, run and ship software)
Tier 2: real programs (build, run and ship software)
Tier 3: adoption (people and agents can use it every day)
Tier 3: adoption (people and agents can use it every day)
mz check --agent, mz fix) and a first slice of entries exist:
compiler/src/harness.rs registers every program feature and its codes, and mz harness
prints them. The plugin host and the generated skills are design only
(RFC-0012, a draft).
What each step unlocks for the benchmark
Phase 0’s goal cannot be tested beyond what the language can express (the benchmark):
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.
Toward M1
Work toward M1 is tracked in mzizi#69. Its design, RFC-0013, and its Wave 0 and part of Wave 1 (C1, C4, C5, C9, with C2, C3 and C10 from Wave 0) were released tomain on 8 October 2026 (mzizi#91, tagged v0.5.0). The second
release of that day (mzizi#96, tagged v0.6.0) moved their rows to ✅ in the file. The third
release (mzizi#104, tagged v0.7.0) carried collections (C7, mzizi#99), records with methods (C8,
mzizi#101 and mzizi#102) and the first text methods (C6, mzizi#98), and made C7 and C8 ✅. The
fourth release (mzizi#109, tagged v0.8.0) carried the rest of the text operations (C6,
mzizi#106) and made C6 ✅, so every Tier 1 row is ✅ on main and M1 is met. Still to build:
modules (P1) and the standard library (P2), which the public suites wait on, and the follow-ups
the RFC lists.
See Status and the M1 plan.
Milestones
1
M1, a language that computes
All of Tier 1 ✅, met on
main by the fourth release of 8 October 2026 (every row C1–C10).
The public suites also wait on the standard library (P2).2
M2, a working programming language
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.
3
M3, a language people choose
The rest of Tier 2 and Tier 3 ✅, and the kill criterion run and published. Not reached.