The Slow Birth of a “New” Programming Language
How `multilingual` evolved from numeral experiments to a full compiler pipeline
Most programming languages arrive in public as a “big bang” release: a splashy blog post, a named version, and a polished syntax tour. multilingual did not. Its history lives in commits: a long, quiet incubation around numerals and scripts, followed by a compressed architectural sprint in February 2026 that turned it into a real multilingual language system. This is the story of that birth, reconstructed from Git history and a few years of stubborn obsession.
multilingual is an experimental programming language where you write code in multiple human languages — English, French, Spanish, Japanese, and more — while everything maps into a single shared semantic core and execution pipeline. The surface syntax (keywords, word order, even directionality) adapts to the programmer’s language, but the underlying program and runtime stay identical.
Phase 1: Before there was a language (2022)
On January 16, 2022, the repository begins with a modest Initial commit (8dc6dfd). There is no runtime, no parser, no compiler theory in sight. The earliest commits are foundational and documentary: references, links, README updates. In hindsight, this matters. The project did not start as syntax theater; it started as a multilingual problem with real data and references behind it.
By February 2022, the first technical identity appears: numerals across languages and scripts.
“Add basic code for handling numerals” (
3f9eb89, 2022–02–20)
This is the first strong signal. Before keywords and grammar, multilingual tackles a representational question: how numbers are written, interpreted, and computed across linguistic systems. In fast sequence, arithmetic features are added (Support addition operations, Support multiplication operation), along with exception handling and tests. Unicode and Roman numeral support becomes explicit:
“Handle unicode strings for numbers in multiple languages” (
30cf905, 2022–02–20)
“Handling Roman numerals” (2339557, 2022–02–24)
This first era, through early 2022, looks more like language infrastructure research than language productization. The work is careful, test‑heavy, and centered on correctness rather than visibility.
Phase 2: Quiet deepening (2023–2024)
A second phase unfolds across 2023–2024, still mostly beneath the surface. Floating‑point numerals arrive, operations become richer, numerical parts are reorganized, and examples/docs improve. The pace is slower, but the direction stays consistent: build abstractions that can survive multilingual complexity.
“Support floating point numerals in all locales” (
6dde8d2, 2023–06–24)
At this point, many projects would stop as a specialized numeric toolkit. multilingual does not. It pivots.
Phase 3: The language “appears” (February 2026)
The true birth of the programming language happens in a concentrated period beginning February 15, 2026. This is the inflection point where the repo moves from multilingual data handling into language frontends and execution semantics.
“Add lexer and support keywords” (
f4e84d6, 2026–02–15)
With that commit, the project crosses a boundary: from values to syntax. A lexer means tokenization; keyword support means a visible language surface. Within days, the rest of the compiler path appears:
Add support for syntax and semantics(2b52c60, 2026–02–16)Support code generation(9ac8fe9, 2026–02–16)Support operators and repl(d08e5f3, 2026–02–17)
This is not incremental polish; it is system assembly. By late February 2026, the project has parser behavior, semantic checks, REPL workflows, and runtime execution paths.
Then comes architectural self‑definition:
“Add typed CoreIR lowering boundary, frontend equivalence tests, and formal docs reframing multilingual frontends‑to‑core architecture” (
4c53de1, 2026–02–20)
This commit states the design thesis clearly: many human‑language frontends, one formal core. That framing is what differentiates a multilingual language from mere translation aliases.
Phase 4: From idea to ecosystem
After architecture, expansion accelerates. More human languages are added, not just as static keyword lists but with behavioral alignment tests and normalization updates. Italian and Portuguese support appear early in this sprint:
“Support Italian and Portuguese programming languages” (
aa7b8de, 2026–02–17)
Then deeper localization complexity is addressed:
- multi‑word keywords
- RTL syntax support
- alias and ambiguity handling
- translation documentation and onboarding materials
On February 22, 2026, the project claims a major milestone:
“Add complete features for all 17 languages” (
24c2e55, 2026–02–22)
That is the moment where birth becomes public identity: no longer a prototype for a few localized demos, but a cross‑language programming surface
That is the moment where birth becomes public identity: no longer a prototype for a few localized demos, but a cross-language programming surface with broad parity intent.
In the same week, the project also moves toward distribution and ecosystem realism: packaging steps, changelog and release artifacts, Python 3.12 compatibility milestones, and broader test frameworks. It is a sign that the language is preparing to be used, not just explored.
Another strand emerges: backend diversification. WASM/WAT support lands (f18f6a0, 32b1bf3) with related workflow and test updates. This suggests the project is treated as a compilation platform, not only a Python‑targeting transpiler.
By the end of February, stabilization behavior appears: import fixes, classes, end‑to‑end tests, and repeated release/version updates (2026–02–28). The version file reports 0.5.1, signaling an early but coherent product phase.
From Git history to running programs
A birth story is only convincing if you can see the result. The good news is that multilingual is not just a Git repository; it already has concrete places where you can see the language behave.
The first is a small fractal demo site that uses multilingual to drive visual experiments across languages. It is intentionally narrow: one domain (fractals), one visual feedback loop, French language surface. It exists to answer a simple question: if you swap the keywords and word order, but keep the core program identical, does the picture on screen stay the same.
The second is an in‑browser playground, which loads the language core as WebAssembly and lets you write and run programs directly in your browser. You can put an English or French or Spanish program (or in other 14 language) on the left, and watch them execute through the same abstract syntax tree. For a project that spent years obsessing over numerals and architecture, this is where it starts to feel real: people can experiment without installing anything.
Underneath both of these sits the main repository on GitHub, which still tells the most honest version of the story. The commits that added numerals, the later sprint that added lexers and code generation, the tests that keep 17 human‑language frontends aligned with a single core — it is all visible there, line by line. If the fractal site and playground are the “show, don’t tell” of multilingual, the repository is the lab notebook.
Explore multilingual
- Fractal experiments (programs written in French in multilingual).
- In‑browser playground (test multilingual in 17 human languages)
- multilingual Language core (design and development of multilingual programming language)
