There’s a moment every programmer lives for: when the compiler compiles itself. It’s a rite of passage, a proof that your creation is self-sustaining. Ada 83/TLALOC does exactly that. And it does it without LLVM, without GCC, without the bloated toolchains we’ve come to accept as inevitable.
You’ve probably never written Ada 83. But you’ve certainly felt the pain of modern compiler stacks. The endless dependencies, the build systems that take minutes, the complexity that no one truly understands. This project is a middle finger to all of that.
“The six-phase pipeline is so clean it feels like a forgotten art form.” It’s built around a DIANA 86 high-level intermediate representation — a tree structure from the 1980s that was ahead of its time. The backend? FASMG, a modern macro assembler that produces static ELF64 binaries for x86-64. The combination is deliberate: classic IR, cutting-edge assembler, zero bloat.
Let’s be clear: Ada 83 is not dead. It’s been sleeping. TLALOC wakes it up, and it does so by embracing the very constraints that supposedly killed the language. No external dependencies. No LLVM pass infrastructure. No GCC plugin system. Just a clean, self-hosting compiler written in Ada 83 itself.
This is not a nostalgia trip. It’s a blueprint. “The assumption that a modern compiler needs LLVM or GCC is a lie. This project shatters it.” The developer, ViMoBr, built TLALOC in Ada 83 because that’s the language that demands rigor. The result is a compiler that is easier to understand, modify, and port than any modern alternative.
Think about the tension here: a language from 1983, a standard that’s been obsolete for decades, paired with a macro assembler that’s only a few years old. It’s a throwback and a leap forward at the same time. Most people see Ada 83 as a relic. TLALOC sees it as a foundation.
Every 200-300 words, you should stumble on a sentence that makes you stop. Here’s yours: “If your compiler needs a million lines of C++ to bootstrap, you’ve already lost.” This project is a challenge to the entire industry. Why do we accept that tooling must be massive? Why do we let LLVM gatekeep our ability to build languages?
The real story here isn’t Ada 83. “It’s not a throwback. It’s a glimpse into the future—a future where we stop adding layers and start stripping them away.” TLALOC proves that a mature language can be revived through clean architectural separation and minimal dependencies. No magic. No gatekeeping. Just good engineering.
Ada 83/TLALOC isn’t a relic. It’s a revolution. The question is: are you brave enough to follow its lead?
FAQ
Q: Why would anyone use Ada 83 today?
A: Because it's a masterclass in minimalism. The compiler is self-hosting, has zero dependencies, and produces optimized ELF binaries. It's not about the language—it's about the architecture.
Q: What's the practical implication of this project?
A: This project shows that you don't need LLVM or GCC to build a modern compiler. You can design a clean pipeline that is easy to understand, modify, and port. It's a blueprint for language revival.
Q: What's the contrarian take on TLALOC?
A: The real innovation isn't Ada 83—it's the separation of concerns. The DIANA IR and fasmg backend are decoupled, allowing you to swap out either. This is more forward-thinking than most modern compilers.