Fact-checked by Grok 2 weeks ago

RISC OS

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 . 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 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, , and assembly. It also includes built-in tools for , 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 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 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 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 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 . These elements were optimized for the 26-bit of early chips, providing a responsive interface with 512 KB to 4 MB of 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 Micro Technology, which licensed RISC OS for 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 through modular extensions, enabling connectivity to peripherals like printers and devices. Commercial 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 forms the lightweight of the operating system, providing fundamental services for process management, memory handling, and interaction on -based architectures. Written primarily in , the is intentionally minimal, focusing on efficiency and speed to support resource-constrained environments typical of early systems. It operates without a traditional monolithic structure, instead relying on a dynamic system to extend functionality at . , which can include drivers, filing systems, and other extensions, are loaded from or and adhere to a standardized , allowing programmers to replace or augment core behaviors without recompiling the . This modular approach enables the OS to adapt to diverse while maintaining a small footprint, with the 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 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 and processors, default to 32-bit mode, providing a full 4 GB by separating the (CPSR/SPSR) and enabling all modes, including , , and modes. The kernel remains configurable to operate in 26-bit modes when needed, ensuring with software, though 32-bit operation is required for modern 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 services. SWIs trap to supervisor mode, allowing the 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 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 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 (HAL) was introduced to decouple the from specific chipsets, abstracting low-level 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 mechanisms, reducing dependency on fixed configurations like the original IOMD or MEMC . This layer supports dynamic device enumeration and error propagation via SWI return codes, improving robustness in diverse setups. The 's efficiency for 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 . For instance, the Relocatable Module Area (RMA) holds modules that can be shuffled by the to defragment , updating pointers as needed via OS_Heap operations. This approach avoids the overhead of paging or , enabling fast boot times and deterministic performance suitable for 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 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 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 , allowing files to be saved and retrieved as integral parts of the for editing and rendering. These formats exemplify how FileCore's byte-stream model supports embedded resources, promoting efficient and on resource-constrained .

Resource Management

