This article is more than 1 year old

Original Acorn Arthur project lead explains RISC OS genesis

Paul Fellows describes how it beat the overambitious ARX to Acorn's Archimedes computer

One of the longest-lived GUI operating systems in the world has its origins as an emergency project – specifically the means by which Acorn planned to rescue the original Archimedes operating system.

This is according to the original Acorn Arthur project lead, Paul Fellows, who spoke about the creation of RISC OS at the RISC OS User Group Of London, ROUGOL [after some helpful arrangements made by Liam Proven – Ed].

On Monday, your correspondent hosted and moderated a reunion of four of the original developers of Acorn's RISC OS.

Fellows explained that participating were "Paul Fellows (VidC controller, Palette, I2C interface, Real Time Clock and EEPROM), Tim Dobson (Fonts, Audio and Utilities), Richard Manby (Graphics and Desktop), and Stuart Swales (Fileswitch and Heap Manager)."

Today, RISC OS is still rumbling along, and version 5 is now open source. But it wasn't the original, planned operating system for Acorn's Archimedes computer. That was going to be ARX, of which almost no trace exists today apart from a few Usenet posts. What information survives has been compiled into the Wikipedia article.

ARX was a highly buzzword-compliant project from the Acorn Research Center (ARC) in Palo Alto – neighbor to the famed Xerox PARC, where the graphical user interface as we know it today was pioneered. The design was ambitiously Unix-like.

In Fellows' words: "A group in Palo Alto, there was a guy called Jim Mitchell that led the ARX development team out there and a lot of very highly paid Californian software engineers writing it. It would have been absolutely wonderful, it just needed about another 20 years of Moore's Law to make it plausible.

"This ARX operating system was preemptively multitasking, multi-threaded, multi-user, written in Acorn-extended Modula2+."

It was big, complicated, and slow on the very early Arm silicon of the time.

ARC was developing it on the A500 computer: "The first prototype ARM-based machines. Made in 1986, it predates the A305/310 by some 12 months… Inside the case there is a 20MB hard drive, the main board which has 4MB of RAM and the four main chips. Originally fitted with an ARM-1 (3-micron) these machines were upgraded to ARM-2 (2-micron) with the multiply instruction during the period when they were in use for development."

The ARC team regularly reported to Acorn management in the UK, who became concerned by the project's slow progress – it wasn't going to be ready in time for the launch of the Archimedes family. Acorn soon turned to Fellows and the Acornsoft team – its in-house software development and publishing wing – to produce an alternative OS for the Archimedes ready for its launch in the absence of a finished ARX.

Fellows added: "I was hauled in, in front of the board of directors at Acorn, and they said 'the hardware is being made and we have got no software, you guys aren't doing very much at Acornsoft, can you make us a BBC-like operating system? You've got 5 months,' as that's when the hardware is going to hit the streets. And like an idiot, I said 'yes.'"

This ridiculously tight timeline is the origin of the codename Arthur, under which the version 1 code shipped: A Risc by THURsday.

As Arthur was being pulled together, the ARX OS team reached a point where they were ready to demonstrate to Acorn bosses a prototype of their OS, having got as far as a GUI and a demo app.

RISC OS in the 21st century: this is your grandfather's Archimedes, pretty much, just 1000× faster

RISC OS in the 21st century

It was decided Arthur would be demonstrated alongside ARX, to give bosses an idea of how the projects were coming together and which OS was likely to be finished first. It seemed imperative to the Arthur coders to ensure their very early and simple OS was ahead of the sophisticated ARX, but how?

"Big mistake: they'd told us what their demo was going to be beforehand," the project lead said. "So they'd got a ticking clock running, and they said 'and you can click on another one and run several of these at once, you won't be able to do that on Arthur as it can't multitask, look!' They clicked on three or four of them and got them running.

"When the fourth one started the system started to engage virtual memory and started swapping – on a 4MB machine – and the hands on the clock started ticking once every 16 seconds."

