Modula-9

Modula-9, also called M9, is an open-source programming language designed for code that may be written quickly by an AI agent but still has to be understood and defended by a person. It belongs to the Wirth language family and draws on the Modula-2 and Oberon tradition of explicit, readable structure. The project describes its target style as code that is written quickly and audited slowly, especially in data science, finance, and research infrastructure. Its goal isn't to make generated code look clever or compact. It is to make important behavior visible enough that a reviewer can follow what the program says and where it may fail.

The language builds several checks into its semantics rather than leaving them as optional compiler settings. Range, overflow, and conversion checking can't be disabled. Exceptions that a procedure can raise appear in its signature, so a reviewer doesn't need to infer all failure paths from the implementation alone. Borrowing is also explicit. If a procedure keeps a borrowed parameter beyond the immediate call, that retention must be declared in the signature and is checked. Together, these rules are intended to reject unsafe ambiguity early and leave a more honest interface for both the next agent and the human who signs off on the work.

Those constraints address a real review problem with machine-generated code. An agent can produce a large, plausible implementation faster than a person can build confidence in it, and familiar syntax alone doesn't make hidden numeric or lifetime assumptions easier to find. M9's answer is to put more evidence at procedure boundaries and to make some dangerous behaviors nonoptional. It doesn't prove that a program's business logic is correct, and it doesn't replace tests or a careful reviewer. It aims to reduce the number of silent choices a reviewer must reconstruct after the code has already been produced.

M9 comes with a self-hosted compiler named m9c, which means the compiler itself is written in the language it compiles. It emits C11 rather than requiring a custom machine-code backend. The repository includes bootstrap C, so building from source needs a C compiler but doesn't require a previous M9 installation or another language toolchain. This approach gives the project a practical route onto existing systems while keeping the implementation available for inspection. It also makes generated C part of the deployment story, though teams will still need to decide how that output fits their build, debugging, and platform support practices.

The distribution is broader than a bare compiler. It includes a runtime, a standard library supplied as source, generated module documentation, a language server, a formatter, and a manual page. The language server and formatter are themselves written in M9. An interactive tutorial, also written in M9, offers a lower-friction way to learn the syntax and safety model. The project publishes prebuilt packages through GitHub releases and records the distribution, compiler, and smoke test used for each build. Those build receipts are a thoughtful fit for a language that emphasizes auditability and reproducible evidence.

Modula-9 is most relevant to teams experimenting with agent-written infrastructure where the cost of review matters more than access to the largest package ecosystem. A research group could use it for data processing components whose numeric behavior should fail visibly. Finance developers may value mandatory overflow and conversion checks. Teams evaluating AI coding agents can use its explicit signatures as a constraint that forces generated code to state more of its assumptions. It is less compelling for projects that depend heavily on mature third-party libraries, mainstream hiring pools, or existing framework integrations, since the language and community are still very new.

The compiler and related tools are licensed under GPL-3.0-or-later, and there is no commercial plan to buy, so the right pricing classification is open source. The available package record identifies version 0.4.1 and shows an intent to package it for Debian, while the public repository includes the source and releases today. That maturity level should shape expectations. M9 already has a compiler, library, editor tooling, tutorial, and release artifacts, but it doesn't yet have the ecosystem or track record of Rust, C, or established Wirth-family languages. For developers willing to evaluate a young tool, its value lies in a coherent idea. Code generated at machine speed should expose enough safety and intent for a human to audit it responsibly.