Hubbry Logo
RISC OSRISC OSMain
Open search
RISC OS
Community hub
RISC OS
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
RISC OS
RISC OS
RISC OS
View on Wikipedia
from Wikipedia
This article is about the operating system developed by Acorn Computers Ltd. For the OS developed by MIPS Computer Systems, see MIPS RISC/os.

RISC OS
A screenshot of RISC OS 5.30 (released 2024) running on a Raspberry Pi
DeveloperAcorn Computers

Open-source (version 5)

Proprietary (versions 4 & 6)

Written inBBC BASIC, C, C++, assembly language
Working stateCurrent
Source modelClosed source; open source for some versions since 2018
Initial release25 September 1987; 38 years ago (1987-09-25)[1]
Latest release
  • 5.30[2] / 27 April 2024; 18 months ago (2024-04-27)
  • 6.20 / 1 December 2009; 15 years ago (2009-12-01)
Latest preview5.31
Marketing targetAcorn personal computers
Available inEnglish
Update methodFlash ROM, OTP ROM, or loadable ROM image
Package managerPackMan, RiscPkg
Supported platformsARM
Kernel typeMonolithic
Default
user interface		GUI
License
Preceded byMOS (discontinued)
ARX (discontinued)
Official websiteriscosopen.org RISC OS Open
riscos.com RISCOS

RISC OS (/rɪsk.oʊˈɛs/)[4] is an operating system designed to run on ARM computers. Originally designed in 1987 by Acorn Computers of England, it was made for use in its new line of ARM-based Archimedes personal computers and was then shipped with other computers produced by the company. Despite the demise of Acorn, RISC OS continues to be developed today by the RISC OS Open community on version 5.0 of the system that was open sourced in 2018.[5]

RISC OS is a modular operating system and takes its name from the reduced instruction set computer (RISC) architecture it supports. It incorporates a graphical user interface and a windowing system. Between 1987 and 1998, RISC OS shipped with every ARM-based Acorn computer including the Archimedes line, Acorn's R line (with RISC iX as a dual-boot option), RiscPC, A7000, and prototype models such as the Acorn NewsPad and Phoebe computer. A version of the OS, named NCOS, was used in Oracle's Network Computer and compatible systems.

After the break-up of Acorn, development of the OS was forked and continued separately by several companies, including RISCOS Ltd, Pace Micro Technology, Castle Technology, and RISC OS Developments.[6] Since then, it has been bundled with several ARM-based desktop computers such as the Iyonix PC[7] and A9home. Most recent stable versions run on the ARMv3/ARMv4 RiscPC, the ARMv5 Iyonix,[8] ARMv7 Cortex-A8 processors[9][10][a] and Cortex-A9 processors[11][b] and the low-cost educational Raspberry Pi series of computers, with the exception of the Raspberry Pi 5.[12][13][14]

History

[edit]
Main article: History of RISC OS
Original cogwheel logo

The first version of RISC OS was originally released in 1987 as Arthur 1.20. The next version, Arthur 2, became RISC OS 2 and was released in April 1989. RISC OS 3.00 was released with the A5000 in 1991, and contained many new features. By 1996, RISC OS had been shipped on over 500,000 systems.[15]

An Acorn Archimedes A3020 computer running RISC OS

Acorn officially halted work on the OS in January 1999, renaming themselves Element 14. In March 1999 a new company, RISCOS Ltd, licensed the rights to develop a desktop version of RISC OS from Element 14, and continued the development of RISC OS 3.8, releasing it as RISC OS 4 in July 1999. Meanwhile, Element 14 had also kept a copy of RISC OS 3.8 in house, which they developed into NCOS for use in set-top boxes. In 2000, as part of the acquisition of Acorn Group plc by MSDW Investment, RISC OS was sold to Pace Micro Technology,[16] who later sold it to Castle Technology Ltd.

In May 2001, RISCOS Ltd launched RISC OS Select, a subscription scheme allowing users access to the latest RISC OS 4 updates. These upgrades are released as soft-loadable ROM images, separate to the ROM where the boot OS is stored, and are loaded at boot time. Select 1 was shipped in May 2002, with Select 2 following in November 2002 and the final release of Select 3 in June 2004. In the same month, RISC OS 4.39, dubbed RISC OS Adjust, was released. RISC OS Adjust was a culmination of all the Select Scheme updates to date, released as a physical set of replaceable ROMs for the RiscPC and A7000 series of machines.

Meanwhile, in October 2002, Castle Technology released the Acorn clone Iyonix PC. This ran a 32-bit (in contrast to 26-bit) variant of RISC OS, named RISC OS 5. RISC OS 5 is a separate evolution of RISC OS based upon the NCOS work done by Pace. The following year, Castle Technology bought RISC OS from Pace for an undisclosed sum. In October 2006, Castle announced a shared source license plan, managed by RISC OS Open Limited, for elements of RISC OS 5.

In October 2018, RISC OS 5 was re-licensed under the Apache 2.0 license.[17]

In 2018 RISC OS Developments acquired Castle Technology Ltd including its intellectual property.[6]

In December 2020, the source code of RISC OS 3.71 was leaked to The Pirate Bay.[citation needed]

Features

[edit]

OS core

[edit]

The OS is single-user and employs cooperative multitasking (CMT).[18] While most current desktop OSes use preemptive multitasking (PMT) and multithreading, RISC OS remains with a CMT system. By 2003, many users had called for the OS to migrate to PMT.[19] The OS memory protection is not comprehensive.[20][21] A third party attempt to add preemptive multitasking was started in 1999, as the Wimp2 project,[22] and similar goal added to the RISC OS Open roadmap in 2015.[23] In addition support for Posix / SysV / BSD pthread (preemptive-threading) was made available through the provision of UnixLib 3.6 in 1992, a C library introduced to permit the porting of the standard GNU / BSD tool chains to RISC OS, by Alun Jones, then of the Higher Education National Software Archive (HENSA). As of 2025 UnixLib is available through the PackMan package manager.

The core of the OS is stored in ROM, giving a fast bootup time and safety from operating system corruption. RISC OS 4 and 5 are stored in 4 MB of flash memory, or as a ROM image on SD card on single board computers such as the Beagleboard or Raspberry Pi, allowing the operating system to be updated without having to replace the ROM chip. The OS is made up of several modules. These can be added to and replaced, including soft-loading of modules not present in ROM at run time and on-the-fly replacement. This design has led to OS developers releasing rolling updates to their versions of the OS, while third parties are able to write OS replacement modules to add new features. OS modules are accessed via software interrupts (SWIs), similar to system calls in other operating systems.

Most of the OS has defined application binary interfaces (ABIs) to handle filters and vectors. The OS provides many ways in which a program can intercept and modify its operation. This simplifies the task of modifying its behaviour, either in the GUI, or deeper. As a result, there are several third-party programs which allow customising the OS look and feel.

File system

[edit]

The file system is volume-orientated: the top level of the file hierarchy is a volume (disc, network share) prefixed by the file system type. To determine file type, the OS uses metadata instead of file extensions. Colons are used to separate the file system from the rest of the path; the root is represented by a dollar ($) sign and directories are separated by a full stop (.). Extensions from foreign file systems are shown using a slash (example.txt becomes example/txt).[24] For example, ADFS::HardDisc4.$ is the root of the disc named HardDisc4 using the Advanced Disc Filing System (ADFS) file system. RISC OS filetypes can be preserved on other systems by appending the hexadecimal type as ',xxx' to filenames.[24][25] When using cross-platform software, filetypes can be invoked on other systems by naming appending '/[extension]' to the filename under RISC OS.[26]