Since the ARX team had told him what their demo app was the night before, the Arthur team came prepared. At this point, Arthur was mainly a text-mode OS, much like the BBC Micro MOS before it.

The trick was to rig together a clock program that appeared to multitask but instead was one program pretending to be many. Seeing that running smoothly was enough to convince Acorn that Arthur, though relatively primitive, was the OS for the launch as it actually seemed to work well enough in a way that wouldn't infuriate users. ARX and its swapping virtual memory was toast.

Even the Arthur desktop environment was effectively a prototype that was pushed into production.

"There's a cautionary tale behind this," Fellows said. "Richard Manby wrote this (Arthur Desktop), in BASIC as a demonstration of the window manager and what it could do, using the bitmap fonts and so forth – the outline font manager wasn't ready at this point. As a piece of demo-ware, it escaped into the wild: they burnt it into the ROM, and it's what it boots up with. But it was a demonstration of how you can write programs to use the window manager! Never underestimate the marketing department, they'll get you every time. If you write a demo, they'll sell it."

"We just wrote a BASIC program that was allowed to draw itself lots of times. Absolute fraud!

"Tim Dobson had written a clock program, we turned up with an A305 with 256KB RAM, an Arthur desktop, and a ticking clock program, and we ran 16 of them which ticked smoothly… and ARX got canceled the next day."

Remarkably, RISC OS's multitasking functionality was almost an afterthought. It came together as a cooperative multitasking system, rather than automatically preempted, in that applications made a system call called Wimp_Poll to hand off control to the next program. If each program did a little bit of work and passed the CPU to the next one, many times a second, the user got to experience a seamless multitasking environment.

"Going back to Neil – he had a wizard idea, he said at the coffee machine one day, 'You know what, if we fool around with MEMC we can do overlays, we can take an application program, use the memory controller to whisk it away and map it somewhere else in the memory map and put another program in at 0x8000 (which was where we mapped our applications too), the logical equivalent of PAGE on the BBC Micro, we can do overlays, switch from one program to another.

"I thought, 'That's all very well, Neil, but why would we want to bother doing that?' He came up with the most astonishing idea I'd ever heard. 'If I do this on the return from Wimp_Poll instead, so that your program calls Wimp_Poll and instead of getting an answer back, it gets swapped out and someone else gets swapped in, and they get the return from the Wimp_Poll that they called sometime earlier… Then we can actually have the full multitasking system that is RISC OS."

One drawback is that if a program never calls Wimp_Poll, due to a bug, no other program gets the CPU and the desktop freezes. Later versions of RISC OS provided a means to kill the stuck app and unlock the desktop, and some third-party code was released in an attempt to turn this approach into a proper pre-emptive one.

Screenshot of the RISC OS 5 desktop

The RISC OS 5 desktop

RISC OS turned out to be a more influential system than is generally remembered today. Alongside OS-managed scalable fonts, and windows that are dragged in real-time around the desktop complete with its contents, rather than the dotted outline that was all any other GUI OS could do, it also introduced the concept of the icon bar.

You know, the icon bar, as seen years later in Windows 95.

"I found this page I was very pleased by: 'Apple acquired the Dock from Steve Jobs' NeXTstep OS which stole it from Acorn's Arthur Operating System of 1987.'

"Damn right it did! Tragically you couldn't patent software at that point. So this was the one I invented, I came up with the idea of the icon bar across the bottom. In case anyone ever asked where it came from, we were sat in a room thinking 'how do we design this to be different, so we don't get sued by Apple?' The Mac had a menu bar of text across the top, so we thought 'we can't go across the top, we'll have to go across the bottom – and we can't use text, so we'll have to use icons.' That's why it's like that," Fellows continued.

"There was a guy at Colton Software with us… who joined Microsoft in Seattle, and it was shortly after that that Windows acquired an icon bar. I know how that idea got there."

The ROUGOL website has a full transcript of Fellows' original talk, from some years ago, on the history of RISC OS, and soon there should be a video of Monday's talk, with a transcript to follow. Fellows also previously spoke about the development of the OS here. ®

More about


Send us news

Other stories you might like