Twenty Years of RISC OS Open: A Veteran OS Gets a Vibe Coding Revival

Twenty Years of RISC OS Open: A Veteran OS Gets a Vibe Coding Revival

In 2006, when the iPhone was still a rumor and Android hadn't yet come to market, a small team of British developers did something radical: they opened the source code of RISC OS 5, the direct descendant of the operating system that ran on the Acorn Archimedes. Two decades later, RISC OS Open is celebrating its 20th anniversary — and the little OS that could is enjoying a renaissance, thanks in part to the very forces that were unthinkable back then: cloud computing, Raspberry Pi, and the hottest trend in programming, "vibe coding".

RISC OS has never been mainstream. Its quirky design — where the entire GUI is drawn in a small ROM, boots in under 10 seconds, and handles files via drag-and-drop icons — is both its charm and its curse. Yet it has survived corporate neglect, the death of Acorn, and the rise of Linux and Windows. Now, as we look back at 20 years of open development, we find a community that is not just preserving history but actively building the future.

The Birth of a Legend

RISC OS was born in 1987, the brainchild of Acorn Computers in Cambridge, UK. It was built to run on the ARM processor — a chip designed by Acorn itself, which later became the most ubiquitous architecture on Earth due to its supremacy in mobile and embedded devices. The OS was written primarily in ARM Assembly and C, and it pioneered a WIMP (Windows, Icons, Menus, Pointer) interface that was ahead of its time.

But Acorn's fortunes waned, and in 1998 the company was dissolved. RISC OS passed through the hands of Pace Micro Technology, Element 14, and eventually split into two lineages: RISC OS Ltd (which took the 6.x branch) and Castle Technology (which continued the 5.x line on the Iyonix PC). In 2006, with the help of a grant from the UK government, RISC OS Open Ltd was formed to encourage open development of RISC OS 5. The source was made available under a shared-source license — and the rest is history.

Twenty Years of Open Source Evolution

The open-sourcing of RISC OS 5 wasn't an overnight revolution. It took years to separate the OS into clean modules that could be built by strangers on any machine. Over time, much of the codebase was relicensed under Apache 2.0, and today the project boasts a robust GitLab-based repository, an active forum, and a vibrant community of developers. You can explore the official repositories and download images at riscosopen.org.

One of the most visible achievements is support for modern hardware. The OS runs beautifully on the Raspberry Pi 4 and 5, thanks to community efforts. There are even builds for the PineBook and various ARM-based virtual machines. And the resurrection of the OS owes a lot to the built-in app store, !Store, which makes downloading and updating software as simple as clicking an icon.

This table isn't meant to suggest RISC OS is "better" — it's to illustrate how radically different it is. The fact that it still exists, and is being actively developed, is a testament to the power of open source.

Getting Hands-On: Running RISC OS in 2026

Want to see what 20 years of community effort looks like? You can run RISC OS today for free. The easiest route is to use the official Raspberry Pi SD card image.

1. Go to the downloads page and grab the latest Pi image.
2. Write it to an SD card. On Linux or macOS, you can use dd:
   bash sudo dd if=RISC_OS_Pi.img of=/dev/sdX bs=4M status=progress
   (Replace /dev/sdX with your SD card's device node. On Windows, use any image writer that supports raw images.)
3. Insert the card into your Pi, connect a monitor (HDMI), keyboard, and mouse, then power up. You'll be greeted by the familiar purple desktop.

If you don't have a Pi, you can run RISC OS in a software ARM emulator — the official site has instructions.

Now, try opening a task window (Ctrl+F12) and typing:

PRINT "Hello from RISC OS!"
END

Press Enter, and you've officially run a piece of computing history.

Building RISC OS from Source: A 10-Minute Guide

For the developer-minded, the real magic is in building your own ROM. Here's how to get started.

First, clone the main source tree. The official repositories live on the RISC OS Open GitLab. Clone the repository for the component you want to modify. For example, to build the kernel:

git clone https://gitlab.riscosopen.org/Products/RISC_OS.git
cd RISC_OS
make

Of course, this is a massive oversimplification. The build system, BuildSys, requires several pre-installed tools: a C compiler (GCC), the NetBSD make, and a set of cross-compilation utilities. The official documentation on riscosopen.org walks you through it step by step. Once you have a working toolchain, you can compile the entire OS from source and produce a ROM image.

A practical tip: if you're only modifying one module (say, the Filer), you can often use the MakeFile inside that module's directory. The beauty of the RISC OS build system is that it's modular — just like the OS itself.

Common pitfalls to avoid:
- Don't try to build the whole OS the first time. Start with a single module.
- Ensure you have the exact version of the compiler that the build expects; the build system is sensitive to toolchain versions.
- If you get an error about missing headers, don't panic — use the export command in the build environment to set the correct paths.

Vibe Coding Meets a 1987 Icon

Now, for the elephant in the room: vibe coding. Coined in 2025 by Andrej Karpathy, the term refers to the practice of letting AI assistants generate your code from natural-language prompts, often iterating in a "vibe" rather than with formal specifications. For a 30-year-old OS, vibe coding might seem like a poor fit, but it's actually opening up new possibilities.

Imagine wanting to write a new file viewer for RISC OS. In the past, you'd need to master the WIMP protocol, understand kernel-message passing, and be fluent in legacy C. Today, you can open your AI assistant and ask for a basic SDL2 program that draws a rectangle on screen. With a little prompting, you'll have working ARM code that compiles and runs on RISC OS. No, it won't be perfect — you'll still need to understand the intricacies of the OS — but the barrier to entry is lower than ever.

"Vibe coding is about trusting the AI and iterating based on feedback. It's ideal for exploring legacy codebases where the patterns are well-documented." — a sentiment echoed by many in the hobbyist community.

Even conservative RISC OS developers are starting to experiment with AI pair programming. For instance, GitHub Copilot can suggest code snippets for ARM assembly and C. If you're looking to integrate such tools into your workflow, ASI Biont supports integration with GitHub Copilot via its API — learn more at asibiont.com/courses.

But a word of caution: RISC OS runs close to the hardware, with direct memory access and a cooperative scheduler. Trusting an AI blindly can lead to crashes and corrupted ROMs. The golden rule of vibe coding applies doubly here: always review, always test.

Why RISC OS Still Matters (Even Now)

RISC OS Open's 20th anniversary is more than a nostalgic milestone. It's a case study in how a dedicated community can keep a niche platform alive against all odds. It's also a reminder that not all innovation is about new, shiny things. Sometimes, it's about preserving and refining something that, for its users, is still perfect.

Moreover, RISC OS offers an alternative to the homogenized world of Linux and Windows. It teaches you about the fundamentals of operating systems—because you can actually understand the entire codebase. And with the rise of ARM in the datacenter, RISC OS's ARM-native heritage looks more prescient than ever.

Conclusion

So, does a 20-year-old open-source OS have a place in a world of AI-generated code and cloud-native everything? If the RISC OS Open community is any indication, absolutely. The OS has survived professional mishaps, licensing dramas, and hardware shifts. It's now accessible, open, and — thanks to vibe coding — easier to contribute to than ever.

Whether you're a seasoned developer or a curious newcomer, now is the perfect time to download a copy, tinker with the source, and add your own chapter to the RISC OS story. After all, twenty years is just the beginning.