A file system can present a file of a given type as a volume of its own, similar to a loop device. The OS refers to this function as an image filing system. This allows transparent handling of archives and similar files, which appear as directories with some special properties. Files inside the image file appear in the hierarchy underneath the parent archive. It is not necessary for the archive to contain the data it refers to: some symbolic link and network share file systems put a reference inside the image file and go elsewhere for the data.

The file system abstraction layer API uses 32-bit file offsets, making the largest single file 4 GiB (minus 1 byte) long. However, prior to RISC OS 5.20 the file system abstraction layer and many RISC OS-native file systems limited support to 31 bits (just under 2 GiB) to avoid dealing with apparently negative file extents when expressed in two's complement notation.[citation needed]

File formats

[edit]
Main article: List of RISC OS filetypes

The OS uses metadata to distinguish file formats. Some common file formats from other systems are mapped to filetypes by the MimeMap module.[27]

Kernel

[edit]

The RISC OS kernel is single-tasking and controls handling of interrupts, DMA services, memory allocation and the video display; the cooperative multi-tasking is provided by the WindowManager module.[18]

Desktop

[edit]
A screenshot of RISC OS 4

The WIMP interface is based on a stacking window manager and incorporates three mouse buttons[28] (named Select, Menu and Adjust), context-sensitive menus, window order control (i.e. send to back) and dynamic window focus (a window can have input focus at any position on the stack). The icon bar (Dock) holds icons which represent mounted disc drives, RAM discs, running applications, system utilities and docked: files, directories or inactive applications. These icons have context-sensitive menus and support drag-and-drop operation. They represent the running application as a whole, irrespective of whether it has open windows.

The GUI functions on the concept of files. The Filer, a spatial file manager, displays the contents of a disc. Applications are run from the Filer view and files can be dragged to the Filer view from applications to perform saves, rather than opening a separate 'Save' dialog box where the user must navigate to a location already visible in the Finder. In addition, files can be directly transferred between applications by dragging a save icon into another application's window.

Application directories are used to store applications. The OS differentiates them from normal directories through the use of an exclamation mark (also called a pling or shriek) prefix. Double-clicking on such a directory launches the application rather than opening the directory. The application's executable files and resources are contained within the directory, but normally they remain hidden from the user. Because applications are self-contained, this allows drag-and-drop installing and removing.

The RISC OS Style Guide encourages a consistent look and feel across applications. This was introduced in RISC OS 3 and specifies application appearance and behaviour. Acorn's own main bundled applications were not updated to comply with the guide until RISCOS Ltd's Select release in 2001.[29]

Font manager

[edit]

RISC OS was the first operating system to provide scalable anti-aliased fonts.[30][31][32][33] Anti-aliased fonts were already familiar from Arthur, and their presence in RISC OS was confirmed in an early 1989 preview,[34] featuring in the final RISC OS 2 product, launched in April 1989.[35]

A new version of the font manager employing "new-style outline fonts" was made available after the release of RISC OS,[36] offering full support for the printing of scalable fonts, and was provided with Acorn Desktop Publisher.[37] It was also made available separately and bundled with other applications.[38] This outline font manager provides support for the rendering of font outlines to bitmaps for screen and printer use, employing anti-aliasing for on-screen fonts, utilising sub-pixel anti-aliasing and caching for small font sizes.[39] At the time of the introduction of Acorn's outline font manager, the developers of rival desktop systems were either contemplating or promising outline font support for still-unreleased products such as Macintosh System 7 and OS/2 version 2.[40]

From 1993, starting with the German RISC OS 3.12, and in 1994 for RISC OS 3.5, it has been possible to use an outline anti-aliased font in the WindowManager for UI elements, rather than the bitmap system font from previous versions.[41][42] RISC OS 4 does not support Unicode but "RISC OS 5 provides a Unicode Font Manager which is able to display Unicode characters and accept text in UTF-8, UTF-16 and UTF-32. Other parts of the RISC OS kernel and core modules support text described in UTF-8."[43]

Support for the characters of RISC OS (and some other historic computers) was added to Unicode 13.0 (in 2020).[44]

Bundled applications

[edit]
Main article: List of RISC OS bundled applications

RISC OS is available in several distributions, all of which include a small standard set of desktop applications, but some of which also include a much wider set of useful programs. Some of those richer distributions are freely available, some are paid for.

Backward compatibility

[edit]

Limited software portability exists with subsequent versions of the OS and hardware. Single-tasking BBC BASIC applications often require only trivial changes, if any.[citation needed] Successive OS upgrades have raised more serious issues of backward compatibility for desktop applications and games.[45] Applications still being maintained by their author(s) or others have sometimes historically been amended to provide compatibility.[citation needed]

The introduction of the RiscPC in 1994 and its later StrongARM upgrade raised issues of incompatible code sequences and proprietary squeezing (data compression). Patching of applications for the StrongARM was facilitated and Acorn's UnsqueezeAIF software unsqueezed images according to their AIF header.[46] The incompatibilities prompted release by The ARM Club of its Game On![47][48] and StrongGuard software.[47][49][50] They allowed some formerly incompatible software to run on new and upgraded systems. The version of the OS for the A9home prevented the running of software without an AIF header (in accord with Application Note 295)[51] to stop "trashing the desktop".[52]

The Iyonix PC (RISC OS 5) and A9home (custom RISC OS 4) saw further software incompatibility because of the deprecated 26-bit addressing modes. Most applications under active development have since been rewritten.[53][54][55] Static code analysis to detect 26-bit-only sequences can be undertaken using ARMalyser.[56] Its output can be helpful in making 32-bit versions of older applications for which the source code is unavailable.[57][56][58] Some older 26-bit software can be run without modification using the Aemulor emulator.[55][59][60]

Additional incompatibilities were introduced with newer ARM cores, such as ARMv7 in the BeagleBoard and ARMv8 in the Raspberry Pi 3. This includes changes to unaligned memory access in ARMv6/v7 and removal of the SWP instructions in ARMv8.[61]

Supported hardware

[edit]

RISC OS has also been used by both Acorn and Pace Micro Technology in various TV connected set-top boxes, sometimes referred to instead as NCOS.[citation needed] A special cut down RISC OS Pico (for 16MiB cards and larger) styled to start up like a BBC Micro was released for BASIC's 50th anniversary.[62] SD card images have been released for downloading free of charge to Raspberry Pi 1, 2, 3, & 4 users with a full graphical user interface (GUI) version[63] and a command-line interface only version (RISC OS Pico, at 3.8 MB).[64]

Versions of RISC OS run or have run on the following hardware: (RISC OS Open Limited adopted[65] the 'even numbers are stable' version numbering scheme post version 5.14, hence some table entries above include two latest releases – the last stable one and the more recent development one.)

