M1: Mzizi's core language is complete, and what that does not mean

On 8 October 2026 the Mzizi language released v0.8.0, and with it reached M1, its first milestone. M1 has a precise definition in the public language tracker: every Tier 1 row is done. Tier 1 is the core a general-purpose program needs.

What a Mzizi program has today

Row	What it covers
C1	Expressions and operators: arithmetic, comparison, boolean logic, interpolation
C2	Bindings: let and var
C3	Functions with typed parameters and returns, calls and recursion
C4	Control flow: when and else when, exhaustive match, for each, while, break, continue, early return
C5	Numbers: int and float, never mixed silently; integer overflow and division by zero stop the program
C6	Text: length, search, case, trim, replace, repeat, indexing, slice, find, split, chars and number parsing
C7	Collections: list(T), map(K, V) and set(K), with indexing that returns an option
C8	Records with methods, and always invariants checked at construction
C9	Errors as values: result(T, E), return error(e) and a try that propagates
C10	A program file kind with fn main, run by mz run

mz run checks a program, lowers it to a Rust package with no dependencies, builds it with Cargo and runs it. CI runs every example program and compares its output with a committed expected file. 760 tests run on every change, 629 of them in the compiler.

Every one of these features is also registered in the language harness, which now holds 197 entries, 80 of them diagnostic codes. An agent can read the whole language from mz harness definition, rather than guessing at it from training data.

How we decided C6 was done

Row C6, text operations, was the last to close. Its original "done when" said the operations would exist "in the standard library". But the standard library depends on modules, and both are Tier 2, the largest unbuilt work in the tracker. Waiting would have tied M1 to them for methods that were already designed and lowered directly to Rust.

The decision, recorded in RFC-0013 and on the tracking issue: built-in methods with tests meet C6. The built-in lowering table is the seed of the future text module. When modules exist, that module documents the same methods, with no second implementation.

The methods that return an option or a list, such as s.find(t), s.slice(a, to = b) and s.parse_int(), were built once lists and options existed. Every one was checked by an independent review for panics in the generated Rust, and for compiler fixes that could change a program's meaning.

What M1 does not mean

• Not a complete language. There are no modules, no standard library and no concurrency yet. Those are Tier 2, and they are next. Generics and interfaces come after that.
• Not a performance claim. A performance suite compares lowered programs with hand-written Rust, and CI checks only that they print the same output. No timing is gated or claimed.
• Not the result. The benchmark that decides whether Mzizi beats the best existing language for machine authors, the kill criterion, has not run. Two small pilots in September showed no advantage, and on the small model Mzizi did worse. When the real run happens, it will be published whichever way it falls.

M1 means the language can now express ordinary programs end to end. That makes the real test possible. It does not pass it.

What comes next

M2 in the tracker is "a working programming language": Tier 1 plus modules (P1), a standard library (P2), lowering for all code (P3), runnable builds (P4), errors mapped back to source (P5) and Rust interop (P6). Modules and the standard library come first, because they also unblock the public benchmark suites.

• Tracker: LANGUAGE-TRACKER.md
• The release: v0.8.0
• Language: mzizi.dev/language