Version française

RISC OS

Here is a (non-exhaustive) list of features of Acorn's operating system RISC OS, which make it an intuitive and pleasant system, allowing the user to be very productive. This mainly concerns the graphical interface. Note that most of these features were present from the beginning, in RISC OS 2 (released in 1989), and some other features were added in RISC OS 3 (1992) or as system extensions.

The Mouse

It has 3 buttons, used in a consistent way between the various applications: each button has been given a name that globally indicates its function; from the left to the right: Select, Menu, Adjust. The Menu button is almost always used for displaying a contextual menu; there is no menu bar under RISC OS, only contextual menus, which allow the user to accede to a menu very quickly, without having to move the mouse. The Select button allows to perform the common operations, as the Adjust button but generally with a small difference (depending on the context).

For instance, one can use Select or Adjust to select an object, but with Adjust the object is added to the current selection. Another difference: both buttons allow to move a window (when used over the title bar) or resize it, but Select brings the window to the front, whereas Adjust does not change the window's depth. When there is a notion of direction, for instance when one clicks on an arrow to change a value, Select will change the value in the wanted direction, and Adjust will change it in the opposite direction; this feature allows to reduce the mouse moves. It is particularly interesting when one clicks in a scroll bar to go to the next page or to the previous page.

Internally, a click is always reported as an event, even if it is finally a double-click. This allows the applications to react immediately to the click without having to wait for the possible second click to know if it is a double-click. Likewise, when one clicks on a button (of a dialogue box...), the event is reported as soon as the button is pressed, instead of being reported once the button is released.

The Windows

Obviously, the widgets (icons, in the RISC OS terminology) can either be present or not. All the operations (moves, resizes, etc) are performed in real time. For instance, when one moves a window, the whole window moves, one does not have a ghost like with some graphical user interfaces; and the windows below the moved window are immediately redrawn, because this is a task regarded by the system as prioritary.

The size of a scroll bar reflects the proportion of the document visible. The scroll bars are sticky: when you are scrolling with the mouse, the mouse pointer remains on the scroll bar.

One can scroll in both directions (horizontal and vertical) at the same time, by using the Adjust button instead of the Select button. This is very useful for drawing software, in particular.

When the user wants to enlarge a window, if he reaches the screen edge, then the window is automatically enlarged in the opposite direction. This feature allows again to avoid useless mouse moves.

Finally, the active window (that has the focus) is not necessarily the window at the front like with some graphical interfaces. It can be any window.

The Fonts

The fonts are outline and anti-aliased (except if the user asks for a bitmap font); this allows to have a good quality text display. In the most recent versions of RISC OS, the Font Manager takes the background colour into account to do anti-aliasing (this was not the case in the first versions).

The Menus

The menus are contextual. Normally, they are displayed when the user clicks with the Menu mouse button, but also with Select or Adjust over some icons.

A menu item is selected with the Select or the Adjust button. Using Adjust allows to keep the menu and the submenus open; this allows to save a lot of time in some cases, like a try between several options, or a selection of all the objects (Select all) followed by an operation on these objects (Selection submenu). Note: the dialogue boxes often have the same behaviour; for instance, this allows to choose between closing the configuration window automatically or not when options are applied (Set button) or when they are applied and saved (Save button).

The Communications Between Applications

The user transfers data between applications by drag'n-drop. In particular, this is the case to load or save files. There is no file selector like with other graphical interfaces; instead, one has a particular application, called the filer, that represents various directories in windows (very common...), and the load and save file operations are performed by drag'n-drop between the application and the filer. This can be seen as a particular case of an import/export operation (in fact, this is just a communication between two applications). This is very practical and intuitive, and this allows to reduce the number of operations defined by an application (menu items, icons in a toolbar, or shortcuts).

The communications are implemented by a system of messages. Thus the applications often communicate with each other. This allows them to do only what they have to do, and they do not have useless features, thus it is simpler to use them.

The Graphic Resolutions

They are completely configurables down to the pixel for the vertical resolution and down to two pixels for the horizontal resolution. One can change the screen mode at any time, and the applications automatically cope with the new screen mode.

The screen modes can be either with square pixels or with rectangular pixels (the height being twice the width). The rectangular-pixel screen modes allow to have high horizontal resolutions when the screen is limited in the vertical resolution (limit on the horizontal frequency). For instance, with my screen, I can have 1440 × 560 at 116 Hz or 1600 × 600 at 96 Hz, whereas for 1024 × 768, I am limited to 75 Hz. There is a scale factor (EIG) used internally and allowing to display 1600 × 600 like a 1600 × 1200 or 800 × 600 resolution in particular.