RISC OS compatible hardware
Machine ARM architecture Introduced Acorn version RISCOS Ltd version Castle Technology, RISC OS Open version
First Last First Last First Latest
ARM with 26-bit program counter
Acorn Archimedes ARMv2 1987–1992 0.20 3.1x — — — —
ARM with 26- & 32-bit program counter
Acorn Risc PC ARMv3 / v4 1994[66] 3.50[66] 3.71 4.00 6.20[67] 5.15 5.30[68]/5.31
Acorn A7000 and A7000+ ARMv3 1995[69] – 1997[70] 3.60[69][70]
Acorn Phoebe (cancelled) ARMv4 1998 3.80 (Ursula) — — — — —
MicroDigital Medi[71] ARMv3 1998[72] 3.71[72] — 4.02 6.20 — —
MicroDigital Mico 1999[73] — — 4.03[73] 4.39[67] — —
RiscStation R7500 1999[74] — — 4.03[74] 4.39[67] — —
Castle Kinetic RiscPC ARMv4 2000[75] — — 4.03 6.20 5.19[76] 5.30[68]/5.31
MicroDigital Omega 2003[77] — — 4.03[78] 4.39[67] — —
Advantage Six A75 ARMv3 2004[79] — — 4.39[80] — —
ARM with 32-bit program counter
Iyonix Ltd Iyonix PC ARMv5TE 2002 — — — — 5.01 5.30[81]/5.31
Advantage Six A9 (Home/RM/Loc) ARMv4T 2005 — — 4.42[67] — —
BeagleBoard[9] ARMv7-A 2008 — — — — 5.15 5.30[82]/5.31
IGEPv2[83] 2009 — — — —
DevKit8000 ? — — — —
Always Innovating Touch Book 2009 — — — —
OpenPandora's Pandora 2010 — — — — 5.17[84]
PandaBoard[85] 2011 — — — — 5.17 5.30[11]/5.31
Raspberry Pi (1 - 4 and compatible)[13][86][87][88] ARMv6, v7-A, v8-A 2012 — — — — 5.19 5.30/5.31
IGEPv5[89] ARMv7-A 2014 — — — — 5.23 5.30/5.31
Wandboard Quad[90][91] 2015 — — — — 5.21 5.31
Titanium[92] — — — — 5.23 5.30/5.31
Pinebook[93] ARMv8-A 2017 — — — — 5.27 5.31

RISC OS can also run on a range of computer system emulators that emulate the earlier Acorn machines listed above:

RISC OS capable hardware emulators
Emulator Machines emulated Host platforms supported Latest release
!A310Emu[94] Archimedes RISC OS 0.59
Archie[95] DOS, Windows 0.9 – 10 February 2001
ArchiEmu[96] RISC OS 0.53.3 – 7 December 2014
ArcEm[97] Windows, Linux, macOS, RISC OS 1.50.1 – 18 December 2015
Arculator[98] Windows, Linux 2.2 – 24 June 2023
Virtual A5000 Windows 1.4
Red Squirrel[99] Archimedes, Risc PC, A7000 0.6 – 28 October 2002
RPCEmu[100] Risc PC, A7000, Phoebe Windows, Linux, macOS, OpenBSD 0.9.5 – 23 October 2024
VirtualRPC Risc PC Windows, macOS 5 September 2014[101]

See also

[edit]

Notes

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

RISC OS

View on Grokipedia
from Grokipedia
RISC OS is a modular, single-user operating system originally developed by Ltd in , , in 1987 specifically for its processor-based personal computers, including the series. It is renowned for its lightweight, efficient design that emphasizes speed and low resource usage, booting in seconds and requiring as little as 8 MB of RAM. The operating system evolved from the earlier Arthur OS used in the first ARM machines, with RISC OS 2 released in 1989 for the line, introducing enhancements like improved multitasking and a more refined graphical interface. Subsequent versions, such as RISC OS 3 in 1990, added support for expanded memory beyond 16 MB and better hardware integration, and it shipped as the standard OS with all ARM-based computers until the company's closure in 1998. After 's dissolution, development continued through licensees like RISC OS Ltd, preserving binary compatibility across versions and adapting it for modern hardware. Key features of RISC OS include its , which provides a drag-and-drop paradigm for file operations and application interaction, making it intuitive for desktop use despite its age. The OS employs a modular architecture with a small kernel handling core functions, extensible via dynamically loadable modules for tasks like filing systems, networking, and the (Pinboard). Programmers interface with it through Software Interrupts (SWIs) for system calls and commands executable from the shell or applications, supporting languages such as , C, Python, and assembly. It also includes built-in tools for , sprite handling, and sound, reflecting its origins in educational and creative computing. In its modern form, RISC OS is maintained by the community-driven RISC OS Open Limited (ROOL), which released the source code under the Apache 2.0 license in 2018, enabling ports to contemporary ARM hardware like the Raspberry Pi. The latest stable version, RISC OS 5.30 from April 2024, supports 26-bit and 32-bit ARM architectures, including USB, networking, and web browsing via apps like NetSurf, while retaining its characteristic responsiveness on low-power devices; development previews such as 5.31 (October 2024) add further enhancements like WiFi and improved browsing. As of 2025, ongoing "Moonshots" efforts aim to introduce 64-bit support and compatibility with newer hardware, including the Raspberry Pi 5. Today, it serves niche users in education, retro computing, and embedded projects.

History

Origins and Early Development

was founded in 1978 in Cambridge, England, by Chris Curry and , initially focusing on microprocessor-based systems and building on earlier work with kit computers like the Sinclair MK14. The company gained prominence with the in 1981, a 6502-based educational computer that established Acorn's reputation in the UK market and influenced subsequent designs. By the mid-1980s, seeking a more efficient processor for next-generation machines, Acorn shifted to developing its own (RISC) architecture, leading to the creation of the (Acorn RISC Machine) evaluation board in 1985. This board, featuring the prototype ARM1 processor designed by a team including and , allowed initial testing and software development on existing hardware via the Tube coprocessor interface. Building on the BBC Micro's operating system heritage, Acorn developed OS in 1987 as a lightweight, ROM-based system tailored for the new ARM architecture. , which drew from the modular structure and BASIC interpreter of the earlier BBC MOS, was first released in June 1987 (version 0.30) and updated to version 1.20 by September, coinciding with the launch of the computer series. Key figures , who led the ARM instruction set design, and , who focused on the hardware implementation, played pivotal roles in ensuring the OS integrated seamlessly with the 26-bit ARM processors, emphasizing efficiency for educational and home use. Arthur served as the direct predecessor to RISC OS, which evolved from it with RISC OS 2 released in April 1989, introducing refinements like improved desktop metaphors. The system featured , allowing multiple applications to run without preemptive scheduling, and sprite-based graphics for efficient rendering of icons and cursors on low-memory hardware. These elements were optimized for the 26-bit of early chips, providing a responsive interface with 512 KB to 4 MB of RAM across initial models like the A305 and A310.

Commercial Era and Releases

RISC OS entered its commercial era with the launch of version 2 in April 1989, marking the first full release under the RISC OS name following the earlier operating system. This version introduced support for color graphics, a significant upgrade from the monochrome capabilities of its predecessor, enabling richer visual applications on Acorn's series computers. In 1991, released RISC OS 3, which expanded compatibility to both the A-series (like the A5000) and the newer R-series machines, including enhanced networking features and improved file handling through the Advanced Disc Filing System (ADFS). This version solidified RISC OS as the standard OS for 's educational and professional markets, with widespread adoption in schools due to its efficiency on processors. By 1996, RISC OS 3.70 added support for the processor, boosting performance on upgraded systems and allowing clock speeds up to 233 MHz, which helped maintain competitiveness in desktop computing. Acorn faced intensifying market challenges in the late 1990s, primarily from the rising dominance of low-cost PC compatibles running Windows, which eroded Acorn's niche in and home computing. Financial pressures culminated in 1998, when Acorn restructured: the company split, with its microprocessor design assets forming , the core computer division rebranding to Element 14 (later acquired by ), and set-top box technology passing to Pace Micro Technology, which licensed RISC OS for embedded use. Following Acorn's decline, development of desktop RISC OS shifted to RISCOS Ltd, which licensed the codebase from Element 14 and released RISC OS 4 in July 1999 as an upgrade for and A7000 series machines. This version implemented 32-bit addressing for larger memory configurations and introduced initial USB support through modular extensions, enabling connectivity to peripherals like printers and storage devices. Commercial support waned by 2001, with RISC OS Select (version 4.02) marking the last major proprietary release, after which production of ROM-based copies ceased around 2005 amid shrinking hardware sales.

