Acorn Archimedes: A dive into the late 80s
I have been busy lately programming on the Acorn Archimedes, a series of RISC home computers of the late 80s (1987) sporting one of the first ARM (32 bits) microprocessor. ARM is to this day very popular in embedded systems like smartphones due to low-power consumption.
I never owned one (mostly started with ~90s x86 based PC) but of all systems i know off of that time, this one was to me the most attractive.
It was moderately popular and was mostly used in UK with education / business as a target. It was very widely used in UK schools. It was then supplanted by the RISC PC series in the 90s which are also decent computers.
My main initial goal was to find a suitable retro home computer 16-bit or 32-bit to code for which sported :
- a simple, fast and elegant hardware / software architecture
preferably with no cache (to remain as
simple as possible to optimize)
- decent chunky
frame-buffer graphics capabilities with many colors a plus (the
Archimedes is unfortunately not really great when it come to
- all the development (high / low levels) tools readily available on the machine
All of this wasn't easy to find, most home computers at that time were using planar graphics and some used many dedicated components to do stuff faster, overall this made them slightly harder to master and more complex on the hardware side although they were cheaper than the Archimedes.
On the development tools requirement most computers at that time were bundled with a BASIC environment but most were not that great (performances or features) and were not able to let the user go on lower level (assembly) as needed.
Of all the computers of that time the Archimedes stand out for checking all the points above and many more like compatibility of software up to this day due to the long standing and still being worked on RISC OS / ARM combinations: software written for the late 80s machines can still work nowadays on a Raspberry PI running RISC OS for example which is admirable considering how fast things get flushed out in computing history.
Id guess the Macintosh II was also attractive and matched some of the requirements but those were double the price so i do not consider them as home (affordable) computers although they were much better in term of graphics capabilities.
A rare alternative also is the Enterprise 128 released in 1985 which had a 256 colors chunky frame-buffer with a 3-3-2 bit RGB palette, a good BASIC and custom chips (which are somewhat linked to Acorn due to one of its designer), the main drawback of the Enterprise is that the 256 colors mode was very low resolution (80x256) and it was still a 8-bit machine. (Z80A CPU)
There is also the powerful Japanese computers such as the FM Towns and X68000 but those were much more expensive than the Archimedes. (double if not more the price)
The simple and efficient hardware / software of the Archimedes
The Acorn Archimedes started in 1987 with the 400 series and its 8 MHz ARM2 RISC CPU with three custom chips dedicated to memory (MEMC), video / sound (VIDC) and I/O (IOC) controls.
It was declined in different models with different memory capacity. (up to 8Mb then up to 16Mb with the introduction of ARM3 in late 1990)
The ARM 2 had about 4 MIPS (7 MIPS on later models when clock frequency was increased to 12 MHz) with 27,000 transistors which was less transistors than late 70s 16-bits CPU such as Intel 8086, this show how efficient and ahead of its time RISC design was.
It was one of the fastest home computer in 1987 due to the simplicity and elegance of the newly built ARM / RISC architecture, most instructions takes as low as one clock cycle to execute.
As an example, there was no need of custom chips for memory load/copy because the CPU was already capable of loading or copying up to 15 words (32 bits data) with a single instruction (stm*, ldm*) and with a ~4x speedup compared to similar instructions on Motorola 68000 CPU. There was no custom chips to draw graphics such as sprites, these were all handled in software.
In 256 colors modes with one instruction you can fetch / copy up to 52 pixels at a time, with one instruction you can also clear the screen 56 pixels blocks at a time in few clock cycles. (note: this is not a full replacement of a Bit blit custom chip such as in Amiga which do way more than just a fast load/copy but the CPU is fast so it will be on par in the end although it is more limited for some tricks)
The ARM instruction set is also packed with smart features such as reusing its barrel shifter for immediate value encoding which is a bit confusing at first. There is a total of nine basic instruction types.
The barrel shifter can be used at the same time as other instructions (you can do a MOV with a bit shift in a single cycle) this allow fast single-instruction operations.
Instructions can also 'embed a condition' (eg. execute instruction if some flag is set) so you can sometimes group instructions as a single instruction, this help code density and performances.
The ARM2 had no cache yet (also no branch predictor) because RAM/CPU speed were roughly on par (cache came later with the ARM3 in 1990 machines), the absence of cache and the overall simplicity of the CPU make it a bliss to program for, there is very few hidden abstraction layer when it come to optimize code, it also had plenty registers (16 with more available by switching processor mode), all except the last one were general purpose registers.
The few 'hidden abstraction' are due to the custom chips / ram, for example alignment may matter.
Higher level languages were also able to generate effective code due to its RISC nature.
The only downside of the ARM was code density due to all instructions being encoded as 4 bytes so a program took more memory than if it was using x86 instructions for example, even worse if the program used aggressive optimization like loop unrolling, this may have been improved with the ARM3 and its cache though.
The early ARM CPU have a multiply instruction which was quite fast which took 2 cycles at best and 17 cycles at worst, it doesn't have a divide instruction though and has no hardware support for floating-point arithmetic as standard, floating-point arithmetic is available through emulation by RISC OS or with additional hardware.
Here are the features of the CPU (taken from the official 1987 datasheet):
* 32-bit data bus
* 26-bit address bus giving a 64-MByte uniform address space
* Support for virtual memory systems
* Simple but powerful instruction set
* Co-Processor interface for instruction set extension
* Good high-level language compiler support
* Peak execution rate of 10 million instructions per second (MIPS)
* Fast interrupt response for real-time applications
* Low power consumption (0.1 W typical) with a single +5 V supply
* 84-pin JEDEC B leadless chip carrier or plastic leaded chip carrier
As for the low power VIDC (Video Controller), it is highly programmable with 8, 12, 16 or 24MHz pixels rate and plenty modes. This combined with highly programmable screen parameters allow it to reach very high resolutions in monochrome mode, this wasn't common in 1987 in home computers, it is a very flexible controller albeit with an odd 256 colors palette choice. (see graphics capabilities below)
There is plenty more to the hardware side of the Archimedes like podules (additional modules which were handy to add SCSI drives, MIDI, video capture cards etc.) which will be not talked here because i simply didn't explored them yet. There is also FPU like the Acorn AKA20 We32206 Floating Point Co-Processor and FPA10 for the ARM3.
Of historical significance the ARM250 (starting with the A3010 in 1992) was also the worlds first System on a Chip (SoCs) a single-chip design including the functionality of an ARM2 / ARM3 (still without cache), the IOC1, VIDC1a and MEMC1a chips all integrated into a single chip. The ARM250 was in-between ARM 2 and ARM 3 and was running at a clock frequency of 12 MHz, it was also used in conjunction with slightly faster memory chips.
So what about the hardware downsides of the Archimedes ? If taken as-is the hardware was great but of course there is always shortcoming due to making compromises, some downside which can be cited are the 4 MB RAM limit on the early Archimedes, shared video memory and not that quick Podule bus which made some things impossible like a real graphics card. Most of those issues are not that big and were handled later on but they still exist on early Archimedes. As for the durability some of the early Archimedes now suffer from battery leakage. The early memory controllers also had some issues.
To conclude on the hardware side of the Archimedes, we can say that this computer was mostly relying on the usage of its fast CPU for everything with the help of a few elegantly built custom chips for memory / video / IO.
Software (RISC OS 2 and 3)
The Operating System of the Archimedes at launch was the Arthur OS which was unfortunately rushed (Arthur is a pun related to how rushed the OS was) written as a stop-gap for the 1989 version called RISC OS 2. Arthur OS was not a multitasking operating system and was a bit of an empty shell. Still, both versions provided a full desktop environment with a window manager and overlapping windows.
In between the release of Arthur OS and RISC OS there was RISC iX released in 1988 which was a Unix OS designed to run on specific Archimedes workstations series, it will works on a A540 with a SCSI card or by using a specific disk driver, older Archimedes needs some hardware upgrade (MEMC1a, VIDC1a) to make it compatible.
RISC OS 2 (as seen above although it is RISC OS 3 which didn't change much in term of design) is where things started to be interesting with the OS supporting co-operative multitasking with some limitations, it was reasonably well designed with plenty innovative features such as:
- anti-aliased fonts
- drag-n-drop support (even for saving files)
- dedicated menu button on the mouse (middle button), there is no menu bars anywhere due to that, apps menu are accessible using the middle mouse button. The other two mouse buttons were select, which behaved like a normal mouse button and adjust which did the sort of things you need to resort to shift-click on other platforms
- task bar / icon bar (icons which depict running apps)
It is a great operating system (require a little adaptation time, some of the things is very different than others OS), it is nicely designed, accessible and powerful. The user can do plenty things with the bare OS, there is a command-line shell available at all time (by pressing F12) with most OS API interface exposed as commands and it support some kind of commands script called Obey.
It is also very lightweight, running in 512kb ROM (!) at first and is fast to boot. The API and documentation is also clean.
It was also one of the first 32 bits WIMP OS.
RISC OS 3 which came later was bundled with some decent applications (can be seen in the screenshot above), RISC OS 2 also had applications but they were available externally.
RISC OS files manager has an useful way to serve applications as an executable directory if some care is taken to conform to some recommended practices on the files layout. To give a practical example, if you double-click on an application icon (just some directories with names starting with "!"), RISC OS will automatically look inside that application directory for some set of files and especially one called !Run (which is a script file), and run it.
There is way more things about RISC OS that i did not have explored in details yet such as the Filer (the files manager), desktop / boot files which also seems interesting. There is also modules, 'low-level' programming routines that can extend or replace parts of the operating system. They can be used to add new SWIs and * Commands.
RISC OS was probably a better OS than many alternative of that time (like Atari TOS) due to thoughtful user centered design and features.
RISC OS is a single-user cooperatively multi-tasked operating system which means that one misbehaving application can stall the system (applications needs to be made to cooperate with each others), it is also easy to crash the whole system since there is minimal kernel and memory protection, advantages among other things is a simpler OS architecture, good performance and easiness of writing bare metal programs which use all the available resources.
Software (BBC Basic V)
RISC OS was also bundled with BBC BASIC V, probably one of the most powerful / fast interpreted BASIC ! Mostly because it was made by the same team which conceived the CPU and the OS.
BBC BASIC V had innovative features such as good quality inline low-level assembly support and very powerful ones like EVAL or dynamic variables creation, it is also tightly coupled with the OS interface, most of the things that would seem not possible with standard BASIC languages is just doable with BBC BASIC V due to its high flexibility. It feels like a proper high level language albeit with BASIC syntax.
Coupled with RISC OS API/Commands/Obey files, BBC BASIC make the Archimedes a blissful machine to works on, think about it: with a bare Archimedes in 1989 running RISC OS 2 you have everything at your fingertips to program anything you wanted because a tightly coupled, fast, accessible and powerful high level language is available.
BBC BASIC V can also serve as a complete macro assembler OR also provide abilities to mix BASIC and low-level assembly code for the most critical part of your code. You don't need additional software, all was provided and all of these were quality software.
To test the hypothesis above i actually do all my Archimedes programming under RISC OS 3 running on an emulated 1987 ARM2 / ARM250 (12 MHz) Archimedes (with Arculator), i have built my own dedicated macro assembler which can be seen as a simple wrapper to the BBC BASIC V inline assembler (but more focused on writing low-level machine code), all of that from scratch with bundled stock software, nothing else was ever needed.
Star Fighter 3000
The Archimedes was mainly sold as a business / education platform which was a bit of a shame because its gaming capabilities were also nice with several graphics mode available, from 160x256 to 640x512 in 2 / 4 / 16 / 256 colors.
There is a chunky frame-buffer of 8 bits per pixel with double buffering (and more) out of the box, RISC OS make it easy to setup different screen banks with ability to switch between them with a single OS call.
There is support for a single hardware sprite with fixed width and of any height which was mainly used for the cursor.
The chunky frame-buffer can be seen as a big improvement (easier) compared to planar graphics for all per-pixels graphics operations.
The VIDC (Video Controller) allow vertical hardware scrolling, horizontal scrolling is also possible by using hardware tricks (DMA / video registers). The hardware does not provide a horizontal raster interrupt though so some of the "raster" based effects (like rasterbars or getting more colors on screen) very popular in 8-bit / 16-bit machines / Atari ST / Amiga are not possible out of the box, it can still be done of course through IOC timer-triggered interrupt but it is not so easy unless the Rasterman module is used.
The Archimedes was one of the first home computer to sport high amount of 3D games (for the niche gaming market it was), it was of course due to its fast CPU and chunky frame-buffer which allowed them to run with moderately low development efforts. Most featured high amount of filled polygons for the time.
Smoothest 3D games on 1987 8 MHz Archimedes are those featuring filled polygons, some of them like Zarch run at 25 FPS with many effects like particles, shadows...
Later games sports texture mapping and are smoothest on later machines (ARM250, ARM3) but some of them are still playable on 1987 hardware.
One of the most impressive 3D game (as seen above) on that platform is Star Fighter 3000 which is playable on a 8 MHz 1987 Archimedes ! It sports a textured tiled ground plane, plenty filled polygons graphics and particles with impressive gameplay features. Some other impressive 3D games are Chopper Force, Drifter, DarkWood, Arcturus...
Also, one of the best version of Elite (a 3D space game which sported an innovative procedural universe) was also made for the platform.
Most of the 3D games were running smoothly (like Elite) on the Archimedes compared to other versions. There is also some decent 2D games like Populous, Lemmings etc.
You can even find a video of Doom 2 running on ARM250 (12MHz) Archimedes here! A bit slow but not that bad considering it is probably not optimized for the hardware.
It was capable of displaying a maximum of 256 colors out of a 4096 colors palette. The screen modes provided in RISC OS offer a maximum of 2, 4, 16 or 256 simultaneous on screen colors.
There is a fundamental difference between the 256 colors modes and those offering fewer colors. In modes having less than 256 colors you can redefine the palette to include any selection from the 4096 available. In 256 colors modes you are pretty much restricted to a fixed set of 256 colors as we will see.
256 colors ? Yes but...
The not so great thing about the 256 colors modes is its inflexibility, it was mostly fixed with only 16 colors that you can change at anytime, the other colors depend on your 16 colors choice.
That is why most 256 colors graphics program do not bother to change the default palette, the Archimedes 256 colors mode is severely limited in term of flexibility. There is only 16 shade of grey available for example and you cannot make them available linearly.
if you change one of the top row color, all of the other colors of the column will change
The default palette (as seen above) is decent but show its limits plenty of times with highly saturated colors, this actually give some recognizable characters to Archimedes graphics programs.
As for built-in graphics code the OS API / BBC BASIC V also provide many graphics function to draw shapes, clear the screen or do some common graphics operations, they are reasonably fast but of course cannot match hand made code.
Overall i think the Archimedes computers was almost like the dream home computer of the late 80s (and early 90s) i was looking for, only if it didn't have that strange way of handling 256 colors for graphics program. (they probably had their reasons at the time but still, the 256 colors inflexibility is kinda irritating)
I did not talk about sounds capabilities but it was decent back then with eight-channel, 8-bit, stereo sound. (the only downside is its filtered output)
I also did not talk much about the VIDC1 programming capabilities where custom screen modes can be built allowing as much as a 1440x900@60Hz (monochrome) resolution on 1987 computer without additional hardware. This is clearly unmatched by any home computers at that time...
The sole fact programming for it can still somewhat serve in the actual world (as an introduction to ARM, it is in almost all smartphones !) coupled by the fact programs from 1987 onward to 2022 still work is nothing more than astonishing and a marvel in engineering. (Note: there is still some compatibility issues for early programs due to some hardware differences along the years)
One of my favorite feature is the RISC OS / BBC BASIC V combo, you don't need anything else to code on the Archimedes than with the bundled tools.
If you enjoyed reading this technical ride of the early Acorn Archimedes, you might also enjoy reading about the peoples which made the Archimedes possible such as Sophie Wilson and Steve Furber, Acorn history is full of innovations by very talented peoples.
To conclude i would say that the Archimedes was an awesome computer with great ideas and execution, it is easy and fun to program, the architecture is elegant and with quality software. Definitely a 32-bit favorite of mine from the 80-95 era. I don't know much of the RISC PC which come after the Archimedes but i would say it is relatively comparable and continuing the legacy although it seems there is serious flaw in hardware (the bus) which affected later models so probably less elegant overall.
Thanks to the Stardot community (on discord) since they answered many of my questions regarding the Archimedes.
back to top