Six Of These Are Written In Themselves. One Just Stopped Being
Fourteen languages, and for each one the language its main implementation is actually written in. It is a genuinely careful card — it separates a virtual machine from a compiler, it names the specific implementation rather than pretending a language has only one, and its parenthetical notes are precise about history.
And buried in it are two rows that point in exactly opposite directions.
Go reads: Initially C → Now Go (with some assembly). The compiler started in another language and was rewritten in the language it compiles.
TypeScript reads: TypeScript (v6 and earlier) → Go (v7 and later). The compiler started in the language it compiles and is being rewritten in another one.
Same card, same arrow, opposite journeys. Which is the most interesting thing here, because it shows that writing a language in itself is a phase rather than a destination — something a project arrives at to prove a point, and sometimes leaves again when a different point matters more.
Three phases of an implementation
| 1 · BORN SOMEWHERE ELSE | 2 · SELF-HOSTED | 3 · MOVED AGAIN |
|---|---|---|
| The first compiler is written in an older language | The compiler is rewritten in the language it compiles | The compiler moves to a different language for a specific reason |
| You cannot write it in itself yet — it does not exist | The language is now expressive enough to build itself | Something matters more than self-hosting — usually speed |
| C in assembly · C++ in C · Rust from an OCaml-based compiler · Go in C | Go · Rust · Kotlin · C# · C++ · TypeScript until recently | TypeScript, from itself to Go |
| A beginning | A maturity milestone | A performance decision |
All fourteen, as the card gives them
Every word in the first two columns is the card’s own, including its notes in brackets.
| Language | What it is built with, as the card states it | Pattern |
|---|---|---|
| C | Major compilers: C / C++ / other languages (early C compilers were written in assembly) | Self-hosted |
| C++ | Major compilers: C++ (the first C++ compiler, Cfront, was written in C) | Self-hosted |
| Java | JVM (HotSpot): C++ | compiler (javac): Java | Split — runtime and compiler differ |
| Python | CPython: C (the most widely used implementation) | Written in C |
| JavaScript | V8 engine: C++ (used in Chrome, Node.js and many other environments) | Written in C++ |
| Go | Initially C → now Go (Go 1.5 moved the compiler and tools to Go) | Bootstrapped |
| Rust | rustc: Rust (bootstrapped from an earlier Rust/OCaml based compiler) | Bootstrapped |
| TypeScript | TypeScript (v6 and earlier) → Go (v7 and later) | Un-bootstrapped |
| Kotlin | Kotlin compiler: Kotlin (with some Java components) | Self-hosted |
| Swift | Swift compiler/toolchain: Swift + C++ | Mixed |
| PHP | PHP interpreter: C | Written in C |
| Ruby | CRuby (MRI): C | Written in C |
| C# | Roslyn C# compiler: C# | Self-hosted |
| Dart | Dart SDK: Dart + C++ (frontend in Dart, VM and runtime largely C++) | Mixed |
WATCH THE ORIGINAL — 20 SECONDS
All fourteen languages with their implementations and the historical notes under each.
▶ Programming languages and the languages used to build them — BANI Academy on Facebook
Why a language would be written in itself
There is a practical reason and a reason about confidence, and both are real.
The practical one: the people writing the compiler are the people who know the language best, and a compiler is a large, demanding program. Writing it in your own language means every awkward corner of the design gets found by the team that can fix it. It is the most serious possible test of a language, performed daily, by the people responsible.
The confidence one is harder to quantify and matters just as much. A language that cannot build itself is implicitly admitting something. Self-hosting says: this is a real tool, not a toy — we build our most important program with it. That is why it so often arrives as a milestone announcement rather than as a quiet refactor.
And then there is the reason to walk away from it, which the TypeScript row captures. A compiler that runs on a slower runtime is a slower compiler, and for a language used across enormous codebases, compile time is felt by every developer every day. At some point the symbolism of self-hosting is worth less than ten seconds off every build — so you port it to something faster and accept that your compiler is no longer written in your own language.
What the implementation language tells you
| If the implementation is… | It tells you | What to expect | On this card |
|---|---|---|---|
| Written in C or C++ | Speed and portability were the priority | The language is probably older, or its runtime does heavy lifting | Python’s main implementation, PHP, Ruby, the JS engine |
| Self-hosted | The language is mature and its team dogfoods it | Expect good tooling — they feel their own pain | Go, Rust, Kotlin, C# |
| Mixed | A toolchain, not a single program | Different parts have different constraints | Swift, Dart, Java |
| Moved away from itself | A specific engineering goal beat the symbolism | Something measurable was wrong — usually build time | TypeScript |
Four honest caveats
A language is not its implementation, and this card is careful about that. Python is not written in C — CPython is, and the card names it. Ruby is not written in C; CRuby is, and the card names that too. There are other implementations of most of these languages, written in other languages, and they exist precisely because the main one made trade-offs somebody disagreed with. Saying “Python is written in C” is the single most common way this chart gets misquoted.
The Java row is the most informative one on the card. It splits the runtime from the compiler — the virtual machine largely in C++, the compiler itself in Java. Most charts of this kind collapse that into one answer and lose the distinction, which is the thing that explains why Java programs start slowly and then run fast.
“Some assembly” is still in there. Several of these projects contain small amounts of hand-written assembly for the parts where nothing else will do. It is a tiny fraction of the code and it is load-bearing, which is a reasonable description of assembly’s role in computing generally.
The footer is the right one. Implementation details change over time. Check each project’s official docs for the latest. That is exactly true, and the TypeScript row on this very card is the proof — a chart made eighteen months earlier would have had a different answer in it.
Questions people ask
How can a language compile itself before it exists? It cannot, which is why every self-hosted language has a first compiler written in something else. You use that to compile the real compiler, then throw the first one away. The card records several of those origin stories in its brackets.
Does this matter if I am just learning to code? Not for writing code, no. It matters for understanding why your tools behave as they do — why one language starts instantly and another takes a moment, why one has fast builds and another does not.
Should I learn C because everything is built on it? Only if you want to work on the layer where that matters. For most people the useful lesson is the opposite: you are standing on decades of other people’s work and you do not have to rebuild it. Start from what you want to exist, which is the argument in Which Language Should I Learn First Is The Wrong Question.
Why do so many charts like this exist? Because the answer is genuinely surprising, and because it is the kind of fact that makes you feel you understand the machine a little better. That is a good reason. Just do not mistake it for a reason to change what you are learning — the same caution we applied to a games chart in Nobody On This Chart Chose A Language.
A phase, not a destination
Fourteen rows, and the two most interesting ones sit a few lines apart pointing opposite ways. One language grew up enough to build itself. Another decided that building itself was costing its users more than it was worth.
Both decisions were correct, for different projects at different moments — which is the quietly useful thing this card teaches. Underneath them all sit C and C++, written when most people reading this were not born, still holding up the Python implementation, the browser engine, the Java runtime and the Dart VM.
The tools change. The layers underneath them change far more slowly, and that is why they are worth knowing about even if you never write a line of them.
Learning a lot does not make anyone good. Doing a lot does.
If you want a deadline rather than another saved cheat sheet, we run a free challenge — there is no barrier to entry, only a commitment fee that is refunded when you finish. It exists because a deadline makes you build something, which teaches more about a language than knowing what its compiler is written in.
Which row on that card surprised you most? Tell us in the comments under the original reel.
More on building a channel for a global audience at mmoyoutube.com.