Transition to Open Source

Following the closure of Acorn Computers' workstation division in September 1998, development of RISC OS shifted to independent entities to sustain the operating system beyond its commercial origins. RISCOS Ltd, formed in March 1999, licensed the rights from Element 14 (Acorn's successor) to advance RISC OS for existing hardware like the Risc PC. Castle Technology later acquired relevant intellectual property and released RISC OS 5 in October 2002 for its Iyonix PC, introducing 32-bit addressing that supported memory configurations up to 1 GB—surpassing prior 26-bit limits of around 128 MB—along with enhancements to graphics handling, including improved anti-aliased font rendering for better on-screen legibility. Updates to RISC OS 5 continued through the 2000s, with issue 2 (version 6.16) issued in April 2009, incorporating further optimizations for Castle's hardware ecosystem. A pivotal in the transition occurred in 2006 when RISC OS Open Ltd (ROOL) was incorporated on 20 June to collaborate with Technology on opening the source code. This released portions of the RISC OS 5 codebase under a custom, partly-free license, granting developers access to core components for modification and redistribution while retaining some proprietary restrictions. The effort marked the first structured involvement, fostering contributions that integrated RISC OS with evolving ARM-based hardware from , such as the Iyonix and later systems. The full shift to open source culminated in 2018, when RISC OS Developments Ltd acquired the complete intellectual property rights from Castle Technology. Core components of RISC OS 5 were then relicensed under the permissive Apache 2.0 license, eliminating prior barriers and enabling unrestricted contributions from the global developer community. ROOL assumed stewardship of ongoing maintenance, supporting ports to modern platforms like the and ensuring compatibility with legacy Castle hardware, thereby revitalizing RISC OS as a collaborative, non-proprietary project. Since 2018, ROOL has released several updates, including versions 5.24 (2018), 5.28 (2020), and 5.30 (April 2024), enhancing support for contemporary hardware while pursuing 64-bit compatibility as of 2025.

Technical Architecture

Kernel and OS Core

The RISC OS kernel forms the lightweight core of the operating system, providing fundamental services for process management, memory handling, and hardware interaction on -based architectures. Written primarily in , the kernel is intentionally minimal, focusing on efficiency and speed to support resource-constrained environments typical of early embedded systems. It operates without a traditional monolithic structure, instead relying on a dynamic module system to extend functionality at runtime. Modules, which can include device drivers, filing systems, and other extensions, are loaded from ROM or disc and adhere to a standardized interface, allowing programmers to replace or augment core behaviors without recompiling the kernel. This modular approach enables the OS to adapt to diverse hardware while maintaining a small footprint, with the kernel itself occupying approximately 180 KB. A key aspect of the kernel's design is its support for both 26-bit and 32-bit addressing modes, reflecting the evolution of processors. In 26-bit mode, used in early implementations for , the and processor status register share the top bits of a 32-bit word, limiting the addressable space to 64 MB. Later versions, starting with RISC OS 3.5 on ARM6 and processors, default to 32-bit mode, providing a full 4 GB by separating the (CPSR/SPSR) and enabling all processor modes, including user, , and modes. The kernel remains configurable to operate in 26-bit modes when needed, ensuring compatibility with legacy software, though 32-bit operation is required for modern hardware expansions. This flexibility allows RISC OS to balance historical constraints with contemporary demands. RISC OS implements through a single-threaded execution model, where applications run in a and voluntarily yield control to the scheduler. Task switching occurs via Software Interrupt (SWI) calls, which serve as the primary interface for invoking kernel services. SWIs trap to supervisor mode, allowing the kernel to handle requests for allocation (e.g., via OS_Heap SWI), scheduling, and I/O operations without preemption, relying instead on applications to poll for events or explicitly relinquish the CPU. This design promotes simplicity and low overhead but requires well-behaved software to avoid blocking the system. The kernel dispatches SWIs through a vector table, first checking core handlers before deferring to loaded modules, ensuring efficient resolution of system calls like dynamic area creation for relocatable code segments. Central to the kernel are components like the module system for managing drivers and extensions, which integrates seamlessly with hardware interfaces. Modules register SWIs and vectors upon loading, enabling the kernel to route device-specific operations—such as handling—to appropriate handlers. In RISC OS 5 and subsequent releases, a Hardware Abstraction Layer (HAL) was introduced to decouple the kernel from specific chipsets, abstracting low-level hardware access like timers, , and memory controllers. The HAL facilitates portability across varying ARM cores by providing standardized APIs for device initialization and control, while enhancing error handling through unified exception reporting and recovery mechanisms, reducing dependency on fixed hardware configurations like the original IOMD or MEMC chips. This layer supports dynamic device enumeration and error propagation via SWI return codes, improving robustness in diverse embedded setups. The kernel's efficiency for embedded applications stems from its absence of , opting instead for a physical model with dynamic relocation. is organized into relocatable dynamic areas managed by the OS_ChangeDynamicArea SWI, allowing blocks to be allocated, resized, or moved without fixed addressing, which optimizes usage in systems with limited RAM. For instance, the Relocatable Module Area (RMA) holds modules that can be shuffled by the kernel to defragment , updating pointers as needed via OS_Heap operations. This approach avoids the overhead of paging or swapping, enabling fast boot times and deterministic performance suitable for real-time tasks, though it demands careful application design to prevent fragmentation.

File System and Formats

The FileCore module serves as the foundational filing system in RISC OS, providing a device-independent layer that handles core file operations while relying on secondary modules like ADFS for hardware-specific access to storage media. It implements a hierarchical structure where directories are treated as special files containing lists of entries, allowing for nested organization and efficient traversal through internal disc addresses that combine fragment identifiers with sector offsets for rapid access without full path resolution. This design enables seamless support for deep directory hierarchies on various media, including floppy disks, hard disks, and in later implementations, flash storage, all without in matching to simplify user interaction. Filenames in RISC OS under FileCore are limited to 10 characters, stored in uppercase by default but preserving entered case for display, with comparisons performed in a case-insensitive manner during file access and loading. A key innovation is the file type extension, a three- or four-character code (e.g., TXT for text files) appended after a comma to the filename, functioning similarly to MIME types for identifying and handling file contents without relying on the filename itself. This type system integrates directly with the filing system, allowing applications to determine behaviors based on the embedded metadata, and supports hierarchical directories across media formatted with FileCore-compatible structures like L, D, E, F for floppies and larger partitions for hard disks up to several gigabytes in modern variants. RISC OS file formats are tightly coupled with the FileCore system to facilitate resource embedding and portability. For instance, the Sprite format (filetype FF9) stores images and icons as a sequence of headers followed by data and optional palettes, enabling direct loading into areas for use in applications or the desktop without additional conversion. Similarly, the format (filetype AFD) represents through an object-oriented structure beginning with a "Draw" header, followed by scalable paths, text, and embedded sprites, allowing files to be saved and retrieved as integral parts of the for editing and rendering. These formats exemplify how FileCore's byte-stream file model supports embedded resources, promoting efficient storage and access on resource-constrained hardware.

Resource Management

