Amiga programming returns: ACE BASIC compiler 2.8.0 brings new capabilities

In a tech world where frameworks become “legacy” roughly three weeks after release, the appearance of a new Amiga BASIC compiler update feels almost rebellious. Yet in early 2026, version 2.8.0 of ACE, arrived quietly but confidently, reminding everyone that some software projects age more like vinyl records than disposable apps. ACE originated in the early 90s, when the Commodore Amiga was still a powerhouse for multimedia computing. Back then, programmers loved BASIC because it was easy to read and quick to write—but they didn’t love how slow interpreted BASIC could be. Games that should have been fast sometimes ran like they were thinking about it first. ACE solved that problem by compiling BASIC into native 68000-series machine code, producing programs that ran much closer to the speed of C applications. Suddenly, developers could write readable BASIC code and still get performance that didn’t make their users go make coffee while the program opened. The project eventually became open source in the late 90s. Normally, that’s the part of the story where software slowly fades into digital archaeology. Instead, ACE stuck around, maintained by enthusiasts who apparently believe that “deprecated” is just another word for “challenge accepted.”

On paper, updating a BASIC compiler for a vintage platform might sound like polishing a classic typewriter while everyone else is building AI writing assistants. But retro development isn’t only about nostalgia. For many programmers, older systems provide something modern platforms often hide: clarity. When you write software for a classic machine, you see memory limits, processor constraints, and system behavior in a very direct way. There’s no 40-layer abstraction stack quietly doing magic behind the scenes. If something is slow, you know why. If something crashes, it’s usually because of something you did—an uncomfortable but educational experience. ACE fits perfectly into this learning environment. BASIC keeps the syntax approachable, while compilation ensures programs run fast enough to be genuinely useful. It’s like training wheels that secretly attach to a racing bike. The ACE project contributors (Manfred Bergmann, Claude and Stefan) started modernizing the project—not by rewriting everything (because nothing terrifies developers more than rewriting everything), but by gradually updating the infrastructure around it. Build systems were adapted for modern toolchains, cross-development workflows were improved, and the project moved into contemporary version-control practices. These changes might sound technical and slightly dull, but they’re crucial. Without them, contributing to the project would require recreating a 90s development setup, which is fun exactly once and then never again. Modern tooling means new contributors can jump in, fix bugs, and add features without needing a time machine.

The latest release adds features that feel surprisingly modern for a language many people still associate with line numbers and GOTO statements. One standout addition is the INVOKABLE keyword, enabling callback-ready closures. In simpler terms, programmers can now treat functions more flexibly—passing them around, triggering them dynamically, and building more event-driven programs. That’s particularly useful for GUI applications, where software constantly responds to user actions. It’s also proof that even BASIC can learn new tricks without losing its personality. Another major improvement is the YAP BASIC preprocessor, which introduces macros and conditional compilation. Large projects suddenly become easier to manage, and developers can maintain codebases that adapt to different Amiga configurations without turning their source files into spaghetti. (Not that programmers ever write spaghetti code. That’s always someone else’s project.) ACE 2.8.0 also expands functional-style programming options through new list-processing utilities, adds better automated testing, and continues polishing the developer workflow. None of these changes scream “headline feature,” but together they move the compiler forward in a way that makes long-term development more practical. ACE 2.8.0 will not dominate mainstream technology headlines, and it doesn’t need to. Its significance lies elsewhere. It demonstrates that software ecosystems can outlive the market cycles that created them, sustained by communities who simply enjoy building things together. And perhaps that’s the real lesson of the release. In an industry obsessed with the next big platform, it’s refreshing to see a project that quietly says: Yes, we’re still here. Yes, we’re still coding. And yes, the compiler just got another update. After all, some technologies fade away. Others just keep compiling.

Spread the love

MORE AMIGA & RETRO NEWS