The Icon Bar

There is an icon bar at the bottom of the screen. When the user starts an application, it displays an icon on this bar (except some particular cases); this allows to accede to the application quickly (to open a new window, do a drag'n-drop to this application, etc).

The Memory Allocations

The user can change the size of various buffers (with the mouse) at any time: font cache, system heap/stack, etc.

The Files

The files are typed. A double-click on a file usually starts the corresponding application if it is not already loaded.

One can define image filing systems, which consist in being able to regard a file as a directory; this is very useful for archives, which can be handled as directories, and for just-in-time conversions of file formats (images, video, etc), in a completely transparent way.

The Icons (Sprites)

Under RISC OS, the word icon can denote an image as well as text. For the images in particular, the word sprite is used. All the system sprites can be redefined by the user (or an application designed to do this), which allows to change the look of the desktop completely.

An icon is associated with each file type... in fact, two icons: a large icon and a small icon. In general, at the beginning of a drag'n-drop, a large icon associated with a file type (type of the data) appears, and this icon is transparent (this is implemented by displaying one pixel out of two).

Note: the mouse pointer is also an icon, which can be redefined by the user and can be transparent.

The Patches

RISC OS was designed in such a way to be able to patch it or add extensions very easily, by adding modules, to fix old features or add new ones. For instance, there exists a patch allowing to scroll from anywhere inside a window, by letting the Menu button pressed. This feature makes the user save a lot of time! And as the Menu button is more or less reserved by the system, this patch is compatible with any application.

The Applications

Applications are in fact directories (whose name starts with a !), thus avoiding scattering data on the disc and allowing very easy install and uninstall operations (copy/delete of a directory), or allowing to start an application directly from an archive, thanks to the image filing systems. In such a directory, there are files corresponding to various operations (the file names below are the same ones for every application):

!Boot
Generally a script. It is run when the application is seen by the filer for the first time (directory containing the application opened) or at boot time. It aims to set some system variables. This has a drawback: an application can behave up to crash the system without even being run (I have already seen this); the user has to trust what he installs on his disc.
!Run
Generally a script. It is run when the application is run (double-click on the application icon, for instance). It generally sets some system variables, can load modules or ensure they are present, and start the application itself.
!Help
Generally a text file (can also be HTML). But it is sometimes a script (in particular to open the help file in a given language).
!Sprites
This file contains images to see the application and the files whose type is defined by the application, with icons (sprites) in the filer windows.

There are other files, including in general (the names below are not compulsory, but most applications use them):

!RunImage
The application itself. It is often machine code, but this can also be BASIC, etc.
Messages
Texts of the various messages. They are in a file separate from the application itself in order to make the translations to other languages easier (without needing to recompile the application).
Templates
These are the templates; they can be created and modified with a resource (windows and their elements) editor.
Sprites
Images (icons) used by the application.

The applications are also very well designed and take relatively little memory (they do not have useless features and are very optimized). There exists a Style Guide they must follow, so that all is very consistent.

The ARM Processor

A small note concerning the processor, because RISC OS is very highly linked to this processor...

Acorn designed the ARM processor (Acorn Risc Machine, and later, Advanced Risc Machine) in the middle of the 80's, because no processors were suitable for them at this time. As they did not have much money and had a very small development team, they had to design a very simple processor... but fast, cheap and low-power. This is what does the success of the ARM at the present time.

RISC OS was written for the ARM (taking into account the tricks allowed by the instruction set of this processor), and a large part of RISC OS was directly written into the assembly language; this partly explains its speed (in the past, a compiler could not have taken into account all the possible tricks). But in return, RISC OS isn't portable to most machines.

You can find more information about the processor on the ARM Ltd site or in an article by Paul DeMone.

Notes Concerning this Page

This document has been created from e-mails and news articles (in French) I had written (mainly late 1998). The French version was put on-line on January 17, 1999, then translated into English.

Some Snapshots

The Future

Acorn do not exist any longer. But RISC OS has a future...

Companies that should release machines under RISC OS:

Other projects related to RISC OS (development in progress):



Valid XHTML 1.0! Level Double-A conformance icon, W3C-WAI Web Content Accessibility Guidelines 1.0.
Last updated:
webmaster@vinc17.org