RISC OS employs a dynamic allocation centered on relocatable modules and dynamic areas to manage heap space efficiently for applications and the operating . Relocatable modules, which extend the OS functionality, are loaded into the Relocatable Module Area (RMA), a dedicated region that expands as needed to accommodate additional modules without fixed boundaries. This allows modules to be relocated during loading to optimize usage, supporting multitasking by preventing fragmentation in the module space. Dynamic areas, introduced in later versions, provide flexible heap by enabling applications to create, resize, and delete variable-sized blocks on demand, distinct from the fixed RMA, which facilitates efficient allocation for temporary data structures like buffers and caches. The sprite manager in RISC OS handles scalable icons, cursors, and graphical elements through a dedicated sprite area, supporting color depths that evolved from palette-based modes to higher resolutions in subsequent releases. Initially limited to up to 256 colors in modes like 8-bit per pixel, the system extended sprite formats in RISC OS 3 to accommodate deeper color spaces, including 16-bit (32,000 or 65,536 colors) and 24-bit (16 million colors) representations. Later versions, such as RISC OS 6, further enhanced support for 32 bits per pixel (bpp) sprites, incorporating alpha channels for transparency and enabling photorealistic images while maintaining compatibility with legacy hardware through dithering and pixel translation. This manager plots sprites via OS calls, integrating with the Window Manager for UI elements like icons and pointers, ensuring scalability across varying display modes. To promote UI consistency across applications, RISC OS utilizes a template system that defines reusable components stored in files, particularly for dialogs and menus. Templates are binary files containing layouts, gadget positions, and event handlers, loaded dynamically by the to instantiate standardized interfaces without hardcoding dimensions in application code. files, often distributed with applications, bundle these templates alongside sprites and messages, allowing easy localization and customization; for instance, developers use tools like WinEd to edit templates, ensuring menus and dialog boxes adhere to the system's (Windows, Icons, Menus, Pointer) guidelines for uniform appearance and behavior. Resource management in RISC OS incorporates garbage collection mechanisms through sparse dynamic areas, which permit non-contiguous allocation to reclaim unused memory without relocating active blocks, aiding languages or runtimes that implement collectors. This integrates with the system's addressing evolution from 26-bit spaces in early versions—limiting access to 64 MB—to full 32-bit support in RISC OS 3.5 and later, where dynamic areas span extended memory maps while maintaining backward compatibility via mode switches and veneer code for legacy modules. Such features ensure efficient resource utilization in mixed environments, preventing exhaustion in the RMA or heap during prolonged sessions.

User Interface

Desktop Environment

The desktop environment of RISC OS is built around a minimalist, icon-driven interface known as the WIMP (Windows, Icons, Menus, Pointer) system, which emphasizes efficient interaction through a pinboard metaphor and intuitive mouse actions. The pinboard serves as an infinite virtual desktop backdrop, allowing users to place and arrange icons representing files, directories, or applications as persistent shortcuts, without modifying the original items. These icons "stick" to the pinboard like pins on a corkboard, enabling quick access to frequently used resources even if they are nested deep in the file system; the arrangement persists across reboots via a saved configuration file. Drag-and-drop operations form the core of file handling on the pinboard: users can drag icons from directory windows (filers) onto the backdrop to create new shortcuts, or drag between icons to perform actions like copying or moving files, with visual feedback during the operation. Windows in RISC OS support overlapping arrangements, managed by the Window Manager module, which handles their creation, positioning, and layering to facilitate multitasking. Each window features a title bar at the top for identification and interaction—clicking the title bar with the left mouse button (Select) brings the window to the foreground, while the right mouse button (Adjust) allows dragging or resizing without activating the window. Resizing occurs via rubber-banding: dragging from the bottom-right size box outlines a new boundary in real-time, updating the window dimensions upon release, which supports flexible layouts without complex menus. Task switching is handled through the Task Manager, accessible via the Acorn or cube logo icon on the icon bar at the screen's bottom; selecting it opens a display listing active tasks with memory usage, allowing users to cycle focus or terminate processes efficiently. Icons throughout the desktop, rendered as sprites (simple bitmap graphics), respond to three primary mouse actions for streamlined interaction: a double-click with the Select button typically opens the represented item (e.g., launching an application or directory), a single Select click enables dragging for repositioning or file operations, and an Adjust click toggles states or invokes alternative behaviors, such as closing a directory after navigation. The middle mouse button (Menu) triggers context-sensitive pop-up menus directly over icons, providing options like properties or deletion without navigating hierarchical structures. This three-state model reduces reliance on keyboard input, promoting pointer-based efficiency. Data exchange across applications integrates via a system-wide , supporting operations through a selection model where only one active selection or exists per at a time. When data is copied, it is claimed by the originating application via system messages, but for persistence when applications are not running, it is stored in a scrap file located in the wimp$scrap directory, enabling seamless transfer even after reboots or task switches. Paste actions insert contents at the current or replace selections, with the Clipboard module handling the protocol to ensure compatibility between diverse applications.

Graphics and Font Handling

RISC OS employs a Visual Display Unit (VDU) driver system to manage screen output, utilizing special control codes sent via OS_WriteC to handle both text and graphics rendering on the VIDC chip. Screen modes are defined with specific resolutions and color depths, such as Mode 28 providing 640x480 resolution with 256 colors, requiring approximately 300KB of for the display. These modes support bit-mapped displays in 2, 4, 16, or 256 color depths, selectable via VDU 22, with the system maintaining separate text and graphics windows that can be resized and positioned independently. Graphics operations in RISC OS include sprite handling for bitmap images and plot commands for vector drawing, enabling efficient rendering of both pixel-based and line-based content. Sprites, stored as memory blocks mimicking screen memory, support attributes like transparency masks and palettes, and can be created by redirecting VDU plots or grabbing screen areas. Plot operations, invoked via VDU 25 with codes 232-239, allow drawing lines, shapes, and sprites at the current cursor position, with extensions like OS_SpriteOp supporting scaling, anti-aliasing, and transformations for advanced bitmap manipulation. On ARM-based hardware, these operations benefit from hardware acceleration through the VIDC video controller, optimizing performance for vector and bitmap tasks. Color management relies on a palette that maps 256 logical colors to physical RGB values from a 4096-color , configurable via VDU 19, with support for flashing effects to enable palette animation by alternating colors at intervals set by OS_Byte calls. In early versions with limited palettes, such as 16 colors, color mapping uses dithering patterns to simulate additional shades by alternating available colors, as implemented in routines like for creating intermediate tints. Font handling in RISC OS is managed by the Font Manager, which supports scalable outline fonts including , stored in files with extensions like .fon or outlines, and automatically scales them to requested sizes using caching for efficiency. enhances on-screen text rendering by shading edge pixels with up to 16 intermediate colors based on the screen mode, reducing jaggedness and improving readability, particularly for small sizes. This technique, configurable via thresholds and palette settings, applies to outline fonts and can be limited by size parameters in the Fonts Configuration to balance quality and performance.

Included Applications

