BASIC09 gets a new LLVM-based compiler

Boisy Pitre built basic09c, a standalone LLVM-backed compiler for Microware BASIC09 on OS-9.

A former Microware engineer has turned an LLVM forum idea into basic09c, a new compiler for BASIC09. The project matters because BASIC09 was built for OS-9, the multitasking operating system that once ran on machines like the Tandy Color Computer and the Dragon 32.

A retro language gets a modern compiler path

LLVM and GCC do not directly support BASIC, so anyone who wants a serious compiler for an old dialect has to do more than dust off a parser. Pitre’s answer was to take the original RFC idea and turn it into a standalone tool that uses LLVM internally instead of trying to merge BASIC support into the main compiler itself.

That design choice matters. A frontend can live on its own schedule, track one dialect closely, and still inherit LLVM’s code generation machinery. For a niche language like BASIC09, that is a lot more practical than asking a general-purpose compiler project to absorb a vintage syntax tree and all its quirks.

The result is a small but meaningful piece of preservation work. It gives BASIC09 a path into modern toolchains without pretending the language is something it is not.

• The original discussion happened on the LLVM Discourse forum.
• The compiler now exists as basic09c, not just a proposal.
• LLVM is used as a library, which keeps the BASIC-specific logic separate.
• The project targets BASIC09, a structured BASIC with procedures and local variables.

Why BASIC09 still matters to retrocomputing people

BASIC09 was not the line-numbered beginner’s language most people picture when they hear “BASIC.” It supported named procedures, local variables, IF...THEN...ELSE constructs, and user-defined variable types. In other words, it was built for real programs, not just quick one-liners typed at a prompt.

That is one reason the language still has a following. Another is the hardware around it: OS-9 ran on systems tied to the Motorola 6809, including the Color Computer family and the Dragon 32. Those machines were small, odd, and technically interesting in a way that modern nostalgia often misses.

Pitre is also the right person to do this work. He spent part of his early career at Microware, and he has written about the Tandy CoCo for decades. This is the sort of project that only happens when the person doing it knows both the language and the culture around it.

“BASIC09 is a structured BASIC: it has named procedures with local variables, supports constructs such as IF…THEN…ELSE, user-defined variable types — and no, it did not need line numbers.”

That line from the source sums up the appeal neatly. BASIC09 was already more disciplined than the toy-language stereotype, which makes it a better candidate for a modern compiler than many people would expect.

Pitre’s track record explains the ambition

This is also not his first retrocomputing stunt. In 2012, Pitre built Liber809, a project that swapped the CPU and support logic in an Atari 8-bit machine for a 6809-based setup. The goal was to make the machine run NitrOS-9, a community distribution of OS-9.

That earlier work tells you something important about his approach. He is not treating retro hardware as a museum piece. He is treating it as a platform that can still be extended, rethought, and made useful in strange new ways.

• Atari 8-bit hardware was the target of Liber809.
• Liber809 aimed to run NitrOS-9, not original Atari software.
• The CPU swap centered on the Motorola 6809, the same family used by BASIC09 systems.
• Pitre’s Microware background makes the BASIC09 compiler feel like a continuation, not a one-off stunt.

That continuity matters because retrocomputing projects often fail when they are driven by novelty alone. Here, the technical choices line up with the developer’s history, the language’s structure, and the hardware it was born on.

What this says about old languages in 2026

The deeper story is not that BASIC is back. It never really left. The more interesting point is that old languages become more usable when someone gives them a modern compiler path, even if the audience is small.

LLVM keeps showing up in places its original designers probably never planned. It is now a foundation for language revival projects, niche frontends, and experimental compilers that would have been far harder to build from scratch twenty years ago. That makes it useful for preservation work as much as for mainstream systems programming.

For BASIC09 specifically, the next question is adoption. Will hobbyists use basic09c to build new programs, or will it stay a clever proof that the language can be compiled with modern infrastructure? The answer will depend on whether the tool becomes easy to build, easy to test, and easy to pair with emulators or surviving OS-9 systems.

My bet is that the real value will come from the second wave: documentation, sample code, and cross-platform tooling around the compiler. If those pieces land, BASIC09 will stop being just a memory from the 6809 era and start being something developers can actually experiment with again.

For readers who care about old systems, the takeaway is simple: watch the compiler, not the nostalgia. A language survives when someone can still build for it.