RISC OS employs a dynamic allocation centered on relocatable and dynamic areas to manage space efficiently for applications and the operating . Relocatable , 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 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 system that defines reusable components stored in files, particularly for dialogs and menus. are files containing layouts, gadget positions, and handlers, loaded dynamically by the to instantiate standardized interfaces without hardcoding dimensions in application code. files, often distributed with applications, bundle these alongside sprites and messages, allowing easy localization and customization; for instance, developers use tools like WinEd to edit , 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 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 s and color depths, such as Mode 28 providing 640x480 with 256 colors, requiring approximately 300KB of for the . These modes support bit-mapped s 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 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 fonts and can be limited by size parameters in the Fonts 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 and other formats, enabling resizing and preparation for printing across supported devices. System utilities round out the suite, with the Filer providing file and management, including copying, deleting, renaming, and by name, type, date, or size across filing systems. The monitors running applications, controls memory allocation (such as disc and font 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 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 . 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 options like "Accept files with an unsuitable 26/32 code flag" allow overrides for 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 toggles such as "Accept known obsolete formats" or "Accept non-AIF compliant files," maintaining without requiring recompilation of old binaries. Additionally, the AIF 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 rather than 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 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 —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/, 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 , , 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 addresses and supports configuration as a basic DNS server for local networks. For input/output, RISC OS provides native drivers for and ports, primarily used for connecting printers and modems, with configuration options like *Configure Print directing output to port 1 () or port 2 (). 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 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 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 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 expansion. However, early models faced limitations, including a 4 MB 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 controllers to bridge generational 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 at 30 MHz initially, it supported upgrades to the 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 expansion slots—up to four in some configurations—allowing integration of modern peripherals like accelerated graphics cards and controllers, alongside dynamic 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 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 / 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 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 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 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 , supporting legacy binary compatibility through techniques. As of 2025, transitioning RISC OS to native 64-bit support poses significant challenges, particularly for newer 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 on Pi 5 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 code directly within programs for low-level optimization. This interpreter-assembler combination was designed by to facilitate and education, supporting inline 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 . 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 in the modern sense. Zap serves as a configurable programmer's editor with for languages like , , 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 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, creation, and manipulation, while event handling employs the EventV mechanism to user inputs like events and presses in a message-driven . These SWIs enable modular, event-oriented programming without direct 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 , integrating with RISC OS headers for SWI . 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 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 are advancing the ecosystem by developing a modern, memory-safe primarily in , aimed at enhancing 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 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. [1]
    Chapter 1: An introduction to RISC OS - RISCOS Ltd
    RISC OS is an operating system written by Acorn for its computers. Like any operating system, it is designed to provide the facilities that you, the programmer ...
  2. [2]
    RISC OS - DistroWatch.com
    May 17, 2025 · RISC OS is a computer operating system originally designed by Acorn Computers Ltd in Cambridge, England in 1987.
  3. [3]
    The Official History of Arm
    Aug 16, 2023 · The pre-history of Arm goes back 45 years. In 1978, Acorn Computers was established by co-founders Chris Curry and Hermann Hauser. The start-up ...
  4. [4]
    Acorn Computers Ltd - Company
    Acorn Computers was a British computer company based in Cambridge. It was set up in 1978 by Chris Curry and Hermann Hauser. Arguably Acorn's most famous ...<|control11|><|separator|>
  5. [5]
    The History of Acorn - by Bradford Morgan White
    Dec 10, 2022 · On the 26th of April in 1985, the first ARM CPU came back to AR&D. The ARM1 was slotted into the tube and the entire instruction set was ...
  6. [6]
    The Arm Story Part 1 : From Acorns - by Babbage - The Chip Letter
    Feb 5, 2023 · The new microprocessor was the first Acorn RISC Machine, the first of a series of designs that we now know as Arm.
  7. [7]
    ARM Evaluation System - Software - The Centre for Computing History
    Acorn User (October 1985), Acorn User, BBC Micro, Cassette, 1985. Acorn User (June 1986), Acorn User, BBC Micro, Cassette, 1985. Acorn User (April 1985), Acorn ...
  8. [8]
    The Acorn Archimedes - 4corn Computers
    There were a couple of publicly released versions of Arthur in 1987, 0.30 in June and 1.20 in September. For version 2 (Oct 1988) Arthur was renamed RISC OS.
  9. [9]
    Acorn Archimedes 310 (Arthur 1.2 Installed)
    The A310 ran an operating system (OS) called Arthur. It was based on an earlier OS Acorn wrote in 1979 for the BBC Micro, a 6502-based microcomputer. Arthur was ...Missing: 1.0 | Show results with:1.0
  10. [10]
    How an obscure British PC maker invented ARM and changed the ...
    Dec 20, 2020 · Engineers Steve Furber and Sophie Wilson proved to be key players on the project. ... The new Acorn chip was so RISC-y in fact that Sophie Wilson ...
  11. [11]
    RISC OS Versions - Chris's Acorns - The Centre for Computing History
    RISC OS ; Acorn, Arthur, 1.20, 25 Sep 1987, &A0 ; Acorn, RISC OS, 2.00, 05 Oct 1988, &A1 ; Acorn, RISC OS, 2.01, 05 Jul 1990, &A2 ...
  12. [12]
    How RISC OS happened, as told by original Acorn Arthur lead
    Jun 23, 2022 · Original Acorn Arthur project lead explains RISC OS genesis ... Paul Fellows describes how it beat the overambitious ARX to Acorn's Archimedes ...
  13. [13]
    A technical history of Acorn Computers (Version 0.6 Beta)
    Timeline ; 1989, April, Acorn RISC OS 2 launched. ; 1989, May to July, Revised Archimedes range launched, consisting of A3000, A410/1, A420/1 and A440/1. ; 1990 ...Missing: commercial | Show results with:commercial
  14. [14]
    RISC OS 3.70 and 3.71 - RISCOS Ltd
    In 1997 the rights to the StrongARM were purchased by Intel. Which meant that RiscPCs supplied from late 1997 onwards had an Intel processor, much to the ...
  15. [15]
    Pace - Chris's Acorns - The Centre for Computing History
    When Acorn was split up Pace bought RISC OS to use in their STBs as NCOS ... The DSL4000 is based on set top box technology bought from Acorn/Element 14.Missing: decline 1998
  16. [16]
    RISC OS 4.02 Easy upgrade - RISCOS Ltd
    RISC OS 4.02, released in July 1999, was the first version of RISC OS released by RISCOS Ltd, who had purchased the rights to RISC OS from Acorn Computers Ltd.
  17. [17]
    The aftermath - RISC OS 4 and new systems (1998 to present day)
    RISC OS 4 was finally released in July 1999, as an upgrade for A7000, A7000+ and Risc PC machines. The main features were a massive speed increase.
  18. [18]
    www.riscos.com - RISC OS 4.0x FTP space
    Adds support for USB printers. Printers 1.91. Printers 1.91 (Printers+). This ... Taborca is an addition to the RISC OS 4 printing system that allows the RISC ...<|separator|>
  19. [19]
    RISC OS rights rumble becomes war of words - The Register
    Jun 17, 2004 · In the beginning. RISCOS Ltd was formed in March 1999 just before the Acorn Group - the remanant of one of the pioneers of home and educational ...
  20. [20]
    https://www.mcmordie.co.uk/acornhistory/after.shtml
  21. [21]
    RISC OS Ltd - Chris's Acorns
    This was only sold at the launch at the Acorn South East Show in July 1999. RISC OS 4.00 was released on 2 ROMs to replace the exisiting RISC OS 3 ROMs and a CD ...
  22. [22]
    RISC OS OPEN LIMITED overview - Companies House - GOV.UK
    RISC OS OPEN LIMITED - Free company information from Companies House including registered office address, filing history, accounts, annual return, officers, ...
  23. [23]
    Announcement: RISC OS Shared Source Initiative - OSnews
    Sep 29, 2006 · “Castle Technology and RISC OS Open Ltd are pleased to announce plans for the opening-up of RISC OS source code.
  24. [24]
    Latest news - RISC OS Open
    Oct 22, 2018 · Then in 2006, Castle worked with RISC OS Open to release the source code to RISC OS under a partly-free license. This move allowed anyone to ...
  25. [25]
    RISC OS goes Open Source, supports royalty-free Raspberry Pi ...
    Oct 31, 2018 · RISC OS, the original OS for ARM processors is now available as a fully Open Source operating system (OS), via the Apache 2.0 licence.
  26. [26]
    RISC OS Open: About us - riscosopen.org
    RISC OS Open Limited (ROOL) is a company formed by five people who have been involved in RISC OS projects for many years.
  27. [27]
    RISC OS PRMs: Volume 5a: Chapter 99: ARM hardware
    Although RISC OS runs under a 32 bit configuration, it remains in 26 bit modes for normal operation, providing a high degree of backward compatibility with ...
  28. [28]
    Chapter 3: An introduction to SWIs - RISCOS Ltd
    SWI stands for SoftWare Interrupt, and is one of the ARM's built-in instructions. In brief, when you issue a SWI instruction, the ARM leaves your program. It ...
  29. [29]
    RISC OS PRMs: Volume 1: Chapter 16: Memory Management
    This chapter describes the memory management in RISC OS. This covers memory allocation by a program or module as well as using the MEMC chip to handle how ...
  30. [30]
    Cooperative Multitasking - RISC OS Open - riscosopen.org
    Nov 24, 2020 · Cooperative multitasking uses callbacks, background workers, cooperative threads, and co-routines. The system remains single-task, and the ...Cooperative Multitasking - RISC OS OpenHelenOS as a foundation for next generation RISC OSMore results from www.riscosopen.org
  31. [31]
    http://www.riscos.com/support/developers/prm/armhw.html
  32. [32]
    Volume 2: Chapter 28: FileCore - RISCOS Ltd
    FileCore is a filing system module. It provides all the entry points for FileSwitch that any other filing system does. Unlike them, it does not control hardware ...Missing: documentation | Show results with:documentation
  33. [33]
    Filer - RISC OS 6 User Documentation - The Configuration System
    ... filenames which are all uppercase, as lowercase. Automatic display of thumbnails allows you to set your preferred display type for normal use, but ...
  34. [34]
    FileCore - RISC OS Documentation - RISCOS Ltd
    FileCore. FileCore has been updated to provide access to larger discs and to avoid limitations of the earlier interfaces.
  35. [35]
    Volume 4: Chapter 90: Appendix E: File formats - RISCOS Ltd
    The file formats described in this appendix are those generated by RISC OS itself and various applications. Each is shown as a chart giving the size and ...
  36. [36]
    RISC OS PRMs: Volume 3: Chapter 53: The Window Manager
    The Window Manager is designed to simplify the task of producing programs to run under a WIMP (Windows, Icons, Menus and Pointer) environment.Missing: Layer | Show results with:Layer
  37. [37]
    Guide: The Pinboard - RISCOS Ltd
    The main use of the pinboard is to hold application and folder icons that you use frequently. If they are placed on the pinboard they are always readily ...Missing: environment interaction
  38. [38]
    The RISC OS GUI - Telcontar.net
    May 25, 2020 · The RISC OS desktop is divided into two areas: the Pinboard and the Icon Bar. The Icon Bar displays the icons of mounted file systems and ...Missing: environment interaction
  39. [39]
    Part 3 - The RISC OS Task Manager
    One very useful program in RISC OS is the Task Manager. This allows users to view and manage how much memory is allocated to various system functions as well as ...
  40. [40]
    [PDF] The RISC OS Selection Model and Clipboard
    The second edition of the RISC OS Style Guide recommends the use of clipboard-based (cut- copy-paste) data transfer. This application note describes how this ...Missing: scrap | Show results with:scrap
  41. [41]
    RISC OS Documentation - Clipboard Holder - RISCOS Ltd
    To help with this, RISC OS 4.24 onwards provides two simple SWIs to provide copy and paste facilities to applications. Data pasted onto the clipboard is stored ...Missing: scrap | Show results with:scrap
  42. [42]
    Chapter 21: VDU Drivers - RISCOS Ltd
    Flashing colour​​ RISC OS will swap two colours at a programmed interval. If they are the same colour, then there is no noticeable effect. If they are different, ...Missing: color depth
  43. [43]
    RISC OS PRMs: Volume 1: Chapter 22: Sprites
    The format of the file created by a *ScreenSave or *SSave command is the same as a sprite area, save that word 1 of the control block is not saved. (There ...OS_SpriteOp 32 · OS_SpriteOp 45
  44. [44]
    Graphics on the ARM - www.riscos.com
    Dither patterns are patterns in which two or more colours alternate in order to simulate a third colour that is not available in the palette. There are two ...Missing: mapping | Show results with:mapping
  45. [45]
    Chapter 61: The Font Manager - RISCOS Ltd
    This system is an abstraction from the physical characteristics of the VDU. Text can therefore be manipulated by its size, rather than in terms of numbers of ...Missing: Layer | Show results with:Layer
  46. [46]
    What is RISC OS - Wakefield RISC OS Computer Club
    Aside from wordprocessing and DTP, RISC OS has the usual range of spreadsheets and databases which contain many of the features familiar to users of other ...Bundled Applications · Third-Party Software · Words, Pictures And DesignMissing: key | Show results with:key
  47. [47]
    None
    Below is a merged summary of the standard applications and system utilities in the RISC OS 3 User Guide, combining all the information from the provided segments into a concise and dense format. To retain as much detail as possible, I’ve organized the information into tables for each application/utility, followed by a section for useful URLs. The tables use a CSV-like structure for clarity and density, with columns representing key aspects (e.g., features, references, options, etc.) and rows detailing specific points.
  48. [48]
    RISC OS Documentation - New OS modules - RISCOS Ltd
    Many of these modules provide APIs which are unchanged from their original forms. Refer to the PRMs for details of the implementations. Conversions. OS_Convert* ...
  49. [49]
    RISC OS 6 User Documentation - The Configuration System
    Files should have a header that includes a 26/32bit flag. This allows RISC OS to stop files that might crash the machine from running. For example running a ...
  50. [50]
    RISC OS on x86 - A bad idea? - The Icon Bar
    Note that the emulator you refer to is ARMulator, which is older and much slower. If you wanted to dig up your stuff if you still have it, then we can take ...
  51. [51]
    RPCEmu - Marutan.net
    RPCEmu is an emulator of classic Acorn computer systems, such as the Risc PC and A7000. It runs on multiple platforms including Windows, Linux and Mac OS X.
  52. [52]
    Technical Explanation of the Operation of Aemulor - Sendiri
    Additionally, because code running in an emulated 26-bit addressing mode only has a 26-bit program counter, it can only address 64MB of address space. RISC OS ...
  53. [53]
    RISC OS PRMs: Volume 5a: Chapter 122: AUN - RISCOS Ltd
    AUN uses the TCP/IP standard in such a way as to retain Econet's existing program interfaces, so your existing network programs should continue to work.
  54. [54]
    RISC OS Documentation - Internet components overview
    The Internet module provides the IP (Internet Protocol) access to the rest of RISC OS components, most usually in the form of TCP or UDP (streams, or messages).<|separator|>
  55. [55]
    RISC OS Documentation - Resolver - RISCOS Ltd
    Under RISC OS, communication with DNS is performed by the Resolver module. ... Set if the Resolver module should act as a simple DNS server to other machines.
  56. [56]
    Features - RISC OS Pyromaniac
    RISC OS Select 32bit images are supported (requires memorymap.rom_base to be assigned to a different location such as &8800000 to avoid memory area clashes).
  57. [57]
    RISC OS 6 *Star command summaries - RISCOS Ltd
    *Configure RMASize. *Configure RMASize sets the configured extra area of memory reserved for relocatable modules. Syntax: *Configure RMASize <m> ...
  58. [58]
    [PDF] SCSI Expansion Card User Guide
    The RISC OS SCSI interface provides high level support for SCSI disc peripherals. However the SCSI card provides general support for all types of SCSI devices.Missing: INET | Show results with:INET
  59. [59]
    RISC OS 5 USB stack overview - riscosopen.org
    Sep 4, 2019 · The RISC OS 5 USB stack consists of the following software components: The USBDriver module, which implements the core of the stack.Source Code · Debugging · Internal ApiMissing: USB4 | Show results with:USB4
  60. [60]
    Configuring Networking - RISC OS Open - riscosopen.org
    Dec 17, 2023 · If using an IOMD based machine (Risc PC or A7000 or A7000+) the Ether1, EtherB, EtherH, EtherM, and EtherY drivers are available to download ...Missing: Firewire | Show results with:Firewire
  61. [61]
    Configuration System: Firewall - RISCOS Ltd
    Firewall. This section discusses the configuration of the RISC OS firewall. Although the configure system makes it easier to configure the firewall than was ...Missing: drivers | Show results with:drivers<|control11|><|separator|>
  62. [62]
    Acorn Archimedes Computers - Low End Mac
    Mar 8, 2018 · Acorn also made RISC OS 2 ROMs available for its previous models. The BBC A3000 ran an ARM2 at 8 MHz and included 1 MB of system memory.Missing: Limitations | Show results with:Limitations
  63. [63]
    https://www.riscosopen.org/wiki/documentation/show/RISC%2520OS%25205%2520USB%2520stack%2520overview
  64. [64]
    Archimedes Potted History - Binary Dinosaurs
    The 5000 had a 25Mhz ARM3 CPU, 12MHz memory, 2MB RAM as standard, 4MB max, IDE HDD interface, HD floppy drive, was sold in 4 models with either 40, 80, 120, or ...Missing: limitations | Show results with:limitations
  65. [65]
    Simtec 4-8MB ROM RAM board - Retro-kit
    The memory limit for the Archimedes was defined by an architectural limit of the MEMC chip in that it could address a maximum of 4MB of RAM. The designers at ...Missing: Early | Show results with:Early
  66. [66]
    [PDF] Acorn Enhanced Expansion Card Specification
    This document outlines the expansion card interface implemented on current Acorn Archimedes, R-series,. BBC A3000 computer systems, and the Acorn Risc PC.
  67. [67]
    The Acorn Risc PC and A7000 - 4corn Computers
    RISC OS 3.50 provided support for the new Risc PC hardare (and dropped support for all previous hardware) including the new 16 and 24bit screen modes. The ...Risc Pc 600 · The A7000 · The Strongarm
  68. [68]
    Introduction to RISC OS 3.5 and RISC OS 3.6 - RISCOS Ltd
    The operating system known as RISC OS 3.5 in this manual is RISC OS 3.50, and is the version supplied with the first generation of Risc PC computers.
  69. [69]
    Stable Release Status - RISC OS Open
    The table below gives a summary of the stable release (5.30) readiness of each RISC OS port, based upon a review by RISC OS Open conducted on 28 May 2022.
  70. [70]
    RISC OS for BeagleBoard
    Mar 31, 2010 · A port of the shared-source RISC OS to the new ARM Cortex-A8 based processors. To try out RISC OS on the BeagleBoard, follow the Using the ...
  71. [71]
    How to get started with a BeagleBoard in Library - RISC OS Open
    Dec 24, 2019 · For 'classic' BeagleBoards this means you'll have 4 USB devices connected to the hub (keyboard, mouse, storage device, Ethernet over USB adapter) ...Missing: BeagleBone | Show results with:BeagleBone
  72. [72]
    Moving to RPCEmu for RISC OS on my Mac - The Icon Bar
    Mar 13, 2020 · A really nice bonus of being on RPCEmu is that it is RISC OS 5. VirtualRPC was running RISC OS 4 (or you could upgrade to RISC OS 6 but not 5).Missing: QEMU | Show results with:QEMU
  73. [73]
    RISC OS Open: Time for a Qemu port - riscosopen.org
    Sep 29, 2023 · RPCEmu, allows RISC OS to run as a hardware emulation of RiscPC-era hardware. Platform: Linux, Windows, macOS. Emulation: Custom. Functionality: ...Virtual RPC adjustSA - RISC OS OpenRISC OS on QEMUMore results from www.riscosopen.org
  74. [74]
    The 32bit RISC OS needs to be ported to 64bit to survive, seeks help
    Mar 30, 2025 · The first Moonshot aims to make the RISC OS source code portable and compatible with 64-bit Arm platforms, a prerequisite for future hardware support.
  75. [75]
    RISC OS Moonshots - riscosopen.org
    At the start of the Arm architecture's rise to global dominance, the original RISC OS source code was “26-bit” because there were 26 address bits available in ...Missing: 1 multitasking based
  76. [76]
    RISC OS Open plots great escape from 32-bit purgatory - The Register
    Apr 1, 2025 · Moving from 26- to 32-bit addresses involved ensuring flags were't stored or assumed in the upper bits of pointers, for instance.
  77. [77]
    BBC BASIC Manual: Part 4: Chapter 37: Appendix J - ARM assembler
    For more details of writing in assembly language see the Acorn Assembler Release 2 manual. For more details of RISC OS see the Programmer's Reference Manual.
  78. [78]
    Desktop Development Environment FAQs - RISC OS Open
    For example, when Acorn shipped the RISC iX workstation a version of the Norcroft C compiler was included in the accompanying software bundle, and Arm's ...Missing: interpreter | Show results with:interpreter
  79. [79]
    Norcroft 64 - RISC OS Open
    Dec 17, 2023 · The Norcroft C compiler can output ARM 64bit code. Probably the last mover amongst the currently available C compilers to add a Aarch64 backend.Norcroft 64 - RISC OS OpenC and RISC OSMore results from www.riscosopen.orgMissing: tools interpreter
  80. [80]
    Zap - a programmers' editor
    Oct 21, 2007 · Zap is a programmer's editor for RISC OS, designed for source code and full text editing, and is highly configurable and extensible.
  81. [81]
    Ovation Pro for RISC OS | David Pilling - Retired Software
    Aug 15, 2022 · Click here to download the complete Ovation Pro package - this is the DavidPilling32 folder from the original CD.Missing: IDEs Zap editor
  82. [82]
    RISC OS PRMs: Volume 1: Chapter 14: Modules - RISCOS Ltd
    Relocatable modules run in an area of memory known as the Relocatable Module Area (RMA) which is maintained by RISC OS. They are 'relocatable' because they can ...
  83. [83]
    RISC OS PRMs: Overview of chapters - RISCOS Ltd
    Volume 1: Chapter 1: An introduction to RISC OS An introduction to RISC OS Volume 1: Chapter 2: ARM Hardware ARM Hardware Volume 1: Chapter 3: An introduction ...
  84. [84]
    RISC OS PRMs: Volume 1: Chapter 8: Software vectors - RISCOS Ltd
    When you call a SWI, RISC OS uses the SWI number to decide which routine in the RISC OS ROMs you want. For an ordinary SWI, RISC OS looks up the address of ...Missing: APIs | Show results with:APIs
  85. [85]
    Network - RISC OS Developments
    New Open Source Resolver and MBufManager modules to replace closed-source versions. These are compatible with the older stack too, to allow developers to ...
  86. [86]
    RISC OS Direct 5.31 now available - RISCOSitory
    Oct 24, 2024 · RISC OS Operating System (ROM) is updated from 5.29 to 5.31 with many new features and fixes representing several years of work. · Includes RISC ...
  87. [87]
    Pi memory freed from its 32 bit shackles - RISC OS Open: News
    Pi memory freed from its 32 bit shackles ... The period between stable releases is the perfect time to try out some experimental changes to RISC ...
  88. [88]
    "Moonshots" Initiative to Secure the Future of ... - RISC OS Open: News
    Mar 28, 2025 · The Moonshots initiative represents a fundamental shift: focused, multi-year development projects undertaken by full-time engineers.
  89. [89]
    ROOL aims high with their Moonshots initiative - RISCOSitory
    Apr 6, 2025 · Set up on the ROOL website as a bounty of sorts, the very first Moonshot is: Moonshot: 64-bit RISC OS, with a guide target of £2,500,000 – ...
  90. [90]
    RISC OS Merlin
    Jun 3, 2025 · Maintain full compatibility with 26-bit and 32-bit RISC OS modules and applications; Build the version of RISC OS I always wished for—evolved ...
  91. [91]
    Status of RISC OS Pyromaniac (2025)
    Jun 6, 2025 · Status of RISC OS Pyromaniac (2025: 6 years in) Back at the start of 2023 I gave a short update (https://www.riscosopen.org/forum/forums/1/ ...RISCOSbits at London 2025 - RISC OS OpenStatus of RISC OS on IRC in 2025More results from www.riscosopen.org
  92. [92]
    RISC OS North Show 2025 - Notes from the talks - The Icon Bar
    Mar 29, 2025 · RISC OS Developments released stable Iris last year and new beta now available. Plan for regular new releases. New release of Pinboard on the ...
  93. [93]
    https://www.riscosopen.org/forum/forums/1/topics/19883