RISC OS includes a suite of standard applications designed for essential productivity and system management tasks, bundled directly with the operating system since its early releases. These tools emphasize simplicity and integration with the OS's lightweight architecture, providing users with immediate access to core functionalities without requiring additional installations. serves as the primary editing application, enabling users to create and modify sprite-based images through pixel-level manipulation. It features tools such as brushes, spray cans, filled shapes, lines, rectangles, and for coloring areas, along with zoom capabilities up to 1:1 ratios and grid overlays for precise alignment. Palette editing supports up to 256 colors, and files are saved in a native Paint format, with options to export sprites to other applications like . Printing is handled by dragging files to the printer icon. Draw provides vector illustration capabilities, allowing the creation of scalable suitable for diagrams, , and technical drawings. Users can construct objects including paths, rectangles, ellipses, and text, with editing tools for grouping, moving, scaling, rotating, and path manipulation using Bezier curves. It supports snapping to grids, zooming up to 8:1, custom line widths, fill patterns, and color styling, while integrating fonts for text handling. Files are stored in the DrawFile format, compatible with DXF for exchange, and printing occurs via menu or dedicated key. Edit functions as a versatile text processor for editing files, including programming code and documents, with features like block selection, search and replace operations, and support for multiple windows. It displays text in configurable fonts, such as the system default, and handles files effectively, while allowing preparation of text for import into . Printing uses the printer's standard font settings. Imp acts as a simple image manipulation and printing utility, facilitating basic conversions and management for output tasks. It supports sprite and other formats, enabling resizing and preparation for printing across supported devices. System utilities round out the suite, with the Filer providing file and directory management, including copying, deleting, renaming, and sorting by name, type, date, or size across filing systems. The monitors running applications, controls memory allocation (such as RAM disc and font cache sizes), and handles task termination or shutdown. Clock manages and date settings, often displayed in an analogue format with alarm integration, while the offers basic arithmetic and scientific functions, including memory storage and support. These applications have evolved across RISC OS versions, remaining core components since the system's inception on machines in the late . Early iterations in RISC OS 3 emphasized foundational tools like and for graphics, with enhancements in later releases such as RISC OS 4 introducing for word processing and improved image handling in . By RISC OS 5, utilities like the gained scientific modes, and integrations for rendering were added to support emerging web capabilities in bundled or closely associated tools.

Key Features

Compatibility Mechanisms

RISC OS has maintained with legacy software through a modular architecture that emphasizes stability, introduced in RISC OS 2 in 1989. Modules in RISC OS are dynamically loadable components that provide system services, and their interfaces have remained largely unchanged across versions, allowing applications written for earlier releases to execute without modification on modern systems. For instance, many kernel-derived modules, such as those handling conversions (e.g., OS_Convert*) and SWIs (e.g., OSSWIs), retain APIs identical to their originals from RISC OS 2, as documented in the Programmer's Reference Manuals (PRMs). Legacy support modules like LegacyBBC and LegacyScreen further preserve obsolete interfaces, such as calls and the single 'Screen' dynamic area, ensuring seamless operation of applications from the era. To address architectural shifts, particularly the transition from 26-bit to 32-bit addressing in RISC OS 4 (1994) and RISC OS 5 (1999), RISC OS implements file header flags to denote binary compatibility. Executable files include a 26/32-bit flag in their headers, enabling the OS to validate and load appropriate code; for example, 26-bit binaries are rejected by default on 32-bit systems to prevent crashes, but configuration options like "Accept files with an unsuitable 26/32 code flag" allow overrides for legacy execution at the user's risk. The Application Image Format (AIF) standard, mandatory since 1996, includes these flags and ensures that non-compliant or headerless files can still run via compatibility toggles such as "Accept known obsolete formats" or "Accept non-AIF compliant files," maintaining stability without requiring recompilation of old binaries. Additionally, the AIF module supports emulated execution of non-32-bit-safe programs, bridging the gap for software developed under 26-bit constraints. Emulation plays a key role in extending compatibility to non-native hardware environments. The ARMulator, ARM's , enables hosting of ARM-based RISC OS code on x86 platforms by emulating ARM instructions, though it is noted for being slower compared to full-system and primarily suited for development rather than production use. For comprehensive PC , RPCEmu provides a cycle-accurate of Acorn hardware, allowing unmodified RISC OS ROMs and applications from the to run on modern x86, , or other hosts like Windows, , and macOS, with support for both 26-bit and 32-bit variants. Within native 32-bit RISC OS environments, such as on the Iyonix PC with XScale processors, Aemulor serves as a dedicated that emulates a 26-bit ARM610 or CPU alongside RISC OS 4 APIs, enabling legacy 26-bit applications like Impression to operate transparently by handling addressing differences and SWI variations. File format persistence further bolsters long-term compatibility, with core formats like sprites—RISC OS's native image standard—remaining viable from the system's in the late . Sprite files adhere to a fixed header structure (44 bytes) followed by palette and pixel data, and modern implementations support backward-compatible modes (e.g., mode 0 for 2 colors or mode 15 for 256 colors) to ensure readability on older releases without alteration. This design allows resources such as icons and graphics created for (RISC OS 1, 1987) to load and render correctly in contemporary builds, including enhanced formats introduced in RISC OS 3.5 (1994) for higher color depths, via the OS_SpriteOp calls that preserve the original area format.

Networking and I/O Support

RISC OS originally featured Econet, a local area networking protocol developed by for interconnecting multiple machines in a or environment, supporting and printer access over . To bridge legacy Econet applications with modern standards, Acorn introduced AUN (Acorn Universal Networking) in RISC OS 3.5, which encapsulates Econet protocols over TCP/IP, allowing seamless compatibility without rewriting existing software. Full TCP/IP stack support arrived with RISC OS 3.5 through the INET suite, enabling internet connectivity via the module, which handles IP, ARP, and related protocols for data transmission. DNS resolution is managed by the Resolver module, introduced in the same version, which queries DNS servers to translate hostnames to IP addresses and supports configuration as a basic DNS server for local networks. For input/output, RISC OS provides native drivers for serial and parallel ports, primarily used for connecting printers and modems, with configuration options like *Configure Print directing output to port 1 (parallel) or port 2 (serial). SCSI interfaces, supported since early versions via expansion cards, enable high-speed connections to hard drives, scanners, and tape backups, with the OS recognizing up to seven devices in a chain and providing filing system access through SCSIFS. USB integration began with RISC OS 5, implemented through the Castle-developed USB stack including the USBDriver module, which supports devices for file access and HID () classes for keyboards and mice. The INET module facilitates broader internet access by integrating TCP/IP with these I/O paths, such as PPP over serial or Ethernet adapters. In modern implementations of RISC OS 5, such as ports to platforms like the , Ethernet drivers (e.g., EtherB for podules or built-in for devices) enhance network performance, while built-in firewall capabilities allow rule-based traffic filtering to secure connections. As of RISC OS 5.30 (April 2024), the networking stack includes native support for compatible hardware (e.g., models 3B, 4B, Zero 2W), compatibility, and an integrated firewall derived from code.

Hardware Support

Legacy Acorn Systems

The Archimedes series, launched by Acorn Computers in 1987, comprised the initial hardware platforms natively supporting RISC OS, with production spanning until 1992. Key models included the A305 and A400 series, introduced as entry-level systems with an 8 MHz ARM2 processor, 1 MB of RAM (expandable to 4 MB), and integrated support for RISC OS from version 2 onward. Higher-end variants like the A3000 (1989), A4000 (1990), and A5000 (1992) incorporated upgradable ARM3 processors reaching speeds of up to 25 MHz, along with enhanced memory configurations up to 16 MB in later revisions, while maintaining the core chipset of MEMC for memory management, VIDC for video and audio, and IOC for input/output control. These machines prioritized educational applications, building on the legacy of the BBC Micro, with the BBC-branded A3000 specifically tailored for school environments through bundled software like BBC BASIC and compatibility modes for 8-bit peripherals. Professional workstation variants within the A-series, such as the A5000, extended RISC OS capabilities for demanding tasks like and graphics design, featuring faster memory access at 12 MHz and optional interfaces for storage expansion. However, early models faced hardware limitations, including a 4 MB RAM ceiling imposed by the MEMC chip's addressing constraints, which restricted multitasking and large application handling until software workarounds and upgrades emerged. Expansion was facilitated through the podule interface, a modular slot system on models like the A4000 and A5000 that supported up to four cards, enabling Micro-compatible peripherals such as Econet networking modules and additional storage controllers to bridge generational hardware gaps. The Risc PC series, introduced in 1994 and manufactured until around 2000, marked Acorn's evolution toward more powerful desktop systems under RISC OS 3.5 and later versions. Equipped with the ARM610 processor at 30 MHz initially, it supported upgrades to the ARM710 at 40 MHz, the ARM7500FE, and ultimately the SA110 at speeds up to 300 MHz, delivering performance comparable to contemporary Pentium-class systems. A key innovation was the inclusion of PCI expansion slots—up to four in some configurations—allowing integration of modern peripherals like accelerated graphics cards and controllers, alongside dynamic RAM support up to 256 MB officially, with some upgrades enabling more. These platforms catered to both and enthusiast users, with like the 600 and 750 emphasizing expandability for and networking applications.

