79-511: Open-source (version 5) Proprietary (versions 4 & 6) RISC OS ( / r ɪ s k . oʊ ˈ ɛ s / ) is a computer operating system originally designed by Acorn Computers Ltd in Cambridge , England. First released in 1987, it was designed to run on the ARM chipset, which Acorn had designed concurrently for use in its new line of Archimedes personal computers. RISC OS takes its name from
158-428: A system call to perform a block I/O write operation, then the system call might execute the following instructions: While the writing takes place, the operating system will context switch to other processes as normal. When the device finishes writing, the device will interrupt the currently running process by asserting an interrupt request . The device will also place an integer onto the data bus. Upon accepting
237-645: A computer even if they are not compatible with the base operating system. A library operating system (libOS) is one in which the services that a typical operating system provides, such as networking, are provided in the form of libraries and composed with a single application and configuration code to construct a unikernel : a specialized (only the absolute necessary pieces of code are extracted from libraries and bound together ), single address space , machine image that can be deployed to cloud or embedded environments. The operating system code and application code are not executed in separated protection domains (there
316-585: A development of MULTICS for a single user. Because UNIX's source code was available, it became the basis of other, incompatible operating systems, of which the most successful were AT&T 's System V and the University of California 's Berkeley Software Distribution (BSD). To increase compatibility, the IEEE released the POSIX standard for operating system application programming interfaces (APIs), which
395-667: 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
474-565: A full graphical user interface (GUI) version and a command-line interface only version (RISC OS Pico, at 3.8 MB). 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. Acorn officially halted work on
553-484: A large legal settlement was paid. In the twenty-first century, Windows continues to be popular on personal computers but has less market share of servers. UNIX operating systems, especially Linux, are the most popular on enterprise systems and servers but are also used on mobile devices and many other computer systems. On mobile devices, Symbian OS was dominant at first, being usurped by BlackBerry OS (introduced 2002) and iOS for iPhones (from 2007). Later on,
632-442: A library with no protection between applications, such as eCos . A hypervisor is an operating system that runs a virtual machine . The virtual machine is unaware that it is an application and operates as if it had its own hardware. Virtual machines can be paused, saved, and resumed, making them useful for operating systems research, development, and debugging. They also enhance portability by enabling applications to be run on
711-447: A malformed machine instruction . However, the most common error conditions are division by zero and accessing an invalid memory address . Users can send messages to the kernel to modify the behavior of a currently running process. For example, in the command-line environment , pressing the interrupt character (usually Control-C ) might terminate the currently running process. To generate software interrupts for x86 CPUs,
790-455: A particular application's memory is stored, or even whether or not it has been allocated yet. In modern operating systems, memory which is accessed less frequently can be temporarily stored on a disk or other media to make that space available for use by other programs. This is called swapping , as an area of memory can be used by multiple programs, and what that memory area contains can be swapped or exchanged on demand. Virtual memory provides
869-503: A program does not interfere with memory already in use by another program. Since programs time share, each program must have independent access to memory. Cooperative memory management, used by many early operating systems, assumes that all programs make voluntary use of the kernel 's memory manager, and do not exceed their allocated memory. This system of memory management is almost never seen any more, since programs often contain bugs which can cause them to exceed their allocated memory. If
SECTION 10
#1732781015761948-408: A program fails, it may cause memory used by one or more other programs to be affected or overwritten. Malicious programs or viruses may purposefully alter another program's memory, or may affect the operation of the operating system itself. With cooperative memory management, it takes only one misbehaved program to crash the system. Memory protection enables the kernel to limit a process' access to
1027-440: A program tries to access memory that is not accessible memory, but nonetheless has been allocated to it, the kernel is interrupted (see § Memory management ) . This kind of interrupt is typically a page fault . When the kernel detects a page fault it generally adjusts the virtual memory range of the program which triggered it, granting it access to the memory requested. This gives the kernel discretionary power over where
1106-470: A significant amount of CPU time. Direct memory access (DMA) is an architecture feature to allow devices to bypass the CPU and access main memory directly. (Separate from the architecture, a device may perform direct memory access to and from main memory either directly or via a bus.) When a computer user types a key on the keyboard, typically the character appears immediately on the screen. Likewise, when
1185-402: A specific moment in time. Hard real-time systems require exact timing and are common in manufacturing , avionics , military, and other similar uses. With soft real-time systems, the occasional missed event is acceptable; this category often includes audio or multimedia systems, as well as smartphones. In order for hard real-time systems be sufficiently exact in their timing, often they are just
1264-417: A user moves a mouse , the cursor immediately moves across the screen. Each keystroke and mouse movement generates an interrupt called Interrupt-driven I/O . An interrupt-driven I/O occurs when a process causes an interrupt for every character or word transmitted. Devices such as hard disk drives , solid-state drives , and magnetic tape drives can transfer data at a rate high enough that interrupting
1343-453: A variation of the classic reader/writer problem . The writer receives a pipe from the shell for its output to be sent to the reader's input stream. The command-line syntax is alpha | bravo . alpha will write to the pipe when its computation is ready and then sleep in the wait queue. bravo will then be moved to the ready queue and soon will read from its input stream. The kernel will generate software interrupts to coordinate
1422-562: Is remote direct memory access , which enables each CPU to access memory belonging to other CPUs. Multicomputer operating systems often support remote procedure calls where a CPU can call a procedure on another CPU, or distributed shared memory , in which the operating system uses virtualization to generate shared memory that does not physically exist. A distributed system is a group of distinct, networked computers—each of which might have their own operating system and file system. Unlike multicomputers, they may be dispersed anywhere in
1501-428: Is system software that manages computer hardware and software resources, and provides common services for computer programs . Time-sharing operating systems schedule tasks for efficient use of the system and may also include accounting software for cost allocation of processor time , mass storage , peripherals, and other resources. For hardware functions such as input and output and memory allocation ,
1580-484: Is a change away from the currently running process. Similarly, both hardware and software interrupts execute an interrupt service routine . Software interrupts may be normally occurring events. It is expected that a time slice will occur, so the kernel will have to perform a context switch . A computer program may set a timer to go off after a few seconds in case too much data causes an algorithm to take too long. Software interrupts may be error conditions, such as
1659-745: 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. Limited software portability exists with subsequent versions of the OS and hardware. Single-tasking BBC BASIC applications often require only trivial changes, if any. Successive OS upgrades have raised more serious issues of backward compatibility for desktop applications and games. Applications still being maintained by their author(s) or others have sometimes historically been amended to provide compatibility. The introduction of
SECTION 20
#17327810157611738-422: Is difficult to define, but has been called "the layer of software that manages a computer's resources for its users and their applications ". Operating systems include the software that is always running, called a kernel —but can include other software as well. The two other types of programs that can run on a computer are system programs —which are associated with the operating system, but may not be part of
1817-443: Is only a single application running, at least conceptually, so there is no need to prevent interference between applications) and OS services are accessed via simple library calls (potentially inlining them based on compiler thresholds), without the usual overhead of context switches , in a way similarly to embedded and real-time OSes. Note that this overhead is not negligible: to the direct cost of mode switching it's necessary to add
1896-499: Is supported by most UNIX systems. MINIX was a stripped-down version of UNIX, developed in 1987 for educational uses, that inspired the commercially available, free software Linux . Since 2008, MINIX is used in controllers of most Intel microchips , while Linux is widespread in data centers and Android smartphones. The invention of large scale integration enabled the production of personal computers (initially called microcomputers ) from around 1980. For around five years,
1975-473: Is that they do not load user-installed software. Consequently, they do not need protection between different applications, enabling simpler designs. Very small operating systems might run in less than 10 kilobytes , and the smallest are for smart cards . Examples include Embedded Linux , QNX , VxWorks , and the extra-small systems RIOT and TinyOS . A real-time operating system is an operating system that guarantees to process events or data by or at
2054-435: Is the part of the operating system that provides protection between different applications and users. This protection is key to improving reliability by keeping errors isolated to one program, as well as security by limiting the power of malicious software and protecting private data, and ensuring that one program cannot monopolize the computer's resources. Most operating systems have two modes of operation: in user mode ,
2133-739: The RISC OS Open community. Most recent stable versions run on the ARMv3/ARMv4 RiscPC , the ARMv5 Iyonix , ARMv7 Cortex-A8 processors (such as that used in the BeagleBoard and Touch Book ) and Cortex-A9 processors (such as that used in the PandaBoard ) and the low-cost educational Raspberry Pi computer. SD card images have been released for downloading free of charge to Raspberry Pi 1, 2, 3, & 4 users with
2212-548: 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
2291-542: The CP/M (Control Program for Microcomputers) was the most popular operating system for microcomputers. Later, IBM bought the DOS (Disk Operating System) from Microsoft . After modifications requested by IBM, the resulting system was called MS-DOS (MicroSoft Disk Operating System) and was widely used on IBM microcomputers. Later versions increased their sophistication, in part by borrowing features from UNIX. Apple 's Macintosh
2370-504: The INT assembly language instruction is available. The syntax is INT X , where X is the offset number (in hexadecimal format) to the interrupt vector table . To generate software interrupts in Unix-like operating systems, the kill(pid,signum) system call will send a signal to another process. pid is the process identifier of the receiving process. signum is
2449-607: 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 . The incompatibilities prompted release by The ARM Club of its Game On! and StrongGuard software. They allowed some formerly incompatible software to run on new and upgraded systems. The version of
RISC OS - Misplaced Pages Continue
2528-592: The bitmap system font from previous versions. 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." Support for the characters of RISC OS (and some other historic computers) was added to Unicode 13.0 (in 2020). RISC OS
2607-498: The personal computer market, as of September 2024 , Microsoft Windows holds a dominant market share of around 73%. macOS by Apple Inc. is in second place (15%), Linux is in third place (5%), and ChromeOS is in fourth place (2%). In the mobile sector (including smartphones and tablets ), as of September 2023 , Android's share is 68.92%, followed by Apple's iOS and iPadOS with 30.42%, and other operating systems with .66%. Linux distributions are dominant in
2686-660: The reduced instruction set computer (RISC) architecture it supports. Between 1987 and 1998, RISC OS was included in every ARM-based Acorn computer model, including the Acorn 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 Corporation 's Network Computer and compatible systems. After
2765-420: The transistor in the mid-1950s, mainframes began to be built. These still needed professional operators who manually do what a modern operating system would do, such as scheduling programs to run, but mainframes still had rudimentary operating systems such as Fortran Monitor System (FMS) and IBSYS . In the 1960s, IBM introduced the first series of intercompatible computers ( System/360 ). All of them ran
2844-410: The CPU for every byte or word transferred, and having the CPU transfer the byte or word between the device and memory, would require too much CPU time. Data is, instead, transferred between the device and memory independently of the CPU by hardware such as a channel or a direct memory access controller; an interrupt is delivered only when all the data is transferred. If a computer program executes
2923-474: The CPU to re-enter supervisor mode , placing the kernel in charge. This is called a segmentation violation or Seg-V for short, and since it is both difficult to assign a meaningful result to such an operation, and because it is usually a sign of a misbehaving program, the kernel generally resorts to terminating the offending program, and reports the error. Windows versions 3.1 through ME had some level of memory protection, but programs could easily circumvent
3002-468: 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
3081-607: The OS for the A9home prevented the running of software without an AIF header (in accord with Application Note 295) to stop "trashing the desktop". 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. Static code analysis to detect 26-bit -only sequences can be undertaken using ARMalyser . Its output can be helpful in making 32-bit versions of older applications for which
3160-520: 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
3239-399: 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
RISC OS - Misplaced Pages Continue
3318-421: The acquisition of Acorn Group plc by MSDW Investment, RISC OS was sold to Pace Micro Technology , 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
3397-538: The application program, which then interacts with the user and with hardware devices. However, in some systems an application can request that the operating system execute another application within the same process, either as a subroutine or in a separate thread, e.g., the LINK and ATTACH facilities of OS/360 and successors . An interrupt (also known as an abort , exception , fault , signal , or trap ) provides an efficient way for most operating systems to react to
3476-470: The break-up of Acorn in 1998, development of the OS was forked and continued separately by several companies, including RISCOS Ltd , Pace Micro Technology , Castle Technology , and RISC OS Developments . Since then, it has been bundled with several ARM-based desktop computers such as the Iyonix PC and A9home . As of March 2017, the OS remains forked and is independently developed by RISCOS Ltd and
3555-453: The computer's memory. Various methods of memory protection exist, including memory segmentation and paging . All methods require some level of hardware support (such as the 80286 MMU), which does not exist in all computers. In both segmentation and paging, certain protected mode registers specify to the CPU what memory address it should allow a running program to access. Attempts to access other addresses trigger an interrupt, which causes
3634-471: The details of how interrupt service routines behave vary from operating system to operating system. However, several interrupt functions are common. The architecture and operating system must: A software interrupt is a message to a process that an event has occurred. This contrasts with a hardware interrupt — which is a message to the central processing unit (CPU) that an event has occurred. Software interrupts are similar to hardware interrupts — there
3713-542: 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
3792-447: The earlier Acorn machines listed above. The OS is single-user and employs cooperative multitasking (CMT). 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. The OS memory protection is not comprehensive. The core of the OS is stored in ROM , giving
3871-422: The environment. Interrupts cause the central processing unit (CPU) to have a control flow change away from the currently running program to an interrupt handler , also known as an interrupt service routine (ISR). An interrupt service routine may cause the central processing unit (CPU) to have a context switch . The details of how a computer processes an interrupt vary from architecture to architecture, and
3950-548: 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. The OS uses metadata to distinguish file formats . Some common file formats from other systems are mapped to filetypes by the MimeMap module. The RISC OS kernel is single-tasking and controls handling of interrupts , DMA services, memory allocation and
4029-533: 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 ). 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
SECTION 50
#17327810157614108-401: The guide until RISCOS Ltd 's Select release in 2001. RISC OS was the first operating system to provide scalable anti-aliased fonts. Anti-aliased fonts were already familiar from Arthur, and their presence in RISC OS was confirmed in an early 1989 preview, featuring in the final RISC OS 2 product, launched in April 1989. A new version of the font manager employing "new-style outline fonts"
4187-410: The hardware checks that the software is only executing legal instructions, whereas the kernel has unrestricted powers and is not subject to these checks. The kernel also manages memory for other processes and controls access to input/output devices. The operating system provides an interface between an application program and the computer hardware, so that an application program can interact with
4266-493: The hardware only by obeying rules and procedures programmed into the operating system. The operating system is also a set of services which simplify development and execution of application programs. Executing an application program typically involves the creation of a process by the operating system kernel , which assigns memory space and other resources, establishes a priority for the process in multi-tasking systems, loads program binary code into memory, and initiates execution of
4345-496: The hexadecimal type as ' ,xxx ' to filenames. When using cross-platform software, filetypes can be invoked on other systems by naming appending ' /[extension] ' to the filename under RISC OS . 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
4424-422: 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
4503-418: The indirect pollution of important processor structures (like CPU caches , the instruction pipeline , and so on) which affects both user-mode and kernel-mode performance. The first computers in the late 1940s and 1950s were directly programmed either with plugboards or with machine code inputted on media such as punch cards , without programming languages or operating systems. After the introduction of
4582-404: The interrupt request, the operating system will: When the writing process has its time slice expired, the operating system will: With the program counter now reset, the interrupted process will resume its time slice. Among other things, a multiprogramming operating system kernel must be responsible for managing all system memory which is currently in use by the programs. This ensures that
4661-431: The kernel—and applications—all other software. There are three main purposes that an operating system fulfills: With multiprocessors multiple CPUs share memory. A multicomputer or cluster computer has multiple CPUs, each of which has its own memory . Multicomputers were developed because large multiprocessors are difficult to engineer and prohibitively expensive; they are universal in cloud computing because of
4740-431: The last stable one and the more recent development one. 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. 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 . RISC OS can also run on a range of computer system emulators that emulate
4819-400: The memory allocated to a different one. Around the same time, teleprinters began to be used as terminals so multiple users could access the computer simultaneously. The operating system MULTICS was intended to allow hundreds of users to access a large computer. Despite its limited adoption, it can be considered the precursor to cloud computing . The UNIX operating system originated as
SECTION 60
#17327810157614898-408: The need to use it. A general protection fault would be produced, indicating a segmentation violation had occurred; however, the system would often crash anyway. The use of virtual memory addressing (such as paging or segmentation) means that the kernel can choose what memory each program may use at any given time, allowing the operating system to use the same memory locations for multiple tasks. If
4977-408: The open-source Android operating system (introduced 2008), with a Linux kernel and a C library ( Bionic ) partially based on BSD code, became most popular. The components of an operating system are designed to ensure that various parts of a computer function cohesively. With the de facto obsoletion of DOS , all user software must interact with the operating system to access hardware. The kernel
5056-420: The operating system acts as an intermediary between programs and the computer hardware, although the application code is usually executed directly by the hardware and frequently makes system calls to an OS function or is interrupted by it. Operating systems are found on many devices that contain a computer – from cellular phones and video game consoles to web servers and supercomputers . In
5135-421: The piping. Signals may be classified into 7 categories. The categories are: Input/output (I/O) devices are slower than the CPU. Therefore, it would slow down the computer if the CPU had to wait for each I/O to finish. Instead, a computer may implement interrupts for I/O completion, avoiding the need for polling or busy waiting. Some computers require an interrupt for each character or word, costing
5214-478: 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
5293-418: The same operating system— OS/360 —which consisted of millions of lines of assembly language that had thousands of bugs . The OS/360 also was the first popular operating system to support multiprogramming , such that the CPU could be put to use on one job while another was waiting on input/output (I/O). Holding multiple jobs in memory necessitated memory partitioning and safeguards against one job accessing
5372-619: The server and supercomputing sectors. Other specialized classes of operating systems (special-purpose operating systems), such as embedded and real-time systems, exist for many applications. Security-focused operating systems also exist. Some operating systems have low system requirements (e.g. light-weight Linux distribution ). Others may have higher system requirements. Some operating systems require installation or may come pre-installed with purchased computers ( OEM -installation), whereas others may run directly from media (i.e. live CD ) or flash memory (i.e. USB stick). An operating system
5451-400: The signal number (in mnemonic format) to be sent. (The abrasive name of kill was chosen because early implementations only terminated the process.) In Unix-like operating systems, signals inform processes of the occurrence of asynchronous events. To communicate asynchronously, interrupts are required. One reason a process needs to asynchronously communicate to another process solves
5530-400: The size of the machine needed. The different CPUs often need to send and receive messages to each other; to ensure good performance, the operating systems for these machines need to minimize this copying of packets . Newer systems are often multiqueue —separating groups of users into separate queues —to reduce the need for packet copying and support more concurrent users. Another technique
5609-698: The source code is unavailable. Some older 26-bit software can be run without modification using the Aemulor emulator. 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. Operating system An operating system ( OS )
5688-464: 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. The file system is volume-oriented: 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
5767-557: 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. 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
5846-662: The video display; the cooperative multi-tasking is provided by the WindowManager module. The WIMP interface is based on a stacking window manager and incorporates three mouse buttons (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
5925-473: The world. Middleware , an additional software layer between the operating system and applications, is often used to improve consistency. Although it functions similarly to an operating system, it is not a true operating system. Embedded operating systems are designed to be used in embedded computer systems , whether they are internet of things objects or not connected to a network. Embedded systems include many household appliances. The distinguishing factor
6004-465: Was made available after the release of RISC OS, offering full support for the printing of scalable fonts, and was provided with Acorn Desktop Publisher. It was also made available separately and bundled with other applications. 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. At
6083-517: Was re-licensed under the Apache 2.0 license. In 2018 RISC OS Developments acquired Castle Technology Ltd including its intellectual property. In December 2020, the source code of RISC OS 3.71 was leaked to The Pirate Bay. Versions of RISC OS run or have run on the following hardware. RISC OS Open Limited adopted the ' even numbers are stable ' version numbering scheme post version 5.14, hence some table entries above include two latest releases –
6162-738: 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
6241-406: Was the first popular computer to use a graphical user interface (GUI). The GUI proved much more user friendly than the text-only command-line interface earlier operating systems had used. Following the success of Macintosh, MS-DOS was updated with a GUI overlay called Windows . Windows later was rewritten as a stand-alone operating system, borrowing so many features from another ( VAX VMS ) that
#760239