A new funding effort from RISC OS Open seeks to modernize the operating system for future Arm hardware.
On Friday, RISC OS Open Limited (ROOL), the organization maintaining the FOSS version of the original Acorn RISC Machine OS, announced its Moonshots initiative. ROOL is looking for money, developers, and community support to fund porting RISC OS to Arm64 – because the 64-bit instruction set is the only one that most modern Arm cores support, from the kernel level up, at least.
ROOL boss Steve Revill – whom we interviewed in 2023 – also published an open letter [PDF] explaining what ROOL needs to do and estimates how much work it will take. ROOL also has a roadmap of the modernizations it feels RISC OS needs. The Moonshots initiative is an ambitious extension of the existing bounties program, which allows the community to sponsor specific features they want in RISC OS.
It's already getting some sponsors, Revill told The Register:
Since we launched the Moonshots, I've already started hearing from people in industry that have automation tools for assembly → C translation, which is a research area which has come on a long way since I last looked at it. I've not really had time to digest but perhaps that will be a way to significantly reduce the size of this particular big ticket – maybe to just a moderately big ticket!
RISC OS is the original native operating system for Arm processors and a true survivor. As The Register described for the 25th anniversary of the Acorn Archimedes way back in 2012, the OS evolved from a version called Arthur, which itself was born from the OS used in Acorn's 6502-based microcomputers, when it shipped with Acorn Computers' first Arm-powered Archimedes machines. The first official public release, Arthur version 1.2, was in September 1987. For context, that's before Windows 2.0 or OS/2 1.0, both of which appeared in December 1987. The Reg FOSS desk talked to project lead Paul Fellows in 2022.
Arthur UI. Source: Matthew Pye
The 1987 Arthur UI – click to enlarge
RISC OS was the slightly more professional name given when version 2.0 shipped in April 1989 – six months before OS/2 1.2 and indeed NeXTstep 1.0, or macOS as Apple calls it these days. Apple now calls the latest version of NeXTstep macOS, and OS/2 1.2 was the version that introduced the 3D-shaded buttons that Windows 3.0 made famous when it first appeared over a year later.
It's interesting to us the difference between the Arm world RISC OS lives in, and that of x86, in terms of CPU backwards compatibility.
In the land of x86, all 64-bit chips – variously called AMD64, x64, x86-64, or simply x86 for old time's sake – also support x86-32, and indeed 16-bit code all the way back to its 8086 chip from 1978. In 2023, Intel proposed a simplified specification, x86S, which would drop 16 and 32-bit support. The next year it formed an x86 ISA advisory group, but the x86S idea did not go down well and was cancelled in December. It's part and parcel with the x86 world's ethos of backwards compatibility.
With Arm, it's a lot less bloat, if that's what you want. Chip designers can pick off-the-shelf Arm CPU core designs to license for their processors, or indeed design their own Arm-compatible cores using a top-tier architecture license. To keep costs down, hardware makers only license the parts they want. If they don't need to run old 32-bit code, they may reduce costs by omitting the Arm32 instruction set, if the selected core or architectural license allows.
On top of that, for general-purpose application processors, the kind you'd want to put in a server or PC, Arm has been going further and further down the path of providing 64-bit-only cores, starting with kernel mode, and then user mode.
The result is that while Intel lost the battle to remove its old instruction sets, most modern Arm-based processors and system-on-a-chip families include either limited Arm32 support, or none. For example, the Arm Cortex-A76 CPU cores in the Raspberry Pi 5 can run Arm32 applications, but they can't boot a native 32-bit Arm OS. The cores only support 64-bit code at the kernel level.
RISC OS 5.30 comes with quite an assortment of applications, and plenty more are online.
RISC OS 5.30 – click to enlarge
Thus if RISC OS is to live on, running native on future Arm hardware, it needs to be 64-bit sooner than later. Right now, it's 32-bit.
Even getting to that point was a bit of a Herculean effort, so the OS has been through a degree of processor migration at least once. When Acorn left the scene, and the RISC OS community got the rights to continue working on the desktop OS, relaunched in the form of RISC OS 4, the operating system – still written pretty much in hand-coded assembly – used Arm's original 26-bit addressing from the 1980s. 32-bit registers, 26-bit memory addresses. The upper eight bits of the program counter held the CPU flags.
Back in the early Arm days, 26-bit addressing gave the OS access to up to 64MB of physical RAM at any one time, which seemed more than enough. By the arrival of the ARM6 CPU at the turn of the 1990s, the architecture supported full 32-bit, and later 26-bit addressing was dumped. (Gray-haired users of early 680x0 Macs may dimly remember when Apple faced a broadly comparable issue.)
Acorn clung onto 26-bit, even though 32-bit Arm cores were available through the 1990s and beyond, partly at least because going to 32-bit would break application compatibility. If there was one thing the Acorn ecosystem needed, it was as many apps as it could keep hold of, arguably.
RISC OS version 5, a fork produced by Castle Technology in the early 2000s, bit the bullet and went fully 32-bit so that it could run on the 32-bit-only processor in Castle's Iyonix computer, which ironically enough was powered by an Intel Xscale that was Arm-based for reasons that if we went into would make this long-ish article officially long. (Let alone getting into the RISCOS Ltd RISC OS 4 vs Castle Technology RISC OS 5 fight that was eventually settled.)
That 32-bit change-over with version 5 was relatively modest, rather than a complete rewrite. It needed some new 32-bit build tools, and as we said, the new 32-bit RISC OS could not run 26-bit-based binaries – although the Aemulor compatibility layer fixed that.
The shift to 64-bit is much, much more challenging, as the RISC OS wiki explains. With the change from 26-bit to 32-bit addressing, the instruction set remained pretty much the same. Moving from 26- to 32-bit addresses involved ensuring flags were't stored or assumed in the upper bits of pointers, for instance.
But with 32- to 64-bit, the instruction set changes completely. 64-bit Arm is a fresh start, with a 64-bit MIPS-like RISC approach. 32-bit Arm is ... 32-bit Arm. It's 32-bit RISC with little quirks from the geniuses at Acorn, such as the multiple load and store instructions. That means the OS, all of that hand-coded assembly, has to be rewritten in 64-bit Arm code. As the sponsorship page says, the current plan is to redo the heart of RISC OS "from hand-crafted Arm assembly language to high-level language (eg, portable ANSI C)."
It's a big goal. Revill's open letter says:
Our team at ROOL has estimated that this will require a dedicated group of developers working full-time over several years.
RISC OS remains unique. It's a modernized, updated version of a proprietary 1980s OS. It can run – and run well – on any Raspberry Pi from the first model up to the Pi 4 and Pi 400. However, there is no Raspberry Pi 5 version and, according to ROOL, there won't be unless this Moonshot succeeds. It's tiny, fast, and simple, and in the humble opinion of this vulture, it has the most elegant desktop GUI ever created other than classic MacOS. However, it does have profound limitations, such as not-quite-comprehensive memory protection – for lingering historical compatibility reasons, once again – and no support for modern multi-core processors.
We would love to see this moonshot succeed. It's a taste of how small and unbloated the best 20th century OSes were. There's nothing else quite like it in the world today. ®
Boot-up-note
Speaking of RISC OS, it's worth mentioning Pyromaniac, a very cool project to implement RISC OS from scratch in Python, with Arm emulation built-in to run RISC OS executables on non-Arm systems. The code is not publicly available, but can be tried out at the command-line level in the cloud, here. It's designed to run on Linux, macOS, and Windows.
Pyromaniac provides 64-bit and 32-bit RISC OS environments, including a desktop. It was developed by Gerph, who among many other things, worked for RISCOS Ltd back in the day, which produced in the late 1990s to the 2000s the RISC OS 4, Select, and 6 family of the original operating system from the ashes of Acorn.
The Pyromaniac software also powers an online RISC OS build server.