Modern Ports and Emulation

RISC OS has been ported to several modern single-board computers (SBCs), enabling its use on contemporary low-cost hardware. The primary port targets the series, beginning with the original Model B in 2012, and extending to Models 1 through 4 with stable support in RISC OS release 5.30 for 32-bit architectures. As of July 2025, a beta ROM enables access to up to 8 GB of RAM on supported models, overcoming previous 32-bit addressing constraints. This port leverages the VideoCore GPU for graphics and supports features like USB peripherals and networking, though it operates in single-core mode on multi-core devices like the Pi 4. Community efforts have also adapted RISC OS to other SBCs, such as the series based on processors, with ports dating back to 2010 that include basic I/O and storage support via MMC/SD interfaces. These adaptations, maintained by volunteers, focus on embedded applications and demonstrate RISC OS's flexibility for -based systems without relying on original hardware. Emulation provides another avenue for running RISC OS on x86/AMD64 hosts, preserving access to legacy software and hardware configurations. RPCEmu, a custom emulator simulating RiscPC-era systems, supports RISC OS 5 and runs on Windows, , and macOS, offering near-full compatibility with peripherals like and IDE emulation. VirtualRPC, an older emulator primarily for macOS, emulates ARM-based machines and allows upgrades to RISC OS 5, though it is less actively developed compared to RPCEmu. QEMU-based emulation for RISC OS remains experimental, with discussions ongoing for improved core simulation, but it has not yet achieved the stability of dedicated tools like RPCEmu as of 2025. These emulators enable developers to test applications without physical hardware, supporting legacy binary compatibility through techniques. As of 2025, transitioning RISC OS to native 64-bit support poses significant challenges, particularly for newer hardware like the 5, which requires mode. RISC OS Open (ROOL) has initiated a "Moonshot" project to rewrite core components from 32-bit assembly to enable 64-bit portability, but progress depends on securing funding and developer contributions, with no stable release available yet. Experimental 64-bit emulation on Pi 5 hardware allows limited testing via tools like , but lacks full and peripheral integration. This effort addresses the impending obsolescence of 32-bit platforms, ensuring long-term viability for modern SBCs.

Development and Community

Programming Tools

RISC OS has provided a robust set of programming tools since its initial release in , emphasizing integration with the architecture for efficient development. The operating system includes as a core component, featuring an embedded assembler that allows developers to intermix assembly code directly within programs for low-level optimization. This interpreter-assembler combination was designed by to facilitate and education, supporting inline assembly instructions that assemble and execute at runtime. For higher-level development, RISC OS supports C and C++ compilation through the Norcroft toolchain, originally developed by Norcroft for and later maintained for RISC OS environments. The Norcroft suite includes compilers, linkers, and utilities optimized for processors, enabling the creation of relocatable modules and standalone applications that integrate seamlessly with the OS kernel. These tools have been a staple for professional on RISC OS, with versions supporting both 32-bit and 64-bit targets in modern ports. Development environments on RISC OS rely on specialized editors and utilities rather than full-featured IDEs in the modern sense. Zap serves as a configurable programmer's editor with for languages like BASIC, , and assembly, making it ideal for management and . For and structured writing, Ovation Pro provides advanced word processing capabilities, including support for technical formatting, which aids in creating manuals and references during module development. Module creation involves relocatable code loaded into the Relocatable Module Area (RMA), with tools like the Norcroft linker handling address relocation to ensure compatibility across memory configurations. Access to system functionality is provided through Software Interrupts (SWIs), which act as the primary for RISC OS services. Graphics operations, such as plotting and sprite handling, are managed via the OS_GraphicsSWI calls, allowing precise control over the . Filing system interactions use OS_File SWIs for directory traversal, file creation, and manipulation, while event handling employs the EventV mechanism to user inputs like events and key presses in a message-driven . These SWIs enable modular, event-oriented programming without direct hardware access. Modern development benefits from cross-compilation support in open-source toolchains, such as the GCCSDK, which allows building RISC OS binaries on x86 or other host platforms targeting . This facilitates and extension without native hardware, integrating with RISC OS headers for SWI compatibility. In the open-source era, community-contributed libraries enhance capabilities; for instance, the open-source TCP/IP stack provides networking APIs for protocols, while the USB stack offers modules for device enumeration and data transfer.

Current Status and Future Plans

As of 2025, RISC OS Open continues to maintain and update the operating system, with version 5.31 released in late 2024 featuring numerous bug fixes, enhanced stability, and optimizations tailored for hardware. This version incorporates several years of development work, including improvements to the and support for features like and web browsing on Pi platforms. Experimental updates in mid-2025 have further addressed memory constraints on devices by relaxing certain 32-bit limitations, allowing greater RAM utilization without a full architectural overhaul. In March 2025, RISC OS Open launched the "Moonshots" initiative, a multi-year campaign to support ambitious development projects, starting with a major effort to the OS to 64-bit architectures such as Armv8 and later. The first Moonshot targets refactoring the core for 64-bit compatibility, essential for sustaining RISC OS on emerging hardware amid the phase-out of 32-bit Arm support, with a goal of approximately £2.5 million to enable full-time engineering work. This initiative marks a strategic pivot toward long-term viability, building on open-source progress since 2018. Community-driven projects like RISC OS Merlin are advancing the ecosystem by developing a modern, memory-safe kernel primarily in , aimed at enhancing module and cross-platform portability while maintaining compatibility with legacy RISC OS applications. As a work-in-progress initiative launched in early 2025, explores reimagining core OS components for safer, more efficient execution on hardware, including embedded emulation for existing software. The RISC OS community remains vibrant, supported by active forums on RISC OS Open for discussions on development and porting. Events such as the inaugural RISC OS North Show in March 2025 in , , and the RISC OS London Show in October 2025 drew attendees for demonstrations, talks on recent updates like version 5.31, and networking among developers and users. User groups continue to hold regular meetings, such as the ROUGOL presentation on November 17, 2025. Despite the 32-bit architecture's constraints, ongoing porting efforts target new single-board computers (SBCs), with forum threads exploring adaptations to recent Arm-based models like those from OKdo and others. These activities underscore a dedicated user base focused on sustaining and evolving the OS.

