Skip to main content
Everything on this page is direction, not shipped work. Phase 0 is still open, and the charter says nothing after it starts until the benchmark gives a real number. The pilots so far have not shown an advantage.

The owner’s direction, 29 September 2026

  • Mzizi builds the whole stack. It is meant to build the backend as well as the UI, and Mzizi’s own backend infrastructure is meant to be built with it. The first slice exists: a service with HTTP routes and handlers, lowered by mz build to a local Rust + axum package (RFC-0011). No Mzizi backend is ported.
  • The frontend takes one of two shapes. Either Astro, with Mzizi UI (Mzizi Roots) underneath, or pure Rust end to end.
  • Everything built carries a contract. Components, language functions and backend handlers, specified in RFC-0010. Today, contracts exist for components and services: mz contract evaluates a component’s contract block against its own declarations (RFC-0006), and runs a service in process, testing each ensure over generated requests (RFC-0011). Contracts for functions do not exist: a program’s functions exist, and its contract block is designed in RFC-0013, not built.
  • A new kill criterion. Mzizi against the best existing language for each kind of task, aiming to rank with the top languages, specified in RFC-0009 §6. Not measured yet.
  • Results are always published, whichever way they fall, in benchmarks/results/. Held-out task texts are published when a task set is retired; their scores are published immediately.
  • The benchmark widens. RFC-0009 extends it to React, and to TypeScript, Python, Go, C++ and Rust backends. The React arm and the Mzizi backend arm (mzizi-be) are added and have never run; the Hono, FastAPI, Go, C++ and axum arms are not added yet (the benchmark).
Both RFCs are merged in design/ in mzizi-dev/mzizi, and charter v0.4 records the direction. Both are drafts: RFC-0009 for the benchmark and kill criterion, and RFC-0010 for contracts everywhere. RFC-0011 designs the backend slice, and most of it is built. See the RFC index.

What Mzizi still has to build

The language’s own list is LANGUAGE-TRACKER.md, summarised on What still has to be built. 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, and every Tier 1 row is ✅ (C6 since the fourth release of 8 October 2026, C7 and C8 since the third). Its milestones are M1, a language that computes (all of Tier 1) and M2, a working programming language (Tier 1 plus modules, a standard library, lowering all code to Rust, a runnable build, errors mapped back to .mz and Rust crate interop). M1 is met on main; M2 is not reached.

M1: the plan

Issue mzizi#69 tracks M1: every Tier 1 row (C1–C10) ✅ on main, tested in CI. The owner approved the plan on 7 October 2026. Its first waves were released to main on 8 October 2026 (mzizi#91, and mzizi#96), and the third on 8 October 2026 (mzizi#104), and the fourth on 8 October 2026 (mzizi#109, tagged v0.8.0). Every row C1–C10 is ✅ in the tracker, so M1 is met on main. The release of 20 October 2026 (mzizi#120, tagged v0.9.0) carried the C6 review follow-ups and RFC-0014, the Tier 2 design as a draft; no row of the tracker changed its mark. Status lists what that release carried, and Status lists the 8 October releases.

The owner’s decisions, 7 October 2026

Quoted from the issue: “Tiers by rfc, compile to rust, methods for now, go ahead.”
  • One RFC per tier. Tier 1 is RFC-0013 (mzizi#76, a draft for review, on main). Tier 2 and Tier 3 each get their own RFC later.
  • A program runs by compiling to Rust. The lowered Rust is the source of truth.
  • Methods on records now, generics later. Generics are deferred past M1.
  • Integer overflow stays checked in every build. “Keep the overflow checks and remove them where the compiler can prove they are unnecessary …” A compiler pass is to remove a check only where it proves the operation cannot overflow, visibly in the lowered Rust and tested. Not built.
  • A performance suite against hand-written Rust. It is to live in the language repository, with Mzizi programs and Rust references; CI is to gate correctness only, and timing runs and their history are to live in the private mzizi-benchmarks repository, which consumes the public one and never the reverse. The suite is on main (mzizi#85): CI gates output agreement only, and no timing is committed. No pass removes an overflow check yet. One run’s timings, on one machine, are in its description; see Status.
  • Release notes from the changelog, and a changelog entry in every pull request. Done (mzizi#82, on main): each release to main publishes its CHANGELOG.md entries as release notes, and a pre-commit hook applies the rule when you commit (mzizi#86). These docs have their own changelog rule (their AGENTS.md).

The waves

Agents build the plan in waves, each pull request on its own branch, one per tracker row. Agents never merge; the owner reviews and merges. Every pull request in a wave meets its tracker row’s “done when” test, updates that row, adds a changelog entry and an examples/*.mz program, gives each new construct diagnostic codes, and claims no measured result.

How that fits the charter

The charter (v0.2) widened Mzizi from web UI to general-purpose software for the agentic world, and merged rendering and edge deployment into one full-stack Phase 1. v0.4 records the direction above, calls Mzizi a general-purpose programming language, and gives Phase 0 one goal, which raises its bar. It does not remove the gate:
If this doesn’t show a measurable advantage, nothing downstream matters — don’t build Phase 1 until Phase 0 has a real number attached to it.

What has to happen next

The second pilot listed the fixes to make before a run that tests the kill criterion. benchmarks/READINESS.md audits them, and most are now made: relative paths in the check output, diagnostics for React idioms, a height derived from its class, mz fix, and a larger public task set. The runner now reads arm.toml and a language-neutral spec.md, and has a React arm. The React arm’s pins now come from the registry’s lockfile. Phase 0 is still not complete. The run waits on: held-out tasks in a private repository, a pre-registered PLAN.md, first Leptos and React runs, and for the backend family, probe scoring in the runner, tasks B2–B5 and the other-language arms. See what remains. RFC-0007 is the gap register: what the charter’s scope needs that the language and compiler lack, and the order to build it in. RFC-0008 took on the first five gaps of its first tier: name and type resolution, list(T), record, option(T) and for each.

Where the plans live

design/ROADMAP.md in mzizi-dev/mzizi is the index of every plan in the project. It holds pointers and gates, not work items: plans live next to the code they plan. The separate mzizi-roadmap repository is archived and points there.