Skip to main content
Mzizi is not yet a working programming language. Mzizi has no modules, standard library or concurrency yet. A program has expressions, bindings, functions, control flow, numbers, results, text, lists, maps, sets and records with methods, in a narrow form. C1–C10 are ✅ in the file as of the fourth release of 8 October 2026 (550826a, tagged v0.8.0), so M1 is met; M2 is not reached. A service lowers to a local Rust + axum package and a program to a dependency-free Rust package; no component lowers, and there is no Workers, Containers or WebAssembly target.
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) and event(T) (RFC-0008).
  • Toolchain: mz check (with --agent), mz fix, mz contract, mz outline, mz build, mz run and mz harness; a recovering parser (blocks nest at most 64 deep, past which one MZ0411), 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 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.
The core language, in a 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 on main and green.
The language harness (H1) is the spine of the language, what the agent reads. The agent protocol (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 to main 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.