References

  1. http://www.riscos.com/support/developers/prm/intro.html
  2. https://distrowatch.com/risc
  3. https://www.riscository.com/2024/risc-os-direct-5-31/
  4. https://www.theregister.com/2025/04/01/risc_os_open_moonshots/
  5. https://www.iconbar.com/articles/RISC_OS_London_Show_2025_-_Notes_from_the_talks/index2250.html
  6. https://newsroom.arm.com/blog/arm-official-history
  7. https://www.computinghistory.org.uk/det/897/acorn-computers/
  8. https://www.abortretry.fail/p/mips-for-the-masses
  9. https://thechipletter.substack.com/p/the-arm-story-part-1-from-acorns-6e2
  10. https://www.computinghistory.org.uk/det/55209/ARM-Evaluation-System/
  11. https://www.4corn.co.uk/archimedes.php
  12. https://www.computinghistory.org.uk/det/51418/Acorn-Archimedes-310-%28Arthur-1-2-Installed%29/
  13. https://arstechnica.com/features/2020/12/how-an-obscure-british-pc-maker-invented-arm-and-changed-the-world/
  14. https://chrisacorns.computinghistory.org.uk/RISCOS.html
  15. https://www.theregister.com/2022/06/23/how_risc_os_happened/
  16. https://www.mcmordie.co.uk/acornhistory/
  17. http://www.riscos.com/riscos/370/index.php
  18. https://chrisacorns.computinghistory.org.uk/AfterAcorn/Pace.html
  19. http://www.riscos.com/riscos/402/index.php
  20. https://www.mcmordie.co.uk/acornhistory/after.shtml
  21. http://www.riscos.com/ftp_space/400/index.htm
  22. https://www.theregister.com/2004/06/17/riscos_dispute/
  23. https://apdl.davidhill.co/riscworld/volumes/volume3/issue4/iyonix/index.htm
  24. https://chrisacorns.computinghistory.org.uk/AfterAcorn/RISCOSLtd.html
  25. https://find-and-update.company-information.service.gov.uk/company/05852060
  26. https://www.osnews.com/story/16018/announcement-risc-os-shared-source-initiative/
  27. https://www.riscosopen.org/news/articles/2018/10/22/risc-os-is-open-for-business
  28. https://www.elektormagazine.com/news/risc-os-the-original-arm-operating-system-goes-open-source
  29. https://www.riscosopen.org/news/articles/2024/04/27/risc-os-5-30-stable-is-now-available
  30. https://www.riscosopen.org/content/about
  31. http://www.riscos.com/support/developers/prm/armhw.html
  32. http://www.riscos.com/support/developers/prm/swis.html
  33. http://www.riscos.com/support/developers/prm/memoryman.html
  34. https://www.riscosopen.org/forum/forums/5/topics/15914
  35. https://www.riscosopen.org/wiki/documentation/show/HAL%20Hardware
  36. http://www.riscos.com/support/developers/prm/filecore.html
  37. http://www.riscos.com/support/users/userguide6/config/filer.htm
  38. http://www.riscos.com/support/developers/riscos6/filesystems/filecore.html
  39. http://www.riscos.com/support/developers/prm/fileformats.html
  40. http://www.riscos.com/support/developers/prm/wimp.html
  41. http://www.riscos.com/support/users/userguide6/guide/chap11.htm
  42. https://telcontar.net/Misc/GUI/RISCOS/
  43. https://www.steve-potts.me.uk/rot/taskman.html
  44. http://chrisacorns.computinghistory.org.uk/docs/Acorn/AN/240.pdf
  45. http://www.riscos.com/support/developers/riscos6/desktop/clipboardholder.html
  46. http://www.riscos.com/support/developers/prm/vdu.html
  47. http://www.riscos.com/support/developers/prm/sprites.html
  48. http://www.riscos.com/support/users/grapharm/chap19.htm
  49. http://www.riscos.com/support/developers/prm/fontmanager.html
  50. https://www.wrocc.org.uk/risc-os/what-is-it
  51. https://www.4corn.co.uk/archive/docs/RISC%20OS%203%20User%20Guide%20Application%20Guide-opt.pdf
  52. http://foundation.riscos.com/support/developers/riscos6/newosmodules.html
  53. http://www.riscos.com/support/users/userguide6/config/compat.htm
  54. https://www.iconbar.co.uk/articles/RISC_OS_on_x86_-_A_bad_idea/index642.html
  55. https://www.marutan.net/rpcemu/index.php
  56. https://sendiri.co.uk/aemulor/articles/aemulor/index.html
  57. http://www.riscos.com/support/developers/prm/aun.html
  58. https://shell.riscos.com/support/developers/riscos6/networking/internetoverview.html
  59. http://www.riscos.com/support/developers/riscos6/networking/resolver.html
  60. https://pyromaniac.riscos.online/pyromaniac/FEATURES.html
  61. http://www.riscos.com/support/users/starcomms/index6.htm
  62. https://chrisacorns.computinghistory.org.uk/docs/Acorn/Manuals/Acorn_SCSIExpCardUG.pdf
  63. https://www.riscosopen.org/wiki/documentation/show/RISC%2520OS%25205%2520USB%2520stack%2520overview
  64. https://www.riscosopen.org/wiki/documentation/show/Configuring%2520Networking
  65. https://www.theregister.com/2024/05/02/rool_530_is_here/
  66. https://www.riscosopen.org/news/articles/2024/04/27/risc-os-5-30-now-available
  67. https://lowendmac.com/2018/acorn-archimedes-computers/
  68. http://bitsavers.org/pdf/acorn/brochures/AcornVisionForTheFuture.pdf
  69. https://binarydinosaurs.co.uk/Museum/Acorn/potted.php
  70. https://www.retro-kit.co.uk/page.cfm/content/Simtec-4-8MB-ROM-RAM-board/index.html
  71. https://www.chiark.greenend.org.uk/~theom/riscos/docs/expspec.pdf
  72. https://www.4corn.co.uk/rpca7000.php
  73. http://www.riscos.com/support/developers/prm/medintro.html
  74. https://www.riscosopen.org/news/articles/2025/07/18/pi-memory-freed-from-its-32-bit-shackles
  75. https://www.beagleboard.org/projects/riscos
  76. https://www.riscosopen.org/wiki/documentation/pages/How%2Bto%2Bget%2Bstarted%2Bwith%2Ba%2BBeagleBoard
  77. https://www.iconbar.com/articles/Moving_to_RPCEmu_for_RISC_OS_on_my_Mac/index1523.html
  78. https://www.riscosopen.org/forum/forums/9/topics/18863
  79. https://www.osnews.com/story/142025/the-32bit-risc-os-needs-to-be-ported-to-64bit-to-survive-seeks-help/
  80. https://www.riscosopen.org/content/documents/risc-os-moonshots
  81. http://www.riscos.com/support/developers/bbcbasic/appendices/armassembler.html
  82. https://www.riscosopen.org/content/documents/dde-faq
  83. https://www.riscosopen.org/forum/forums/1/topics/19009
  84. http://zap.tartarus.org/
  85. https://www.davidpilling.com/wiki/index.php/OvationProR
  86. http://www.riscos.com/support/developers/prm/modules.html
  87. http://www.riscos.com/support/developers/prm_index/prmindex.html
  88. http://www.riscos.com/support/developers/prm/softvecs.html
  89. https://www.riscosdev.com/projects/network/
  90. https://www.riscosopen.org/news/articles/2025/03/28/moonshots-initiative-to-secure-the-future-of-the-os
  91. https://www.riscository.com/2025/rool-moonshots-initiative/
  92. https://riscoscommunity.org/projects/risc-os-merlin/
  93. https://www.riscosopen.org/forum/forums/1/topics/19883
  94. https://www.iconbar.com/articles/RISC_OS_North_Show_2025_-_Notes_from_the_talks/index2186.html
  95. https://www.riscository.com/2025/risc-os-london-show-2025/
  96. https://www.riscosopen.org/forum/forums/1/topics/20113
  97. https://www.riscosopen.org/forum/forums/12/topics/9548
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.