System

The system supports only some of the processor modes for 32bit execution:
- SVC mode is used for modules (and the OS).
- IRQ mode is used for timed events and other extensible IRQs.
- USR mode for applications and utilities.
- UND mode is used for the undefined instruction handler.
- Modes FIQ, SYS, MON and HYP are not used.
- Only 32bit modes are supported.
In 64bit execution the use of modes is more limited:
- USR mode maps to EL0.
- SVC mode maps to EL1.
- IRQ mode (for simplicity) maps to EL2.
- Other modes map to EL1.
- x18 is currently not defined.
MMU is not enabled - all the execution happens within a flat memory space environment.
Memory protection is not used within many memory regions (including the ROM area).
- The memory below application space (0-&8000) is has a number of traps which are configurable with watchpoints to report accesses to the memory range for diagnostic purposes. (watchregions)
  - 0-&20: Low vector range (not used by RISC OS Pyromaniac)
  - &20-&FE8: Low memory (not used by RISC OS Pyromaniac)
  - &FE8-&1000: Shared pointers, used by C library, FPE, Window Manager (not used by RISC OS Pyromaniac)
  - &1000-&4000: VDU workspace (not used by RISC OS Pyromaniac)
  - &4000-&8000: Scratch space (not used by RISC OS Pyromaniac)
- SVC stack memory can be trapped, to detect corruption of the system stack.
Internal exceptions may be fatal. They are reported with a python backtrace (configurably) and then trigger the Error handler using a hardware error code. Sometimes that might mean that multiple exceptions are reported from a single failure, due to further problems handling the exception.
IRQs may be dispatched through the device vectors.
- Tickers are passed through the device vectors, and use IRQ mode when registered tickers are dispatched.
- VSyncs are passed through the device vectors, and raise events.
Exception vectors are implemented in high address space.
API documentation for features can be found in the docs/prm directory.
The pyro.py command supports a --version full to get information on the system implementation.
Within the system the command *Help Pyromaniac gives information on the system implementation.

SWIs

SWIs are provided for most of the Kernel operations.
- Most of the standard SWIs from RISC OS to 3 are supported, with some of the RISC OS 4 and Select specific features.
- A few of the RISC OS 5 SWIs are supported.
- Unsupported SWIs:
  - OS_BreakPt - Not supported.
  - OS_UpdateMEMC - Not relevant to RISC OS Pyromaniac.
  - OS_InstallKeyHandler - Not supported.
  - OS_ClaimScreenMemory - Kernel does not manage the screen buffer, so this is redundant.
  - OS_ReadRAMFsLimits - Kernel does not manage RAMFS, so this is redundant.
  - OS_DelinkApplication, OS_RelinkApplication - Not supported.
  - OS_HeapSort, OS_HeapSort32 - Not supported by the Kernel (provided by the OSSWIs module)
  - OS_ExitAndDie - Not supported.
  - OS_ReadMemMapEntries, OS_SetMemMapEntries, OS_FindMemMapEntries - Without physical pages, these are redundant.
  - OS_ClaimSWI, OS_ReleaseSWI - Not supported (not sure these were ever defined)
  - OS_Pointer - Partially supported (only for reading type) (ospointer.device_type).
  - OS_AbortTrap - Not supported
  - OS_MMUControl - Without an MMU, controlling it is redundant.
  - OS_SpecialControl - Not supported (not sure what this was intended for)
  - OS_EnterUSR32, OS_EnterUSR26 - Not supported
  - OS_TaskControl - Not supported (not sure what this was intended for)
  - OS_DeviceDriver - Not supported
  - OS_Hardware - Not supported
  - OS_IICOp - Not supported, use the IIC module.
  - OS_ConvertVariform - Not supported
Kernel SWIs can be trapped with OS_ClaimOSSWIs.
SWIs can warn about misuses:
- SWIs issued in SVC mode without the X-bit set may report warnings to the trace output.
- SWIs issued in SVC mode without the X-bit which cause errors may report errors into the trace output.
- SWIs issued in IRQ mode will report a warning in the trace output.
SWI execution depth may be explicitly limited.
- Configuration kernel.swi_recursion_limit may be set to the number of nested SWI calls that may be performed before an error is raised.
- Configuration emulation.internal_recursion_limit may be required to increase the limit of Python function call nesting to allow the SWI recursion limit to be effective.

Memory (Memory management)

Dynamic areas are partially implemented, but don't support the full range of features:
- Creation - supported
- Deletion - supported
- Resizing - supported
- Sparse mappings - not supported properly (they can be faked with dynamicarea.sparsemap_support=fake).
- Handlers - supported:
  - Pre/Post Shrink/Grow will be called on resize.
  - Shrinkable areas - not supported
  - Physical map addresses/specific pages - not supported
  - Abortable areas - not supported
- Clamping - supported (dynamicarea.clamp_*), but not applied to sparse dynamic areas.
- Domain mappings - not supported
- Heap DAs - supported
  - Heap DAs automatically resize when they need to grow.
  - Heap DAs are used for the System Heap and the RMA.
  - Corruption can be detected in many ways.
    - Corruption in Heap DAs (including the system heap and RMA) triggers a report into the trace output when it is detected (debug option daheaperror).
    - Heap tracking can identify repeated frees and ownership of allocated blocks (configuration option dynamicareaheap.tracking_full_checks).
    - Allocated and freed block headers can be marked as tracing or aborting (watchregions.daheap).
    - Guard regions can be included within the protected watch regions to trap overruns and underruns (dynamicareaheap.guard_size greater than 0).
    - When guards are used, their values may be configured (dynamicareaheap.guard_alloc_value, dynamicareaheap.guard_free_value).
- Enumeration - supported
- Renumbering - supported
- Access permissions - not supported
- Locked areas - supported
- Doubly mapped areas - not supported
- Read free space - supported
  - Free space can be configured to be the difference between the configured amount of DRAM and the used memory ('dynamic'), or a static size (dynamicarea.freesize).
- Read change information - supported, but tracks all areas not just the system ones.
Application space, RMA, ROM, the System Heap, SVC, IRQ and UND stack dynamic areas are implemented.
New dynamic areas have been created:
- Zero page is registered as a Dynamic Area.
  - By default this is 0 bytes and so would be inaccessible.
  - It can be configured to be accessible, which allows the modules like SharedCLibrary and Debugger to initialise, which would otherwise try to access data in the zero page area (in the Select versions).
  - The content of zero page can be configured to various values through the zeropage configuration group.
- CPU exception vectors region is registered as a Dynamic Area.
Application space is remappable using the OS_AMBControl SWIs.
- OS_AMBControl doesn't allow remapping into different areas of memory. It can only map into the application space.
- Lazy mappings are not supported.
- Application space can be resized directly. The free pool does not exist, so resizing it does not push pages into the application space.
- OS_AMBControl 9 provides information on the mappings.
Without the MMU, memory protection is not relevant.
OS_ValidateAddress supported.
OS_Memory calls are only supported enough to read the system size. Physical pages do not exist, so it is not possible to enumerate or remap memory, but it is possible to return fake values.
- OS_Memory 8 for reading the memory size is configurable, but may also be forced to specific sizes.
Memory mapped I/O regions (external hardware registers mapped into memory space) are supported, but are incredibly slow, so are disabled by default. At the present time, no memory mapped regions are offered by the implementation.
- OS_Memory 6/7 for reading the memory arrangement can be configured to return errors (the default), return 0 pages available (through osmemory.physical_table_support), or some fake page tables.
Addresses and sizes of DynamicAreas in the memory map are configurable (through the memorymap configuration group), although the system may not function as expected for some configurations.
The base address for new dynamic area allocations is configurable.
Dynamic area names can be validated on creation through configuration (name_zero_effect, name_invalid_effect, name_control_effect).
Dynamic area name length is configurable (name_max).
OS_Heap managed areas are configurable:
- Minimum size of allocations can be set (heap.minimum_allocation).
- Maximum size of a heap can be controlled (heap.maximum_heap_size), which makes it easier to recognise heap header corruption.
- Extends which reduce to 0 or less can be reported as errors, rather than returning -1 (heap.extend_to_nothing_is_error)
- Blocks claimed and freed can be implicitly cleared so that they do not contain left over values, or make it easier to spot invalid uses (heap.clear_*).
- The free list within the heap defaults to the RISC OS Classic format, but can be configured to use a simpler offsets format (heap.free_link_is_heap_offset).
- Allocated block size can be rounded to different values within the heap (heap.rounding).

Interrupts

Generalised interrupts not supported.
Ticker events are implemented:
- OS_CallEvery and OS_CallAfter can be used to register timed events, and they will be called back at the appropriate time.
- Interrupting ticker events are believed to be unreliable, causing interrupts that break the current execution, and are disabled at present.
- Ticker events are triggered when the system is idle and has threaded out of the ARM execution, which may mean that events are delayed.
- Tickers can be dispatched more slowly with a configuration (tickers.dispatch_rate).
TickerV is supported.
VSync can be enabled (graphics.vsync_enabled) and will trigger Event_VSync.

Modules

Modules are loadable into ROM, RMA and may be provided in ROM images through Podule manager:
- ROM modules are initialised first.
- Early init modules will be initialised before other modules.
- ROM modules are not protected.
- ROM modules may report errors and will not fail the boot.
- RMA modules are initialised once the OS has booted.
- RMA modules which report errors will fail Pyromaniac initialisation.
- Modules may be loaded from a separate area, 'Modules area' (modules.module_area_forced).
- Podule Manager can provide additional modules which are treated like ROM modules.
Module entry points are partially implemented:
- Initialise/Finalise - implemented.
  - Compressed modules are not supported.
  - A flag on the initialise entry point offset indicates that the module may be of a different architecture.
- Services - implemented, supporting Ursula style service tables.
- Start - implemented.
- Help and commands - partially implemented.
  - Commands can be dispatched (through the command line and with OS_CLI)
  - GSTrans mappings and the parameter limits in the infoword are honoured.
  - Informational and Help-only commands are supported.
  - FileSystem commands are dispatched when the filesystem is selected.
  - Syntax messages which don't start with Syntax: * are warned about (configurable).
- SWIs - implemented (but not the SWI decoding code).
- Extended flags - implemented and extended.
  - 32bit module flag is required for ARM 32 execution (non-32bit modules will be rejected).
  - Early initialisation modules will be started before modules without the flag.
  - Flags have been created to indicate the architecture of the module - but only ARM 32 is supported.
Allocations within the RMA (Claim, Release, Extend, etc) are implemented.
Module, ROM and extension/expansion ROM enumeration is supported.
OS_SWINumberToString/OS_SWINumberFromString are implemented, resolving names from a file of constants and from dynamically loaded modules.
Modules may be multiply instantiated, and preferred.
Modules may be reinitialised. ROM modules may be reinitialised if they had been killed.
Module names may be abbreviated by suffixing them with a ..
Modules are implementable in Python to provide implementations without having to load the original module.
- Initialise/Finalise - implemented.
- Start - not implemented.
- Service - implemented, but no Ursula style service tables.
- SWIs - implemented.
- Help - implemented.
- Commands - implemented.
- Extended flags - describe the module as being for the 'Python' architecture.
Module notification services are not partially supported.
- Service_ModuleStatus is supported.
- Service_ModulePreInit is supported.
Podules supported through the Podule PyModule.
- Only a single extension ROM is currently supported with --config podule.extensionrom1.
- Podules can only load full RISC OS ROM images at present (actual podule images not supported).
- Podule chunk directories will be synthesised from the ROM images.
- 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).
- RISC OS 5 images are partially supported.
Unplugging modules through the NVRAM configuration is not supported.
- Unplugging modules is supported through the Pyromaniac configuration (modules.unplug configuration option)

OS_Byte

Dispatched through ByteV.
Only some of the reason codes are implemented:
- 80 implemented at time of writing; see --list-registered OS_Byte for named handlers.
- See individual sections of the features for more detail on support.
Status variables (OS_Byte &A6 upward) are supported, although they may not be used by the system.
NVRAM is implemented through this OS_Byte 161/162 (but not checksumed).
- NVRAM requests are passed through NVRAMV, which defaults to an internal implementation.
- NVRAM can be preserved by supplying a backing file with --config nvram.backingfile=<filename>.
- NVRAM backing files can be 240 bytes of data, or a file containing the values.
- NVRAM backing files will be written every time the data is updated.
- An IIC implementation is provided which contains the NVRAM storage, although this is currently not used.
OS_Byte 129 and OS_Byte 0 have configurable values to return for the OS version and Machine type.
OS_Byte 1 (user flag) is supported.
Event enabling and disabling with OS_Byte 13/14 is supported, and will be honoured by OS_GenerateEvent and internally generated events.
Other OS_Byte operations are documented in the following sections.

OS_Word

Dispatched through WordV.
Only a few calls implemented:
- System clock - implemented
- Interval timer - not implemented
- Time conversions - implemented
- Read character definition - implemented
- Palette operations - read and write palette are implemented through PaletteV.
- Pointer operations - some implemented (see the Graphics system for more details)

OS_ReadSysInfo

A few of the calls are implemented, enough to return the hardware as having none of the features of the other platforms:
- Screen size (OS_ReadSysInfo 0) - 0
- Mode/Monitor/Sync (OS_ReadSysInfo 1) - configured module, with monitor type 'MDFs', and vertical sync.
- Chips and ID (OS_ReadSysInfo 2) - no chips, same ID as OS_ReadSysInfo 5
- IO Features (OS_ReadSysInfo 3) - no chips present
- Mac address (OS_ReadSysInfo 4) - configurable
- Unique ID (OS_ReadSysInfo 5) - configurable
- Kernel values (OS_ReadSysInfo 6) - most values are 0; values only returned where implemented
- Abort information (OS_ReadSysInfo 7) - correctly returned
- Platform Class (OS_ReadSysInfo 8) - configurable
- ROM Information (OS_ReadSysInfo 9) - configurable
- OS Version (OS_ReadSysInfo 10) - supported
- Debug handlers (OS_ReadSysInfo 11) - configurable
Kernel debug handlers are configurable to use different implementations:
- null - ignores the output and returns no input.
- stdout - writes output to the console stdout and returns no input.
- stderr - writes output to the console stderr and returns no input.
- socket - connects to a remote server and directs input and output through it.

Platform

OS_PlatformFeatures 0 supported, but returns no IRQ trigger function, and limited features.
- 'SynchroniseCodeAreas required' bit is set, as the system uses the synchronisation points to track code changes.
- 26bit mode is unavailable.
- Vectors are always reported in the high region.
- 'No physical pages available' bit is set, as none of the page manipulation interfaces are exposed.
- The flags are configurable as osplatformfeatures.codefeatures.
OS_PlatformFeatures 33 describes the cache, having a single I cache which is the size of the memory of the machine.
OS_PlatformFeatures 64 describes the CPU registers, and the layout of register dumps.
OS_SynchroniseCodeAreas supported, and used for internal recaching of changed memory regions. May be a very slow operation.
Aborts update DFAR/DFSR, IFAR/IFSR and are reported by the Debugger module.

Services

Services are dispatched internally and to modules.
Many of the system operations do not dispatch services in the way they do under RISC OS Classic; only a few have been implemented.
Internally provided services:
- Service_TaskManagerAcknowledgements reports system information.
Fast service dispatch using the RISC OS 4 service tables is supported.
- PyModules do not currently support fast service dispatch.

Vectors

Vectors may be claimed (OS_Claim), added to (OS_AddToVector), released (OS_Release) and dispatched (OS_CallAVector).
When called, the vectors may be claimed (by pulling from the stack).
Post-processing and multiple calls to lower level handlers are not supported.
Most OS SWIs call the vectors as expected.
UserV is implemented as a simple message printer (configurable), to allow testing of the vector dispatch.
The Debugger module includes a *Vector command to list the vectors in a similar way to the tool of the same name.

Variables (System variables)

Basic setting and reading of variables is supported.
Variables are GSTrans'd on set if requested.
Variables are EvaluateExpression'd on set if requested.
Macros are GSTrans'd on read.
Code variables are supported (both within RISC OS and PyModules)
Enumeration is supported.
Deleting is supported.
Reading variables can cause the buffer to be corrupted with other data (sysvars.read_corrupts_buffer).
Variables are isolated to the emulated environment (not propagated from host environment - this would not really make sense as they have completely different interpretations).
Default system variables:
- CLI$Prompt set to *.
- File$Path set to @..
- Run$Path set to ,%..
- Alias$. set to Cat.
- FileSwitch$CurrentFilingSystem set to HostFS.
- FileSwitch$HostFS$CSD (and friends) set to $.
- Sys$Time set to a code variable to give the current time.
- Sys$Date set to a code variable to give the current date.
- Sys$DateFormat set to %24:%mi:%se %dy-%m3-%ce%yr
- Sys$Year set to a code variable to give the current year.
- Sys$ReturnCode set to 0.
- Sys$RCLimit set to 256.

Conversions

OS_Convert* family are implemented (except the new OS_ConvertVariform).
OS_GSTrans is implemented. OS_GSInit and OS_GSRead are implemented in terms of OS_GSTrans (where in RISC OS Classic, it was the other way around).

Buffers

Buffers 0-9 are supported internally, but largely unused.
Buffer 0 (keyboard input) is read as part of read key interface, but key presses are not inserted into the buffer (they're read directly). This means that OS_Byte 138 to insert characters works and takes precedence over the input from the keyboard.
Buffer 9 (mouse events) is updated by the pointer, but is never read.
OS_Byte 15 and OS_Byte 21 supported for flushing buffers
OS_Byte 128, OS_Byte 138, OS_Byte 145, OS_Byte 152. OS_Byte 153 are supported for reading size, inserting and removing bytes from the buffers.
InsV, RemV and CnPV are supported for the buffer insertion, removal, counting and flushing. Both byte and block interfaces are supported.
BufferManager module does not exist - the buffers are all handled internally.

Input (Character Input)

OS_ReadC, OS_Byte &81 (INKEY) and OS_ReadLine are implemented, and take input from stdin, if available.
OS_ReadC dispatched through ReadCV (RdChV)
OS_ReadLine/OS_ReadLine32 are supported:
- ReadLineV is used to dispatch such calls.
- Configurably may use native 'readline' to give history and line editing.
  - May infer the prompt within the output.
  - History file and the truncation length are configurable.
  - Will output its read line to the graphics implementation only on a complete line being supplied.
  - Tab completion of system variables, *-commands and filenames is available (input.readline_native_completion).
- Escape within a read line is supported (only partially with the native 'readline')
OS_ChangeRedirection is implemented.
*Exec input is implemented.
INKEY is implemented.
- Buffered keys (passed through buffer 0) are returned from the console.
- Keyboard scan only works if the UI component supports it (VNC, GTK and WxWidgets currently support input)
- Under console the keyboard scan will always return no keys pressed:
  - OS_Byte &79 always returns 'no keys pressed'.
  - OS_Byte &81 with -ve values always returns 'no keys pressed'.
Function key input is expanded from Key$* if the key input is triggered.
- Function keys can be triggered from the console when the native readline is not used.
- Function keys can be triggered from the UI where the UI passes these through.
- Function keys can be triggered by buffer insertions with OS_Byte 138.
- Console input can be trigger function keys for certain terminal control sequences (configurable with input.terminal_escape)
Cursor key operations can be controlled with OS_Byte 4.
- Mode 0 (cursor editing) is not supported (silently swallows cursor key presses).
- Mode 1 (generating codes) generates key codes.
- Mode 2 (act as function keys) triggers function keys, as above.
- Input of the cursor keys is supported through the GTK and WxWidgets UI.
- Input of the cursor and function keys in the console is supported for certain terminal control sequences.
Input encoding is configurable.
- Input encoding defaults to UTF-8 (configurable with input.utf_support).
- The input encoding will be converted to the current alphabet before being inserted into the buffers.
OS_Byte 219 to redefine the tab character is supported.
Escape should be handled correctly.
- Escape is triggered by either reprogramming the escape key using OS_Byte 220, or by Ctrl-C (SIGINT) interrupt.
- Event_Escape will be raised if it has been enabled, disabling the standard escape behaviour.
- Escape effects configured using OS_Byte 200 are honoured.
- Escape effects configured using OS_Byte 230 are honoured.
- In VNC, GTK and WxWidgets UIs, the Escape key is functional.
- Escape should follow the regular pattern for RISC OS, although behaviour such as flushing buffers is not effective if keys are not being passed through buffers (as is the case for console).
- Escape cannot be detected whilst in the native readline input.
KeyV can be triggered by the UI (configurable with input.keypress_enable).
- Generates character input into the buffers on key presses.
- Key press state in OS_Byte &79/&7A and OS_Byte &81 are not implemented yet.
- Key repeats delay and rate are supported.
- Key status flags in OS_Byte &CA is supported.
  - KeyV updates the flags in this OS_Byte value when Shift, Ctrl, Caps Lock, Scroll Lock and Num Lock are pressed.
  - KeyV 3 is issued to update the keyboard LEDs (may be displayed in the WxWidgets UI).
  - Caps Lock and Anti-Caps Lock ('Shift enable') are honoured from these flags when characters are inserted into the buffer.
  - Scroll Lock has no effect.
  - Num Lock has no effect.
- Configurable whether KeyV is used outside of the UI (console input never passes through KeyV).
- Event_Keyboard will be issued (configurable with input.keypress_event_enable).
On Windows, console input is read in the background when requested, so as to not block timers.
EOF (Ctrl-D) can be configured to raise an error, issue OS_Exit or OS_Reset, fake an Escape key press, or be ignored (input.eof_effect).

Output (Character output and VDU)

VDU output may be vectored through WrchV (configurable through vdu.wrchv).
- Default operation is to only use the vector when there are claimants.
- The use of the vector can be disabled entirely (which will be faster), or enabled always (which will be slower when there are no claimants).
OS_Write family are implemented, and write to stdout.
OS_NewLine supported.
- When used in the plain VDU implementation is is configurable whether it generates combinations of \r and \n.
- When used in ANSIText VDU implementation will always generate a \n.
OS_PrettyPrint will print formatted output, honouring the current text window. This may result in oddly positioned line breaks in console mode as the text window will most likely not match the size of the text output console.
Redirection of output is not fully supported:
- OS_ChangeRedirection is supported, but never acted upon.
- OS_Byte 3, character output destination, is not honoured, although it does track state.
- Printer output is passed around internally, but is not directly diverted to a separate device.
- VDUXV redirection is supported.
- *Spool/*SpoolOn is supported.
Stdout is converted from the current alphabet (controllable by OS_Byte &47 and *Alphabet) to the output encoding (which defaults to UTF-8). These character sets (alphabet and output encoding) are configurable with --config vdu.alphabet and --config vdu.output_encoding).
Output is flushed on the console in a configurable manner (with --config vdu.flush). Output can be flushed at the end of a line, after each character, or only when the logical position of the cursor changes outside the usual console progression.
VDU sequences are supported, and state is retained for most of the calls. When unsupported, they will be consumed, but the default action is to print the sequence as a diagnostic when they occur, eg [^<char>:<queue>] (configurable).
- VDU 1/VDU 2/VDU 3 is tracked and passes to an internal 'printer' which does nothing with it.
- VDU 5/VDU 4 state is tracked and output diverted to the graphics system if necessary.
- VDU 21/VDU 6 state is implemented.
- VDU 7 is issued as Service_ExternalBell (SystemBell internal module will convert this to a Sound call).
- VDU 8-VDU 13 (except VDU 12) cursor movement are passed through to the console as appropriate. VDU 9 is passed to the console as a space to match RISC OS behaviour.
- VDU 12 (CLS) is ignored by the console (the ANSIText implementation will clear the screen as expected).
- VDU 14/VDU 15 is tracked, and paging actions can be configured through vdu.paging.
- VDU 16 (CLG) is passed to the graphics system.
- VDU 17 (set text colour) is ignored by the plain implementation (the ANSIText implementation will set the colour)
- VDU 18 (set graphics colour) is passed to the graphics system.
- VDU 19 (set palette) records the palette (only a single colour is recorded).
- VDU 20 (reset colours) resets the palette entries and colours, and passes to the graphics system.
- VDU 22 (change mode) changes the effective mode to a numbered mode, and passes to the graphics system.
- VDU 23 is processed and unknown calls will be passed to UKVDU23V (which is many of them).
  - Character definitions and reading are supported.
  - Resetting character definitions with OS_Byte 20 and OS_Byte 25 are supported.
  - The default definitions are the default definitions provided by the RISC OS Kernel.
  - Character redefinition by alphabet is provided by the International module.
  - Text cursor shape definition is supported, and will be used to draw the flashing cursor.
  - Text window is supported in limited ways (appears correctly on UI through Cairo)
  - Text character movement direction is supported.
  - Colour tint selection is supported.
  - Text colour swapping is supported.
  - Character sizes are supported in Cairo.
  - Teletext option selection is supported.
  - ECF definition is supported for both BBC and RISC OS formats.
    - Simple ECF definition is supported.
    - Reading the ECF definition is not supported.
  - ECF rendering is supported in Cairo.
  - ECF origin is supported, but never used.
  - Scrolled text window operations are supported in character mode in the graphics system, but not in byte mode.
  - Clear text region operations are supported in Cairo and ANSIText.
  - Teletext configuration is supported.
- VDU 24 (set graphics window) is passed to the graphics system.
- VDU 25 (plot) is passed to the graphics system.
- VDU 26 (reset windows) resets the text and graphics windows.
- VDU 28 (set text window) records the text window (although scrolling is not supported in ANSIText; should be correct in the graphics system).
- VDU 29 (set origin) is passed to the graphics system.
- VDU 30/VDU 31 cursor supported for moving the cursor (in ANSIText).
- VDU 127 deletes a character.
Paged mode is supported and the manner of waiting for output can be configured:
- A configuration option can be set to change the behaviour to wait for a key press before continuing, or to use Shift, or to ignore pagin.
- Paged mode does not detect a Shift to continue at the console, but can be configured to detect Shift in the graphics UI.
Slow output mode (triggered by holding down the ctrl key during VDU 4 output), is not supported.
Palette operations are tracked.
- OS_ReadPalette is supported, for main palette, border and the pointer, through PaletteV.
- In ANSIText the palette changes are effective after the change (ie do not change existing text).
- OS_Byte 9/10 and VDU 23,9/10 to change flashing colour timings are supported, but ignored.
OS_SetColour is supported for both text and graphics output, but not for patterns.
Tinted colours are supported when in 64/256 colour modes.
Teletext modes are provided through implementations, configured through --config teletext.implementation=<value>.
- The videov implementation calls the RISC OS Select VideoV vectored teletext interface. High quality mode can be configured.
- The videov implementation does not use efficient updates for its handling of the display.
- VideoTTX module provides an implementation of the TTX module through VideoV.
Alternative VDU implementations may be provided and are configured through --config vdu.implementation=<value>; use --list-implementations VDU for a list of VDU implementations):
- plain provides the output described above.
- ansitext augments the 'plain' output by converting RISC OS text colour sequences to ANSI colour sequences.
OS_Byte &86 always reads cursor input position as the current cursor output position.
OS_Byte calls to read character at input or output cursor are supported only in graphics implementations at present.
OS_ReadModeVariable/OS_ReadVduVariables is implemented for VDU and graphics parameters. See Graphics section for details of the graphics parameters implemented. Text parameters:
- Text window bounds supported.
- Text window size supported.
- Text colour and tint supported.
- Highest numbered mode supported.
- Text character size and spacing supported.
ANSIText implementation supports:
- Foreground and background colours (and palette changes, but only for subsequent output) using standard colours, 256 colours and 24-bit interfaces (configurable)
- Cursor positioning.
- Clear screen.
- Cursor movement.
- Cursor shape (block/underline), flash state, and visibility.
- Changing size of terminal to match screen mode (configurable).
OS_PrintChar write characters to the printer implementation.
OS_RemoveCursors/OS_RestoreCursors are supported and will remove the cursor when it is applied (see Graphics section).
A few ColourTrans SWIs have been implemented to make it possible to use some applications which need to work with colour (see ColourTrans section for more):
- ColourTrans_SetTextColour, ColourTrans_SetOppTextColour, ColourTrans_SetColour are supported to select colours.
The output destination for VDU output can be configured to a different file descriptor, if necessary (vdu.output_fd).

Graphics

Graphics calls are understood, and passed on to selected implementation.
- null does not support any output, but tracks the interfaces to give useful returns from SWIs.
- cairo provides the primary graphics implementation.
  - When selected directly it may render to a bitmap (PNG, PNM), an SVG or a PDF.
  - At the end of execution, the contents of the graphics system may be saved to a configurable file.
- gtk provides a UI implementation based on GTK 3 (see the Video section)
  - The underlying graphics are derived from the Cairo implementation.
- wx provides a UI implementation based on WxWidgets (see the Video section)
  - The underlying graphics are derived from the Cairo implementation.
- vnc provides a UI implementation which is served over VNC (see the Video section)
  - The underlying graphics are derived from the Cairo implementation, served by the 'cairo-vnc' package.
- framedevice provides a simple interface which can be used with physical devices.
  - The underlying graphics are derived from the Cairo implementation.
  - Frame device implementations are configured through framedevice.implementation.
  - console and ansi frame device implementations provide graphics on the console, one character per pixel.
  - ssd1306 provides an interface to an SSD1306 OLED display connected via I2C.
  - dreamcheeky provides an interface to a small LED message display connected by USB.
  - turingsmartscreen provides an interface to a LCD display connected by USB.
- bbcbasic provides a graphics output as a BBC BASIC program wich can be run to reproduce the graphics that were rendered. This is only intended for testing purposes, to allow the comparison of different behaviour more easily. It is not complete and many graphics operations will not be reported in the output file.
The state of the graphics system is tracked where possible, and may be used by the different implementations.
OS_Plot calls are interpreted and may be acted upon by the different implementations.
- Debug option plotsvg can be used to output diagnostics of what OS_Plot operations were performed as SVG statements. These can be dropped into an SVG file and will render a partial image of what would have been plotted. Currently this is upside down due to the differences in coordinate systems.
- Unhandled Plot calls are passed to UKPlotV.
- OS_ChangedBox state updated by the implementation if it is acted upon. If the implementation provides updates, they will be returned by the SWI.
VDU 4 and 5 output is passed to the graphics system.
Dot-dash patterns are supported within the Cairo implementation.
ECFs are understood and are mostly supported within the Cairo implementation.
- BBC and RISC OS interpretation of ECFs are both supported.
- Giant ECFs are supported.
- Simple ECFs are not supported.
Colour selection works for shallow colour, 256 colour and deep colour modes.
Modes exist and can be operated on:
- Numbered modes can be selected with VDU 22, OS_ScreenMode 0.
- Mode selectors are supported in OS_ScreenMode, OS_ReadVduVariables, and OS_ReadModeVariable.
  - Attempting to select modes with inconsistent values for ModeFlags and NColour can be configured to warn, generate errors or be ignored (modeselector_fullpalette_invalid, modeselector_ncolour_invalid).
- Default screen mode is configurable (vdu.mode).
- OS_ReadModeVariables and OS_CheckModeValid are implemented.
- Service_ModeExtension is used for unknown modes.
  - RISC OS 3.1 and 3.5 format extensions are supported (vdumode.modeextension_format, vdumode.support_vidclist*).
  - Only the mode variables will be set from the returned modes; VIDC parameters are ignored.
  - Substitute modes are supported.
- Service_ModeChanging and Service_ModeChanged are issued on the change of the mode.
- OS_Byte &87 reads the current mode (and character at cursor, if it is decodable using the current bitmap font).
OS_ScreenMode has many reason codes implemented:
- OS_ScreenMode 0 (Select mode) - Supports selection by mode specifier (mode number, mode selector, sprite).
- OS_ScreenMode 1 (Return mode) - Supported
- OS_ScreenMode 2 (Enumerate modes) - Supported by calling Service_EnumerateScreenModes.
- OS_ScreenMode 3 (Select Monitor Type) - Not supported
- OS_ScreenMode 4 (Configure acceleration) - Supported, but returns that none is available
- OS_ScreenMode 5 (Update frame buffer) - Stubbed
- OS_ScreenMode 6 (Force frame update) - Stubbed
- OS_ScreenMode 7 (Count banks) - Supported
- OS_ScreenMode 8 (Select display bank) - Supported
- OS_ScreenMode 9 (Select render bank) - Supported
- OS_ScreenMode 10 (Copy banks) - Not supported
- OS_ScreenMode 11 (Select display driver) - Supported for reading device only
- OS_ScreenMode 12 (Read display details) - Supported
- OS_ScreenMode 13 (Decode mode string) - Supported
- OS_ScreenMode 14 (Encode mode string) - Supported
- OS_ScreenMode 15 (Select mode by mode string) - Supported
- OS_ScreenMode 255 (Register display driver) - Not supported
- OS_ScreenMode 254 (Deregister display driver) - Not supported
- OS_ScreenMode 253 (Read maximum display driver) - Supported
- Service_EnumerateScreenModes can configurably return the details for the numbered modes (vdumode.enumerate_numbered_modes).
  - Modes returned by the service may be restricted by configuration (vdumode.display_*).
The PyromaniacModes module provides extra modes through configuration (modes.numbered_modes).
OS_ReadModeVariable/OS_ReadVduVariables are implemented for VDU and graphics parameters. See Character output and VDU section for details of the text parameters implemented. Graphics parameters:
- Graphics window supported.
- Cursor position history supported (in both the internal and external variants).
- Graphics origin supported.
- Graphics colours and tints supported.
- Graphics character size and spacing supported.
- Display and screen base addresses, and screen memory size not supported (as there is no frame buffer; see Video section)
- VIDCClockSpeed not supported.
- Horizontal line is supported (as used by the classic Draw module).
- PolyHLine supported (as used by the Select Draw module) (graphics.polyhline_enable).
- VideoDisplayNumber supported.
- Graphics colour patterns ECFs, colours to write to the screen, are not supported.
64 colour modes partially supported.
- OS_SetColour updates the tint parameter consistent with the colour selected. On RISC OS Classic, the tint is a construction parameter for the colour number and the value in VDU variables cannot be relied on to obtain an equivalent GCOL. In RISC OS Pyromaniac the value of the VDU variables for tint is updated consistently. This may have side effects where clients do not expect the tint to change over calls to OS_SetColour.
- Palette changes within 64 colour modes may not have the same effects as RISC OS Classic.
VSync is supported through Event_VSync when enabled (graphics.vsync_enable), and OS_Byte 19 will wait until an appropriate period has passed even if not enabled.
Sprites operations are only partially supported (see the Sprites section).
VDU cursor flashing is supported (configurable)
- Within the UIs it will default to enabled.
- In Cairo the cursor may flash on non-UI when configured.
- When configured off, no CPU impact will be made for flash events.
- VDU operations which control the cursor flash rate, and visibility are supported.
- Flash events are counted through centisecond timer, not through VSyncs.
Screen banks are supported, although whether they are effective and how many is dependant on the graphics implementation:
- OS_Byte 112 and OS_Byte 113 legacy calls select screen banks.
- OS_ScreenMode 7-9 operate on screen banks (OS_ScreenMode 10, copy banks, is not supported).
Cairo graphics support:
- Output buffer is either vector or a 24bit bitmap; paletted modes are emulated.
  - The output may be saved to a PNG, PNM, SVG or PDF on exit (configurable with graphicscairo.save_on_exit and graphicscairo.save_filename)
- 'Video' may be created by configuring the creation of frames, which can then be passed to ffmpeg to create a video.
  - Enabled through configuration graphicscairo.video_enable.
  - Stored as PNGs in configuration graphicscairo.video_directory.
  - May include the mouse pointer when configured (graphicscairo.video_pointer).
- For line drawing when output is a bitmap, drawing may be anti-aliased (disabled by default).
- Lines supported.
  - End point selection not supported (all lines have both ends).
- Dotted lines are supported.
  - End point selection not supported (all lines have both ends).
  - Continuation pattern not supported (all patterns start at the beginning).
- Points supported.
- Triangles supported.
- Rectangles, Parallelograms supported.
- Circles and ellipses supported (may not render as expected in non-square pixel modes).
- Arcs, segments, sectors supported.
- Flood fill not supported.
- Block copy, block move are supported.
- Solid colours supported.
- ECFs supported.
- GCOL actions are not only partially supported:
  - Set (0) works as expected.
  - EOR (3) and invert (4) will do a colour inversion, rather than bitwise paletted operations.
  - Others operate as Set.
- Gap modes are rendered correctly for text output (in both BBC gap mode style and regular style), although graphics operations in gap modes may produce odd effects.
- VDU 12 and VDU 16 (CLS and CLG) are supported.
- VDU 4 output is passed to the graphics implementation and will be rendered appropriately.
- VDU 5 text supported, both as bitmaps and as a native font (not through FontManager), configurably.
- VDU 5 text movement supported as expected.
  - Should wrap correctly at the graphics window edges when unbounded output is disabled, and continue when unbounced output is enabled.
  - Should bound correctly at the graphics window edges.
  - Text written outside the graphics window should never be wrapped.
- VDU 4 and VDU 5 text size configuration are honoured.
- Text window scrolling is supported (not hardware scrolling).
- Graphics window bounds all graphics and text.
- Reading text characters from screen is supported in bitmap mode.
- OS_ReadPoint is supported for reading the point colours.
- OS_Word 9 is supported for reading the point colours through legacy interface.
- Palette changes only affect subsequent output, not existing output on the screen.
- Draw path and fill rendering supported:
  - SWIs are dispatched through the DrawV vector.
  - Paths are supported, although the gap operations may not work as expected.
  - Fill rule NonZero and EvenOdd are supported, but Positive and Negative are not.
  - Triangle caps not supported.
  - All fills are interior (boundary regions, and exterior fills not supported)
  - Line widths are supported.
  - Flattening value is ignored
  - Dash pattern is ignored.
  - Matrix transform operations are supported.
- Screen banks are supported:
  - 2^32-1 screen banks are supported, and will come into existance when referenced.
  - Display and VDU banks are honoured correctly.
ColourTrans module exists to provide some colour manipulation calls (See ColourTrans section)

Video

No frame buffer is currently supported (no Direct Screen Access).
Although the multi-display driver OS_ScreenMode calls are supported, the drivers do not support multiple displays.
UI Configurables:
- Window title is configurable.
- Scale factor is configurable.
- Border around the graphics display is configuable in colour and size (graphicsui.border_colour and graphicsui.border_size).
- Minimum width is configurable, allowing scale up of very small modes.
gtk implementation:
- Closing the window will terminate the system.
- Dynamic scaling not supported.
- Eigenfactors supported.
- Redraws are able to be capped at a redraw rate, to prevent the system running away with refresh as fast as possible.
- VSync is used for updates at the redraw rate.
- Key presses are passed on to the input system.
- Mouse movement is passed on to the pointer system.
- UI pointer shape is updated from RISC OS (graphics.ponter_on_shape, graphics.pointer_off_shape).
- Border is rendered around the graphics output (configurable colour; not using RISC OS palette definition).
- Menus offer RISC OS interaction options:
  - Screenshot (to file and to clipboard)
  - Reboot
- Screen blanking is not supported.
wx implementation:
- Screen display window shows the output from the graphics system.
  - Closing the window will terminate the system.
  - Scaling of the window is configurable to either be disallowed, scale to the window, or scale retaining aspect ratio (graphics.window_resize).
  - Border is rendered around the graphics output, defaulting to the RISC OS palette colour, but may be forced by configuration (graphics.border_*).
- Eigenfactors supported.
- Redraws are able to be capped at a redraw rate, to prevent the system running away with refresh as fast as possible.
- VSync is used for updates at the redraw rate.
- Key presses are passed on to the input system.
- Mouse movement is passed on to the pointer system.
- Mouse clicks are passed to the input system, and Menu may be emulated (emulate_menu_button).
- UI pointer shape is updated from RISC OS (graphics.ponter_on_shape, graphics.pointer_off_shape).
- Menus offer RISC OS interaction options:
  - Screenshot (to file and to clipboard)
  - Reboot
  - Enable and disabling debug options from a list.
  - Show window with keyboard LEDs.
  - Show windows with miscellaneous system information.
  - Show console output.
  - Show memory dumps for modules, AMBs, and dynamic areas.
  - Open a file explorer to examine the hosted file system.
  - Open a python shell to directly examine the system state.
- Centres windows when mode size changes (configurable).
- Screen blanking is supported.
vnc implementation:
- Multiple clients are supported (vnc.max_clients).
- Connection remains running when client.
- Redraws are able to be capped at a redraw rate, to prevent the system running away with refresh as fast as possible.
- Key presses are passed on to the input system.
- Mouse movement is passed on to the pointer system.
- Port can be selected, defaulting to display 2, port 5902 (vnc.port).
- A password may be set for full access to the system (vnc.password).
- A separate password may be set for view only to the system (vnc.password_readonly).
- Screen blanking is supported.
framedevice implementation:
- No input support.
OS_Byte 144 (*TV) is supported, but does nothing.

Pointer (Pointer and mouse)

Outside of the UIs, pointer and mouse operations only track their settings, they never generate any input.
Mouse clicks may be passed through from the UI.
- Mouse clicks enter the mouse buffer.
- Buffered mouse state is read from the mouse buffer.
KeyV calls for the mouse clicks not supported.
Pointer configuration is partially supported:
- Pointer shape can be configured with OS_Word 21, and is passed to the graphics system.
  - GTK and Wx widgets may display the configured pointer in the UI using the native pointer.
- Pointer colours are supported, although some graphics UI systems may not be able to display full colour and may default to monochrome.
- OS_SpriteOp 24 to set the pointer from a sprite is supported.
- Mouse and pointer are always linked.
The OSPointer module provides a *Pointer command (which in RISC OS Classic is provided by the Wimp).
Mouse bounding box not supported.
OS_Pointer supports reading the pointer type and the alternate pointer ('Mouse scroll') position.
PointerV is not used.
Alternative pointer ('Mouse scroll') events are supported.
- Only WxWidgets UI generates these events, but they are passed through.
Mode changes cause the mouse position to be reset to the centre of the screen.

ColourTrans

ColourTrans SWIs are vectored through ColourV.
ColourTrans never uses ECFs to simulate more colours in low depth modes.
Colour matching uses a fixed 2, 4, 1 weighting.
Colour selection
- ColourTrans_SetGCOL - supported
- ColourTrans_SetOppGCOL - not supported
- ColourTrans_SetColour - supported
- ColourTrans_SetTextColour - supported
- ColourTrans_SetOppTextColour - supported
  - Sets the opposite colour number in all modes. In Classic, in 256 colour modes, this call would set the worst matching tint for the best matching colour.
GCOL operations:
- ColourTrans_ReturnGCOL - supported
- ColourTrans_ReturnGCOLForMode - supported
- ColourTrans_ReturnOppGCOL - supported
- ColourTrans_ReturnOppGCOLForMode - supported
- ColourTrans_GCOLToColourNumber, ColourTrans_ColourNumberToGCOL - supported
Colour number operations:
- ColourTrans_ReturnColourNumber - supported
- ColourTrans_ReturnOppColourNumber - supported
  - Returns the opposite colour number in all modes. In Classic, in 256 colour modes, this call would return the worst matching tint for the best matching colour.
- ColourTrans_ReturnColourNumberForMode, ColourTrans_ReturnOppColourNumberForMode - supported
Font operations:
- ColourTrans_ReturnFontColours - not supported
- ColourTrans_SetFontColours - calls to Font_SetColourTable.
Colour tables:
- ColourTrans_SelectTable, ColourTrans_GenerateTable - supported partially
  - Sprites as sources are supported.
  - Current mode, mode numbers, descriptors and sprite mode words as sources are supported.
  - Sprites as destinations are supported.
  - Current mode, mode numbers, descriptors and sprite mode words as destinations are supported.
  - Palette pointers follow the RISC OS 3.5+ definitions of the default palette.
  - Pixel translation tables are supported.
  - Palette tables are not supported.
  - 32K. tables are supported for deep modes rendering to shallow modes (precomputed tables exist for common 256 colour modes).
  - Wide translation tables are supported.
  - Transfer functions are supported (but not for 32K. tables).
- ColourTrans_SelectGCOLTable - not supported
Miscellaneous operations:
- ColourTrans_InvalidateCache - supported, but does nothing.
- ColourTrans_SetCalibration - not supported
- ColourTrans_ReadCalibration - not supported
- ColourTrans_WriteCalibrationToFile - not supported
- ColourTrans_WriteLoadingsToFile - not supported
- ColourTrans_ConvertDeviceColour - not supported
- ColourTrans_ConvertDevicePalette - not supported
- ColourTrans_MiscOp - not supported
Model conversions:
- ColourTrans_ConvertRGBToCIE, ColourTrans_ConvertCIEToRGB - not supported
- ColourTrans_ConvertRGBToHSV, ColourTrans_ConvertHSVToRGB - supported
- ColourTrans_ConvertRGBToCMYK, ColourTrans_ConvertCMYKToRGB - not supported
Palette operations
- ColourTrans_ReadPalette - supported
- ColourTrans_WritePalette - supported for updating the display palette

Sprites

OS_SpriteOp calls are passed through SpriteV.
Rendering calls are mostly supported.
- Many variants of the rendering calls are not supported.
  - Old style masks and 1-bpp masks are supported.
  - Alpha-channel sprites are supported.
  - CMYK sprites are not supported.
  - Colour mapping is not supported.
  - Plotting deep sprites is supported.
  - Plotting in deep modes is supported.
  - Masked and unmasked rendering is supported.
  - Rendering of the mask in the current colour is supported.
  - Left and right wastage are supported on all sprites.
  - Old style palettes on sprites with 256 colours might not be correct.
  - Translucent plotting is applied consistently on all sprites operations.
- Plot actions are supported in line with GCOL:
  - Set (0) works as expected.
  - EOR (3) and invert (4) perform a colour inversion, rather than a bitwise palette inversion.
  - Other actions work as Set.
Screen operations:
- OS_SpriteOp &2 (ScreenSave) - supported
  - A warning is generated if an invalid palette flag is supplied.
- OS_SpriteOp &3 (ScreenLoad) - partially supported
  - Does not load to the graphics window's bottom left.
  - Does not select a screen mode when new style sprite modes are used.
  - Does not write to the palette.
Sprite file operations:
- OS_SpriteOp &a (LoadSpriteFile) - supported
  - Does not validate the sprite file after load.
- OS_SpriteOp &b (MergeSpriteFile) - supported
  - If sprite area is empty, performs a load.
  - Errors may leave the sprite file in a valid but inconsistent state.
- OS_SpriteOp &c (SaveSpriteFile) - supported
Area operations:
- OS_SpriteOp &8 (ReadAreaCB) - supported
- OS_SpriteOp &9 (ClearSprites) - supported
- OS_SpriteOp &f (CreateSprite) - supported
- OS_SpriteOp &11 (CheckSpriteArea) - supported
- OS_SpriteOp &19 (DeleteSprite) - supported
- OS_SpriteOp &1a (RenameSprite) - supported
- OS_SpriteOp &1b (CopySprite) - supported
Sprite information:
- OS_SpriteOp &d (ReturnName) - supported
- OS_SpriteOp &18 (SelectSprite) - supported
  - Does not select the sprite for plotting with OS_Plot
- OS_SpriteOp &28 (ReadSpriteSize) - supported
Plotting:
- OS_SpriteOp &1c (PutSprite) - supported
  - In mismatched colour depths for paletted sprites (eg 16 colour sprite plotted to 256 colour mode), the images will be rendered to the closest colours. Classic would byte copy data, so would be scaled and coloured oddly.
  - Transparent plotting is supported. Classic would not render transparently when the plot action bits 8-16 were set.
- OS_SpriteOp &22 (PutSpriteUserCoords) - supported
  - In mismatched colour depths for paletted sprites (eg 16 colour sprite plotted to 256 colour mode), the images will be rendered to the closest colours. Classic would byte copy data, so would be scaled and coloured oddly.
  - Transparent plotting is supported. Classic would not render transparently when the plot action bits 8-16 were set.
- OS_SpriteOp &30 (PlotMask) - supported
- OS_SpriteOp &31 (PlotMaskUserCoords) - supported
- OS_SpriteOp &32 (PlotMaskScaled) - supported
- OS_SpriteOp &33 (PaintCharScaled) - not supported
- OS_SpriteOp &34 (PutSpriteScaled) - supported
- OS_SpriteOp &35 (PutSpriteGreyScaled) - not supported
- OS_SpriteOp &37 (PlotMaskTransformed) - supported
  - Arbitrary source rectangles are not supported.
  - Destination coordinates are not supported.
- OS_SpriteOp &38 (PutSpriteTransformed) - supported
  - Arbitrary source rectangles are not supported.
  - Destination coordinates are not supported.
- OS_SpriteOp &41 (TileSpriteScaled) - supported
  - Under the Cairo graphics implementation this will be accelerated to only use a single sprite conversion (graphicscairo.tile_acceleratiion).
- Transformations and scalings which produce empty regions can be configured to report warnings or errors (spriteop.empty_transformation).
Creation:
- OS_SpriteOp &e (GetSprite) - supported
- OS_SpriteOp &10 (GetSpriteUserCoords) - supported
Sprite modification:
- OS_SpriteOp &1d (CreateMask) - not supported
- OS_SpriteOp &1e (RemoveMask) - not supported
- OS_SpriteOp &1f (InsertRow) - not supported
- OS_SpriteOp &20 (DeleteRow) - not supported
- OS_SpriteOp &21 (FlipAboutXAxis) - not supported
- OS_SpriteOp &23 (AppendSprite) - not supported
- OS_SpriteOp &25 (CreateRemovePalette) - not supported
- OS_SpriteOp &26 (CreateRemoveAlphaMask) - not supported
- OS_SpriteOp &2d (InsertCol) - not supported
- OS_SpriteOp &2e (DeleteCol) - not supported
- OS_SpriteOp &2f (FlipAboutYAxis) - not supported
- OS_SpriteOp &36 (RemoveLeftHandWastage) - not supported
- OS_SpriteOp &39 (InsertDeleteRows) - not supported
- OS_SpriteOp &3a (InsertDeleteColumns) - not supported
Pixel data:
- OS_SpriteOp &29 (ReadPixelColour) - not supported
- OS_SpriteOp &2a (WritePixelColour) - not supported
- OS_SpriteOp &2b (ReadPixelMask) - not supported
- OS_SpriteOp &2c (WritePixelMask) - not supported
Pointer:
- OS_SpriteOp &24 (SetPointerShape) - supported
Redirection:
- OS_SpriteOp &3c (SwitchOutputToSprite) - ignored when redirecting to screen, error otherwise
- OS_SpriteOp &3d (SwitchOutputToMask) - not supported
- OS_SpriteOp &3e (ReadSaveAreaSize) - not supported
System sprite area is provided by the SpriteUtils module:
- Most of the commands for system sprite area manipulation are provided by the SpriteUtils module.

Fonts

The FontManager provides a number of the original SWIs.
- Not implemented:
  - Font files: Font_MakeBitmap, Font_UnCacheFile, Font_ReadFontPrefix, Font_ReadEncodingFilename
  - Sizing: Font_FindCaret, Font_FindCaretJ
  - Conversion: Font_SetScaleFactor
  - Rendering: Font_SwitchOutputToBuffer
  - Colours: Font_ReadColourTable
  - Configuration: Font_ReadThresholds, Font_SetThresholds, Font_SetFontMax, Font_ReadFontMax
- Implemented:
  - Font handles: Font_FindFont, Font_LoseFont, Font_SetFont, Font_CurrentFont, Font_FutureFont
  - Font files: Font_LookupFont
  - Font specifiers: Font_FindField, Font_ApplyFields
  - Informational: Font_CacheAddr, Font_ReadDefn, Font_ReadInfo, Font_ReadFontMetrics
  - Sizing: Font_StringWidth, Font_StringBBox, Font_ScanString, Font_CharBBox
  - Conversion: Font_ConverttoOS, Font_Converttopoints, Font_ReadScaleFactor
  - Rendering: Font_Paint, Font_Caret
  - Enumeration: Font_ListFonts, Font_DecodeMenu
  - Colours: Font_SetFontColours, Font_SetPalette, Font_SetColourTable, Font_CurrentRGB, Font_FutureRGB
Fonts are provided by a font resource.
- The 'standard' fonts may be faked by the font system, and will do nothing. They will enumerate as the standard set of fonts (graphics.font_fake.)
- When the Cairo graphics system is in use:
  - The standard fonts can be mapped to the standard Cairo serif, sans-serif and monospace fonts (graphics.font_standard). The italic variants can be forced to be oblique (fonts_standard_synthetic).
  - The font-config system (through the fc-list command) can be used to determine the fonts available (graphicscairo.fonts_fontconfig), and may be filtered to allow only certain fonts (graphicscairo.fonts_fontconfig_allo, graphicscairo.fonts_fontconfig_deny). Font names will be converted to RISC OS font names based on rules using the weight and italic effects.
  - The bounds used by the font characters can be read from the font itself (the designer's metrics), or by examination of a sample of characters (graphicscairo.fonts_designer_bounds).
  - Fonts may be given a name prefixed by a : to use the host font of that name.
Font identifier fields are supported:
- \F (font identifier): Supported
- \f (territory for font name): Supported, but not used
- \E (encoding): Supported
- \e (territory for encoding): Supported, but not used
- \M (matrix): Supported. Trailing space is configurable (font.enforce_trailing_space_on_matrix).
Font handles can be restricted to a particular range (font.handle_min, font.handle_max).
Unused font handles can be retained, or freed from the list immediately (font.free_early).
Font handles can be made to be unique per claimant (font.reuse_handles).
Font_ListFonts menu generation is not supported.
Font control strings are not well supported, and where unsupported will be stripped.
Font_Caret is supported through line drawing:
- Can be configured can be configured to use 'loops' on the end of the the stem (fontmanager.caret_loops)
- Double width is supported.
- OS units and millipoints are supported.
- Flag bit 2 is ignored (as this is set by the Wimp, though it has no meaning), but all other unsupported flags raise an error.
- 3 forms of caret are used, depending on the vertical height. These follow the style of the Classic FontManager.
- Does not render with EOR in Cairo (as this is not implemented).
- OS_ChangedBox is updated at the completion of caret render.
Font_ConverttoOS can be rounded to the current output's pixel units (fontmanager.converttoos_rounded).
PLOT 206-215, VDU 23, 25 and VDU 23, 26 not implemented.
The font scale factor is always 400; it cannot be changed.
Font_Paint support:
- Justification is supported
- Rub out box is supported
- OS unit and millipoint rendering is supported
- Coordinate block for spacing of characters and words is supported.
- Kerning is never applied, and requests for it will be ignored (fontmanager.error_on_kerning).
- Transformation matrix is supported.
- Right-to-left rendering is not supported.
- Cairo rendering will always blend to the background, even when not requested.
- OS_ChangedBox is updated at the completion of font rendering.
Font string control codes support:
- Control codes are supported in all the supported SWIs.
- Move x/y are supported.
- Select font is supported.
- Underline position and thickness is supported, but only works reliably for horizontal text.
- Colour selection by GCOL/RGB are supported.
- Matrix is supported.
- Comment is supported.
Font_ScanString support:
- Control codes are supported.
- Coordinates blocks are not supported.
- Matrix is supported.
- Kerning is not supported.
- Right-to-left is not supported.
- Returning matrix is not supported.
- Split character is supported.
- Returning split count is supported.
- Returning matrix is supported.
- Maximum x and y offset are supported.
Current and future contexts are supported (Font_CurrentFont, Font_CurrentRGB, Font_FutureFont, Font_FutureRGB).
- The colours returned are the colours selected in the current mode. In Classic FontManager these calls would return the supplied colours.
Font_ListFonts support:
- RISC OS 2 compatible mode defaults the enumeration parameters.
- Font identifier and local font names are supported, although local name is always the same as the font identifier.
- Termination with CR and NUL are supported.
- Returning a list of encodings is supported.
- Font menu definition is supported.
- Encoding menu definition is not supported.
Font_DecodeMenu support:
- Regular font menus are supported.
- Encoding menus are not supported.
Font_SetPalette support:
- Palette gradient is applied in linear RGB space.
- Compatibility and TRUE RGB values are supported.
Font_SwitchOutputToBuffer support:
- Redirection to a buffer is not supported.
Font_SetColourTable support:
- Only the start and end of the table are supported.
- Notification of the colours without a table is supported.
Font identifiers in font strings (Font_FindFont, Font_ApplyFields, Font_FindField) are described as being terminated by spaces in the PRMs. This is never the case, and cannot be made optional as spaces are already declared as significant in the documentation.
FontV is not used by FontManager by default, but can be configured (fontmanager.fontv):
- R8 on entry is the SWI offset, as per the DrawV precedent.
- R8 should be set to -1 on return if the SWI has been handled (which differs from DrawV).
CLI commands:
- *FontCat is supported, and can take an extra -encodings parameter to list font encodings instead of fonts.
- *FontList is supported.
  - Size and dots-per-inch are listed, although DPI is not applied anywhere.
  - Usage count is supported.
  - Age is supported, as 'Recency' counter.
  - Cache data size is not reported (there is no cache data).
- Unsupported: *FontInstall, *FontRemove, *FontLibrary, *LoadFontCache, *SaveFontCache.

Filesystem

Only a host filesystem is implemented.
- Filesystems cannot be registered with the built in system (although their registration can be ignored with register_filesystem).
- A RISC OS Classic FileSwitch may be loaded which allows regular filesystems to be used.
Filenames are passed through GSTrans to expand variables.
Filesystem operations are passed through vectors as expected.
Opening and accessing files which are already open for write can now be checked (filesystem.check_open_files).
Only a single 'host' filing system supported; temporary and current filing systems are not supported.
- The base of the native filesystem can be configured (filesystem.native_directory).
- The encoding used for the native filesystem can be configured (filesystem.native_encoding).
- The encoding used for RISC OS filesystem can be configured (filesystem.riscos_encoding).
OS_File is fully implemented, for the limitations of the host system.
- Load actions are supported.
- Loading Generic Code (&F95) files will synchronise code areas, but can be disabled (filesystem.load_gencode_synchronises).
- Timestamping will be applied based on the load and exec addresses supplied.
- An error will be reported if the memory required for loading files is not present.
- Native filesystem operations treat filetypes as ,xxx extensions, and load/exec addresses as ,llllllll,eeeeeeee extensions.
- Native files with the executable bit set will be treated as filetype UnixEx (filesystem.unix_executable). They can be executed if pyromaniacmodule.unixexecutable_enable is set.
OS_Find can open and close files.
- Error handling, and the extra bits on open are not well supported.
- Close all files on current filesystem can configurably report an error, or ignore the request, but it won't close the files.
OS_Args can read the EOF state, pointer, extent and allocated space, path name.
- SCB flags are partially supported.
- Temporary filesystem read by OS_Args 0,0 returns as 0 (no filesystem).
OS_Byte can be used to read the EOF state of a file.
OS_BGet/OS_BPut can read and write a byte, and report EOF condition followed by errors on subsequent reads.
OS_GBPB can read and write multiple bytes, and supports the directory enumeration interfaces.
- Enumeration can be configured to return results like FileCore, or more efficiently (filesystem.enumerate_last_chunk).
- Enumeration can be configured to return the context offset either in monotonically increasing values or a variety of other ways (filesystem.enumerate_context).
- Enumeration supports wildcards.
- Enumeration buffer can cause the buffer to be corrupted (filesystem.enumerate_corrupts_buffer).
OS_FSControl is vectored, but only a few interfaces are supported:
- Shutting files is supported, but generates an explicit error.
- Changing and unseetting the current directory, library and URD are supported.
- Changing and reading directories 'unchecked' is supported.
- *Back and *Up supported.
- Unsetting directory, library and URD is supported.
- StartApplication supported, but doesn't deal with temporary filing system.
- Run file supported:
  - Calls RunAbsolute for absolute files.
  - Calls RunUtility for utility files.
  - Calls RunUntyped for untyped files.
- RunAbsolute supported:
  - Loads the code (if necesary).
  - Calls the executable at &8000 for ARM code in AArch32, and at &8100 in AArch64.
  - Does not issue the UKCompression services.
  - Checks the AIF header is present and suitable for the system (executables.absolute_allow_unheadered).
- RunUtility supported:
  - Checks the header when configured (executables.utility_allow_unheadered), defaulting to enabled on AArch64.
  - May not free the workspace on certain exit types.
  - May run from a separate dynamic area, to identify problems more easily (executables.utility_da).
- Cataloguing directories (*Cat, *LCat, *Ex, *LEx, *EnumDir) is supported.
- Information on a file is supported for *Info and *FileInfo.
  - *Info can be configured to use Sys$DateFormat value or a fixed value.
- RunUntyped supported, and executes Run actions as necessary.
- *Wipe is supported for a limited set of options (unsupported: Confirm, Date range).
- *Copy is supported for a limited set of options (unsupported: Look, User buffers, Newer, Structure only, Delete source, Prompt for disc change, Confirm, Date range)
- *Count is supported, although the Confirm option is not implemented.
- *Wipe, *Copy, *Count can be configured to error, warn or ignore unknown flags (filesystem.multifile_unsupported_flags).
- Access permissions (*Access) are supported.
  - Access permissions on native files will be synthesised when read, and translated back to native format when the permissions are set.
  - Lock permissions are not supported.
  - Execute only permissions are not supported.
- Rename file is supported.
- Shutdown filesystem is not supported.
- Convert filetype name to number supported.
- Convert filetype number to name supported, and can be configured to truncate or error (filesystem.filetype_strict_range).
- Convert file information to filetype supported.
- Canonicalise filename supported.
- Reading boot option is implemented, and returns a configured value for the host filesystem.
- Setting boot option not supported.
- Boot from filesystem attempts to execute &.!Boot according to the boot option.
- Reading and setting defects not supported.
- Reading free space with OS_FSControl 49/55 is supported (configurably may return host filesystem or fixed values).
  - *Free will report the free space on the currently selected directory, or a given path.
- Registering, selecting filesystems not supported.
  - However, registrations can be ignored to allow the components to initialise (filesystem.register_filesystem).
- Reading internal file handles is supported, but without filesystems the filesystem information word is 0.
Timestamps on objects may be configured to always return a fixed value (useful for consistency during testing).
Filehandles are numbered from a high limit, downwards
- The upper and lower limits on the file handle numbers are configurable (filesystem.filehandle_*)
- File handles can be enumerated through OS_FSControl 58.
'Filesystems' (in the sense of ADFS:<specifier>) are not supported - everything is rooted at $.
Statistics can be gathered on the operations performed on files (filesystemstatistics.enable).

CLI

Dispatched through CLIV.
Command line buffer is 1024 bytes.
- Configurable through progenv.cli_size.
- Size is readable through OS_ChangeEnvironment 33.
Empty commands and comments - supported.
File execution - supported (by filename, by / prefix, by *Run command)
Aliases - supported
Abbreviated commands - supported
Filesystem prefix - supported if the filesystem interfaces support it (supplied interfaces do not, but classic FileSwitch does)
Filesystem commands - supported if the filesystem interfaces support it (supplied interfaces do not, but classic FileSwitch does)
Module name directed commands - supported (Module#<module> configurable)
Commands are directed to the preferred module instance.
Module command syntax errors support dictionary lookups.
Redirection - recognised and stripped, but not honoured.
GSTrans - supported
Argument counting - supported
Service_UKCommand - supported (LegacyBBC python module will handle commands which don't have a space after them, eg *FX).

Devices (I/O access)

Joystick input is not supported.
ADC is not supported.
RTC (Real Time Clock) is supported.
- OS_ReadMonotonicTime implemented.
- Time reading and writing through OS_Word 14 and OS_Word 15 is implemented.
- Operations are issued through RTCV.
- Time offsets may be configured, to alter the real time clock by a specified amount.
- An IIC implementation is provided which contains the PCF8583 RTC/NVRAM chip, although this is currently not used for the clock.
- Timezone is supported in the Territory module as the host time zone.
- RTCHWDS1307 module can be enabled to use the DS1307 IIC RTC chip.
- RTCHWDS3231 module can be enabled to use the DS3231 IIC RTC chip.
- RTCHWPCF8563 module can be enabled to use the PCF8563 IIC RTC chip.
- RTCHWPCF8583 module can be enabled to use the PCF8583 IIC RTC chip (as used in the RiscPC).
Parallel devices are supported through different implementations in the ParallelDeviceDriver.
- Implementations are provided for:
  - null - tracks state only.
  - file - writes to (or reads from) native files.
  - socket - connects to a remote server and diverts input and output to it.
- Does not support parallel: filing system.
OS_SerialOp is supported to access serial implementations.
- Issued through SerialV.
- Implementations are provided for:
  - null - ignores all access to the serial port.
  - file - reads and writes from files on disc.
  - pyserial - access to real serial devices through the pyserial python module.
- Does not support serial: filing system.
GPIO access is supported through the GPIO module.
- Implementations are provided for:
  - null - does not provide any pins.
  - static - provides static values on pins and ignores outputs.
  - mcp2221 - provides access to external GPIO pins through MCP2221 USB IIC/GPIO interface.
  - pcf8574 - uses the IIC module to access GPIO pins on a PCF8574.
  - pcf8575 - uses the IIC module to access GPIO pins on a PCF8575.
  - mcp23008, mcp23017 - uses the IIC module to access GPIO pins on the MCP23008 and MCP23017 devices.
  - pigpio - uses the pigpio Python module to access GPIO pins on a Raspberry Pi.
  - rpigpio - uses the RPi.GPIO Python module to access GPIO pins on a Raspberry Pi.
  - ch341 - provides access to GPIO pins through CH341 USB IIC/GPIO interface.
  - wx - provides GPIO pins within the WxWidgets UI for both input and output.
IIC access is supported through the IIC module.
- Implementations are provided for:
  - internal - provides registered handlers, and a PCF8583 Clock/RAM chip.
  - null - ignores writes and returns 0 for all reads.
  - mcp2221 - provides access to external devices through MCP2221 USB IIC/GPIO interface.
  - pigpio - provides access to I²C through the Raspberry Pi's ports, or over the network.
  - cp2112 - provides access to I²C through CP2112 IIC/GPIO interface.
  - ch341 - provides access to I²C through CH341 USB IIC/GPIO interface.
- Internal IIC implementations are configurable (iicinternal.devices) and listable (--list-iic-devices):
  - aht10 - AHT10 temperature/humidity sensor.
  - ds1307 - DS1307 RTC/CMOS.
  - ds3231 - DS3231 RTC.
  - lm75 - LM75 temperature sensor.
  - max30205 - MAX30205 temperature sensor.
  - mcp4725 - MCP4725 DAC.
  - mcp9808 - MCP9808 temperature sensor.
  - pcf8563 - PCF8563 RTC.
  - pcf8583 - PCF8583 RTC/CMOS storage.
MIDI is not supported.
Econet is not supported.

Sound

Internal SoundChannels module provided, playing back sound through MIDI.
- Voices are supported only as MIDI voices:
  - The default voices are mapped to approximately sensible MIDI voices, and may be configured.
  - Voice information can be read.
  - MIDI channels are only configured on first use, to avoid affecting existing MIDI usage if no sound is output.
- Global volume supported.
- Sound operations are passed through the Python rtmidi module.
- Gate only, no parameter modification.
- Sounds are asynchronous and up to 16 channels can in theory be used (although only 8 currently supported).
- Sound buffering can be configured to work like RISC OS or the BBC (actually defaults to BBC, because it's a much nicer system).
- Tuning is not supported.
- *Voices, *ChannelVoice and *Sound supported.
- OS_Byte 210 to suppress sound is supported (not documented in the PRM, but supported by RISC OS Classic).
- Service_SoundControl - issued and if claimed will abort processing.
- Service_Sound - issued on initialisation and finalisation.
- Does not issue service on startup.
SoundDMA is supplied as a stub which only tracks state.
- This means no sampled sound output.
- 16bit sound extension SWIs are not supported.
- Sound_Configure - supported but only tracks state.
- Sound_Enable - supported but only tracks state.
- Sound_Stereo - supported but only tracks state, and does not quantise stereo positions.
- Sound_Speaker - supported but only tracks state.
- Sound_Mode - not supported.
- Sound_LinearHandler - not supported.
- Sound_SampleRate - not supported.
- *Audio, *Speaker and *Stereo are supported through calls to the above SWIs.
- *Stereo can also report the current state of the stereo position (not supported under RISC OS Classic).
SoundScheduler is supplied and can schedule playback.
- SoundScheduler may call the SWIs for requested beats.
- The code interface provided by Sound_Schedule and Sound_Schedule32 is not supported.
- The accuracy of scheduled dispatch is limited by the ticker events, so cannot be greater than a scheduled call per centisecond.
- Sound_QBeat may report beats according to time values returned from the system clock (sound.scheduler_type).
SharedSound not provided (without SoundDMA it isn't useful).

Networking

Simple Internet module providing a native socket interface.
- Only some of the SWIs are sending and receiving data (recv, recvfrom/_1, sendto, sendmsg/_1, read, write).
- New style and old style calls have differing degrees of support (mostly this relates to the sockaddr structure layout).
- Socket_Ioctl supports some operations:
  - Non-blocking configuration (FIONBIO)
  - Data in buffers (FIONREAD and FIONWRITE - new to RISC OS)
  - Asynchronous notifications (FIOASYNC)
  - Interface information reading (AF_INET, AF_LINK and AF_INET6) (SIOCGIFCONF)
    - Interfaces are ordered to try to return the most useful first (loopback, multicast, broadcast, point-to-point), but otherwise keep the host order.
    - Interface names will be converted to RISC OS format (specifically this applies to Windows where the long UUIDs will be converted to numbered 'host' interfaces).
    - Addresses follow the standard sockaddr_in6 and sockaddr_dl (SIOCGIFADDR)
    - Flags for the interface are translated to give RISC OS style flags, possibly synthesised on Windows (SIOCGIFFLAGS)
    - Broadcast addresses can be read (SIOCGIFBRDADDR)
    - Netmask addresses can be read (SIOCGIFNETMASK)
    - Destination addresses can be read (SIOCGIFDSTADDR)
    - MTU can be read (SIOCGIFMTU)
    - Destination addresses are not supported (SIOCGIFDSTADDR)
    - Metrics are supported, but return a fixed value (SIOCGIFMETRIC)
- Socket_Select supported.
- Socket_Setsockopt supports the some of the options:
  - Many socket options at level SOL_SOCKET are supported, if they are supported by the underlying system.
  - IPPROTO_IP options which require a single byte or word are supported. This means that the multicast interface and membership options are not supported.
- Socket_Recvmsg and Socket_Recvmsg_1 are partially implemented. The socketextra package is required to provide support for reading the iovec and control messages, however the sockaddr structure will not be populated. Simple requests without control messages may fall back to recvfrom instead.
- Blocking operations will block tickers from happening.
- Asynchronous sockets will trigger Event_Internet in the background:
  - The situations in which the events are called may differ slightly from the original implementation.
- No Socket_InternalLookup support, which means kvm access to read statistics and interface hardware information is not possible the way that it used to be done.
- AF_LINK sockets can be used to read the interface hardware addresses. A modified version of ifconfig is required to take advantage of this.
- No routing information available (AF_ROUTE sockets on the host system may not work as expected by RISC OS, although you can still use them but must know about the host representation)
- On startup, initialises Inet$Hostname and Inet$LocalDomain with values from the host system.
- Unimplemented SWIs: Socket_Shutdown, Socket_Getsockopt, Socket_Stat, Socket_Readv, Socket_Writev, Socket_Sendtosm, Socket_Sysctl, Socket_InternalLookup, Socket_Filter.
- *InetStat supports only simple information on open sockets.
- The module's operation can be disabled through a configuration option.
Resolver module provides limited functionality.
- Resolver_GetHostByName supported for remote names.
  - Local hosts file is supported through InetDBase:hosts, configurably (resolver.hosts_file)
  - Lookup through LanManFS not supported.
  - Lookup through ResolverMDNS not supported.
  - Lookup through Freeway not supported.
- Resolver_GetHost not supported.
- No services issued on resolution.
- Configuration of resolver is limited.
  - The Resolver_CacheControl SWIs are supported as stubs.
  - The module itself may be disabled through a configuration option (resolver.enable).
- *ResolverConfig is implemented.
- System variables are supported like in RISCOSSelect.
  - Inet$Hostname raises Service_InternetVars when changed, validates host name and updates Inet$LocalDomain if multiple components are specified.
  - Inet$LocalDomain raises Service_InternetVars when changed and validates the domain.
  - Inet$Resolvers raises Service_InternetVars when changed, but does not issued the 'reordered' service. The list of resolvers is not used.
  - InetDBase$Path raises Service_InternetVars when changed.
Network applications will probably fail if they attempt to read the internet database (InetDBase$Path) files, such as InetDBase:Services, if these are not available in the filesystem.

Misc (Miscellaneous Kernel functions)

OS_CRC supported.
OS_ReadArgs supported.
OS_SubstituteArgs / OS_SubstituteArgs32 supported.
OS_EvaluateExpression supported, although some of the operators are not yet implemented.
OS_Confirm supported.
- Multiple implementations (osconfirm.implementation).
- Default riscos implementation provides the usual pointer based confirmation:
  - Configurable to allow the display of a message when a confirmation response is required.
  - Configurable to program the pointer and read the mouse buttons for input.
  - The characters used for confirmation are configurable (in RISC OS Classic the characters were defined in the Kernel Messages file).
- yes, no and escape implementations always return a given result.
- wxwidgets implementation uses a native dialogue box for a response.
OS_ClaimOSSWI supported.
OS_ClaimProcessorVector supported, although only the undefined instruction vector has been heavily tested.
OS_Reset supported (configurable whether it resets or exits, and may explicitly exit with 'power off' extension).

MessageTrans

Implemented as a module, which can operate in one of 3 ways:
- none: All SWIs return errors
- simple: All SWIs return as if they file were open and give either a fake response, or the default value. Useful for testing when the expected Messages files do not exist.
- full: A full implementation which reads Messages files and returns tokens properly. Not actually a 'full' implementation right now as some SWIs are not implemented.
MessageTrans_Lookup error behaviour on short buffers is now configurable (messagetrans.overflow_error).
In simple configuration:
- MessageTrans_ErrorLookup supported to pass through the error code, as a simple means by which errors can be reported (as this SWI is commonly used to report errors, it is better that it return a useful message, rather than 'SWI not known').
- MessageTrans_OpenFile, MessageTrans_CloseFile return without doing anything.
- MessageTrans_FileInfo returns a fake size.
- MessageTrans_ErrorLookup, MessageTrans_Lookup, use the default value supplied. If no default is supplied, a message based on the token and parameters is generated.
- MessageTrans_GSLookup works as MessageTrans_Lookup but then GSTrans's the output.
- MessageTrans_MakeMenus is supported, but will report values as for MessageTrans_Lookup.
- MessageTrans_CopyError is supported.
In full configuration:
- Never directly accesses files in memory (ResourceFS access is more costly).
- Always loads the files into memory.
- Error numbers are not returned correctly.
- Default dictionary is not supported.
- Other SWIs should operate as expected.

ProgEnv (Program environment)

The environment runs utilities (&FFC) and absolutes (&FF8) in 32bit or 64bit USR mode, depending on their declaration.
OS_GetEnv/OS_WriteEnv supported.
OS_UpCall supported.
OS_ChangeEnvironment and its deprecated friends are implemented.
- Pass through ChangeEnvironmentV.
- MemoryLimit is set on boot, and updated in the application space DA handler on resize.
- ApplicationSpaceSize is set on boot, and updated in the application space DA handler on resize.
- Error handler is called when an error is raised within an entered module or application.
- UpCall handler is called when OS_UpCall is issued.
- Abort handlers called when exceptions are raised, and the default handlers generate errors as expected. Types of aborts are reported according to the IFSR or DFSR.
- New BranchThroughZero handler (32) is called on detecting execution at address 0.
- ExceptionDumpArea is implemented and is used by the default handlers.
- New ExceptionDumpRegion handler (33) is implemented to capture the code around the execution address on aborts.
- Non-transient callbacks are dispatched but don't always work as expected (OS_SetCallBack and exits from Escape and Event handlers are honoured).
- Escape conditions should be honoured and processed by the environment handlers as expected. Acknowledging escape generates most of the same side effects as RISC OS would (although some are incomplete).
- Exit handlers are called as expected on application exits; the default handler exits the environment.
- Event handler is not implemented (will not be called for events).
- UpCall handler is implemented (will be called for events).
- Breakpoint handler is not implemented.
- OtherExceptionHandler is never called.
- CAOPointer is supported, but not used properly for application startup.
- Special handler 33 has been defined to be report the space used by the command line, and how large it is.
OS_EnterOS/OS_LeaveOS are implemented (sorry) as they are used as part of the test framework.
OS_IntOn/OS_IntOff are implemented, but may be configured to report errors.
OS_CallASWI/OS_CallASWIR12 are implemented internally.
Transient callbacks (OS_AddCallBack/OS_RemoveCallBack) are supported, and will be triggered when the OS is returning back to USR mode.
Interrupt signals (Ctrl-C on POSIX tty systems) are trapped and will be passed as an Escape (regardless of the definition of the escape key) to the system.
Break/Escape actions and effects are not currently supported completely.
- Break is not generatable.
- Escape is generated by Ctrl-C, or by the defined escape character.
- Escape may be disabled (OS_Byte 200).
- Escape effects (OS_Byte 230) are supported.
- Event_Escape is raised if enabled.
- Escape is not passed through the buffer system.

Errors (Error handling)

Data aborts, prefetch aborts and undefined instructions are passed to the exception handlers as expected. May be configured to display the registers at the time of the exception automatically.
- Additional information is available when the trace interface is in use.
- The region for the address being reported may be reported in the error message.
- C backtrace may be available if it is recognised by the trace system.
A new environment handler is used to report Branch Through Zero.
A new environment handler records the instructions leading up to the exception address.
Failures within the Utility or Absolute code through OS_GenerateError are reported as such from the tool.
Failures within the Python, will be reported through backtraces, which is converted to a hardware error in RISC OS.
Errors raised within an entered module or absolute will cause the Error handler to be called as expected; if the default handler is present, these will cause the system to exit.
Errors are passed through ErrorV.
Error pointers are checked for validity and may be replaced:
- A pointer of 0 is configurable with error.nullpointer_effect to either pass the null pointer on (passthrough), generate an explicit Null error pointer message (message), or report the string ofla (ofla).
- A pointer to invalid memory of 0 is configurable with error.invalid_effect to either pass the null pointer on (passthrough) or generate an explicit Invalid error pointer message (message).
- A pointer to an unaligned address is configurable with error.unaligned_effect to either pass the null pointer on (passthrough) or generate an explicit Unaligned error pointer message (message).
- These checks will be reported through the trace system as warnings.

Booting

By default the system sets up a minimal environment, but passes through many of the stages which were originally performed by RISC OS Classic.
As not all of the boot-time operations are relevant to the Pyromaniac system, they may not all be issued. A non-exhaustive list of the start up operations (see riscos/kernel.py in Kernel.initialise/Kernel.boot/Kernel.system_boot for more information):
- Creation of system dynamic areas.
- Initialisation of the SVC stack (with a BTS-aware initialised base).
- ROM module initialisations.
- Podule module enumeration and module initialisations.
- Module initialisations.
- Alphabet configuration.
- Memory size configuration (not supported).
- Configured filesystem selection (not supported).
- Service_PostInit issued.
- Queued transient callbacks called.
- Mode selection (configurable).
- Startup banner (configurable).
- Service_Reset.
- Startup bell (configurable).
System boot (which is the running of the boot sequence, etc) is not performed by default. When enabled it triggers:
- Boot from filesystem (configurable).
- Boot into configured language (not supported).
- Run BootMenu (configurable).
- Enter supervisor (configurable).
The system startup is intended to be able to provide enough to start tools, without precluding the ability to initialise as a full startup which loaded RISC OS modules might expect.

Desktop

No WindowManager module is supplied, but certain SWIs and commands are supported to ensure that command line tools operate as expected.
- The RISC OS Classic WindowManager will work with a few small modifications for AMB operations.
Wimp_ReportError provides an interface to report errors and get responses from the user.
- Service_WimpReportError is raised for the start and end of the call.
- Service_ErrorStarting, Service_ErrorEnding, Service_ErrorButtonPressed are issued, but are not restartable.
- RISC OS 3.5 categories are supported.
- RISC OS 3.5 additional buttons are supported.
- Application names are supported by querying Wimp_ReadSysInfo and TaskManager, defaulting to 'application'.
- Sprites are included within the WxWidgets implementation.
- Serious errors are recognised from the error group and a special list of numbers, and produce the RISC OS 3.5 style 'Application has gone wrong' messages.
- Five implementations are provided.
  - null which does nothing.
  - vdu which outputs the information on the VDU stream.
  - graphics which outputs a graphics representation like RISC OS Classic.
  - easygui which opens dialogues on the native system.
  - wxwidgets which provides a native dialogue when WxWidgets is used for the graphics implementation.
Wimp_ReadSysInfo provides a stub for a few functions.
- Wimp_ReadSysInfo 0: Task count is configurable with wimpreadsysinfo.task_count.
- Wimp_ReadSysInfo 1: Mode is configurable with wimpreadsysinfo.mode.
- Wimp_ReadSysInfo 2: Sprite suffix is configurable with wimpreadsysinfo.iconsprites_suffix.
- Wimp_ReadSysInfo 3: Desktop state is configurable with wimpreadsysinfo.desktop_state.
- Wimp_ReadSysInfo 7: Window manager version is configurable with wimpreadsysinfo.wimp_version.
- Wimp_ReadSysInfo 8: Returns the font handles that would be used by Wimp_TextOp.
- Wimp_ReadSysInfo 11: Returns the application space size from the environment.
- Wimp_ReadSysInfo 16/19: Returns the sprite pool bases for the ROM, RAM and priority pools.
Wimp_SpriteOp can use configurable sprite pools to access sprites.
- WimpSpritePool module manages the sprite pool.
- wimpspritepool.rom_native_filename / wimpspritepool.rom_filename populates the ROM sprite pool on use.
- wimpspritepool.ram_native_filename / wimpspritepool.ram_filename populates the RAM sprite pool on use.
- wimpspritepool.priority_native_filename / wimpspritepool.priority_filename populates the RAM sprite pool on use.
- wimpspritepool.protect_rom_sprites changes the order of searching for named sprites.
- *IconSprites is provided by the WimpSpritePool module to populate the sprite pool.
  - *IconSprites on its own will list the contents of the sprite pool.
- *ToolSprites is provided by the WimpSpritePool module.
Wimp_BaseOfSprites is supported.
Wimp_CommandWindow provides a rendering of the class command window used by the WindowManager.
- The state of the window manager can be passed through to the Wimp_ReadSysInfo 3 variable.
- The window colours are configurable through wimpcommandwindow.colour_*.
- The window can be configured to appear immediately, rather than waiting for output with wimpcommandwindow.immediate_effect.
- The command window uses the font provided by Wimp_TextOp.
Wimp_TextOp can be used to render text in a similar manner to the WindowManager in RISC OS Classic.
- No 'current redraw window' is present, and requesting positions relative to it will produce an error.
- The default font name and size used are configurable through wimptextop.font_*.
- Wimp$Font, Wimp$FontSize and Wimp$FontWidth are set up as code variables from their first use, which have immediate effect when changed.
- Wimp_TextOp 0-3 are implemented.
- Wimp_TextOp 4 (truncate with ellipsis) is not implemented.
Wimp_SetColour can be used to select a graphics colour (GCOL) using Wimp colours.
Wimp_TextColour can be used to select a text colour (COLOUR) using Wimp colours.
Wimp_SetPalette/Wimp_ReadPalette can be used to retriecve or manipulate the Wimp colour palette.
Wimp_SetMode will change mode immediately.
Wimp_PlotIcon can be used to render icons.
- Some validation strings (specifically those affecting rendering) are supported:
  - R: border types are supported, with the slab in colour (or C overrides).
  - A: allowed characters are understood, but not used by the renderer.
  - D: password obscuring is supported.
  - F: font colours are not supported.
  - C: 24bit colour specification is supported (wimpicon.validation_c).
  - K: key actions are understood, but not used by the renderer.
  - L: multi-line text is supported. RISC OS Classic did not support alignments of the multi-line text, but RISC OS Pyromaniac may use all the alignments (wimpicon.multiline_alignment).
  - P: pointer sprite is not supported.
  - S: sprite name is supported, and uses the selected sprite if both are supplied.
  - T: tinting is not supported.
  - X: iconbar resizing is not supported (and wouldn't be used by the renderer).
  - Y: flags are supported, but not used by the renderer.
- Icon flags are partially supported, where they relate to rendering:
  - Horizontal, vertical and right-justified flags are supported, and should function as in RISC OS Classic.
  - Selected and shaded icons are supported.
  - Bordered and filled icons are supported.
  - Half-size sprites are supported.
  - Icon fonts using specified handles are not supported.
  - Deleted icons are supported (won't be drawn).
  - Colours are mostly supported (Wimp colours, R-validation colours, C-validation colours, selection and shaded colours).
- Icon data types are mostly supported (indirected, text and sprite, in all combinations).
- Sprite selection colours use inversion (as pre-RISC OS 4).
- Sprite shading colours may use lighten to grey, grey and lighten (as pre-Select), or blend to background (as in RISC OS Select) (wimpicon.shaded_style).
- Deep sprite colour mapping (and thus selection and shading of deep sprites) is not supported.
- Extended KSAT form of Wimp_PlotIcon is mostly supported.
  - Coordinate offsets are supported.
  - Background colour specification is supported.
  - Window handle specification is not supported.
  - Default sprite area specification is not supported.
  - Highlight flag is not supported.
- VDU mode reverts to VDU 4 after rendering, rather than staying in VDU 5 mode.
Window operations are only supported in a limited way:
- Window operations are visual only - you cannot interact with them.
- There is no window stack, so windows are only drawn when Wimp_OpenWindow is issued.
- Windows are not redrawn if their position or state is changed.
- Some of the window flags are supported:
  - Old style flags are promoted to new style.
  - Title bar text is supported and will be rendered.
  - Windows are not moveable by the user.
  - Hotkeys are not supported (as there is no polling).
  - Window user redraw is not supported.
  - Pane windows are not treated any differently.
  - Windows are not bounded to the screen.
  - Horizontal and vertical scroll bars are supported.
  - Background and forground window flags are not supported.
  - Back and close icons are drawn as placehoders.
  - Maximise icon is drawn as a placeholder.
  - Status flags (bits 16-20) are not supported.
  - Real colour flag is not supported.
  - Extra flag for true colour is supported (and the 'C' validation is honoured).
  - Extra flags for 3D borders are not supported.
  - Extra flag for returning shaded icons is supported.
- Window nesting is not supported.
- 3D window borders are not supported.
- Windows without frames are not supported.
- Window handles follow the pattern of handles from RISC OS Classic, but are not references to memory.
- Icon redraw is clipped to the window.
- Wimp_CreateWindow will create a window and return a handle.
- Wimp_GetWindowState will return the current state of the window.
- Wimp_OpenWindow will immediately redraw the window in the new position.
- Wimp_CloseWindow changes the window flags, but has no visual effect.
- Wimp_DeleteWindow will delete the window from those known, but not remove it from the screen.
- Wimp_GetIconState, Wimp_SetIconState, and Wimp_ResizeIcon are supported, although they will not redraw without a Wimp_OpenWindow.
- Wimp_WhichIcon is supported.
- Wimp_GetPointerInfo is supported, with the window flag for returning shaded icons.
- Wimp_CreateIcon and Wimp_DeleteIcon are supported, but never reuse deleted icons.
- Wimp_GetWindowState and Wimp_GetWindowInfo are supported.
Wimp_OpenTemplate, Wimp_LoadTemplate, Wimp_CloseTemplate are supported, although fonts are not applied.
Wimp_SetCaretPosition and Wimp_GetCaretPosition are supported, although they have no visual effect.
Wimp_SlotSize is supported.
WimpCommands module provides some commands which are usually handle by the WindowManager.
- *WimpMode will decode the mode string and issue a Wimp_SetMode.
- *WimpSlot will modify the current application space, but does not record the next slot size
TaskWindow module is supplied, which can return a configurable state for TaskWindow_TaskInfo.
TaskManager module is supplied, which returns a list containing only itself when enumerating tasks (configurable).
- *TaskManager_Acknowldgements displays the acknowledgements to the VDU stream.
- Tasks returned by the enumeration can be configured.
- Task name termination is configurable as 0-termination or CR-termination.

Invocation

Configuration of the emulated system is possible through command line switches (--config <system>.<var>=<value).
Internal modules can be enabled by command line switch (--load-internal-modules). They may be disabled by using the unplug configuration (--config modules.unplug=<modules-list>).
RISC OS Modules can be loaded by command line switches (--load-module <file> and --load-rom-module <file>)
System variables can be set by a command line switch (--set-variable <var>=<value>)
Invocation allows:
- Running of utilities (specify native filename).
- Running of absolutes (specify native filename).
- Entering modules (--enter-module <module>)
- Executing module commands (--command <command>). May be specified multiple times.
On exit, Service_PreReset will be issued (configurable with pyro.reset_effect).
Total execution time can be limited (--config emulation.runtime_limit=<seconds>).
When multiple actions (commands, module entry, system boot, etc) are performed, the terminating behaviour is:
- They will terminate when an error is returned.
- If pyro.stop_on_failing_rc is enabled, execution will terminate once Sys$ReturnCode is non-0.
If pyro.return_rc is enabled, the tool's exit code will be set to 1 if a RISC OS error occurred, or the Sys$ReturnCode value. If the option is disabled, the exit code will be either 0 or 1, based on those same conditions (ie 0 is success, and 1 is failure).
Terminating messages are configurable, and may be written to stdout, stderr or to the RISC OS drivers (--config execute.output):
- Errors generated are printed by default (--config execute.error_template).
- Exit is silent by default (--config execute.exit_template).
- OS_Reset prints a message by default (--config execute.reset_template).
Signals to the system are handled in a logical way:
- SIGINT (usually Ctrl-C) is passed to the OS as an Escape key (regardless of the configuration of the Escape key code).
- SIGTERM has the usual behaviour of terminating the application.
- SIGUSR1 will report the current execution location to the trace stream.
Exit codes for the tool are dependant on the type of error (see --help-exit-codes):
- Exits with errors (SWIs generating errors without the X bit) will return a non-0 return code.
- Successful exit with OS_Exit (or through MOV pc, lr in the case of Utilities and module commands) will return a 0 return code, or the return code of the OS_Exit SWI if ABEX was supplied.
- Aborts return code 125.
- Failure during the booting (usually module errors) return code 124.
- Incorrect configuration returns code 123.
- Bad command arguments returns code 122.
- Exit due to a reboot (OS_Reset) returns code 121 (configurable whether a reboot restarts the system).
- Exit due to a timeout returns code 120.
- Exit due to explicit termination (such as by closing the UI window) returns code 119.
Pyromaniac Command server (pyro-server) allows starting a RISC OS to run commands within a Unix environment.
- Runs RISC OS commands through the pyro-client tool, within the server environment.
- Client returns RISC OS command return codes on exit.
- The RISC OS server continues running after the commands executed through the client exits.

SysRqs (System requests)

System requests ('SysRqs') provide interfaces to access the internals of the Operating System implementation:
- Subsystems have commands related to the operations they perform.
- System requests are exposed through internal interfaces and a line-based TCP server (sysrqserver.enable).
- The TCP server provides human readable responses to requests.
- UI implementations use the SysRqs system to query the internal state of the Operating System.
System request subsystems provide access to different areas, prefixed by the subsystem name:
- ambs - Application space management.
- clipboard - Access to the ClipboardHolder data.
- config - Pyromaniac configuration.
- debug - Pyromaniac debug and tracing.
- dynamicareas - Dynamic area memory management.
- fs - Filing system.
- graphics - Graphics and VDU systems.
- internet - Network system.
- input - Access to the input system.
- memory - Access to logical memory.
- regs - Access to ARM registers.
- nvram - Access to NVRAM configuration bytes.
- modules - Relocatable module system.
- sysvars - Access to system variables.
- tasks - Wimp task information
- tickers - Access to the ticker list.
- timings - Timings system.

PyModules (Supplied Modules)

SystemBell - generates a bell through the regular SoundChannels interface, or through the console depending on configuration.
- systembell.implementation controls the bell's effect.
- Implementation sound issues the Sound_Control calls in the regular way.
- Implementation console issues a bell through the console.
- Implementation message prints a message to the RISC OS output.
- Implementation wxwidgets uses the host system bell when used with the WxWidgets UI.
SoundDMA - stub implementation which just tracks configured values.
SoundChannels - sound implemention that uses python-rtmidi.
- This provides asynchronous sound with up to 15 channels.
- May provide a BBC-style buffering system for the SOUND calls, in addition to the RISC OS system. The BBC would buffer notes and could play multiple notes simultaneously, with the next starting when a note on the channel completed. The RISC OS system only plays notes immediately.
- MIDI instruments can be selected by choosing the voice configuration with sound.voice_* settings.
- See the Sound section for more detail.
SoundScheduler is provided and can play synchronised notes.
IIC - a means of communicating with the I²C hardware, provided as implementations. See the 'Devices (I/O access)' section for more details.
Internet - an implementation of the BSD Sockets interface, as provided by the Internet 5 module. See the 'Networking' section for more specific implementation details.
Resolver - a simple implementation of the DNS resolver. Does not support background operations. See the 'Networking' section for more specific implementation details.
TWIN - a rudimentary command handler for *TWIN which allows BASIC TWIN commands to launch an editor. The host's nano editor (configurable through the texteditor configuration) is invoked on the BASIC program.
- *Edit command allows the same functionality for other text files.
LegacyBBC - provides some older interfaces from the BBC:
- *FX<number> support (and *Key, *TV, and *Opt) without spaces
- OS_Byte 160 legacy interface to OS_ReadVduVariables (required for ARMBasicEditor, not supplied).
- OS_Word 7 (SOUND) is passed to Sound_Control
- OS_Word 8 (ENVELOPE) is recognised and ignored.
- Configurable with legacybbc.enable for the module's availability, and legacybbc.warnings for any use of its interfaces.
BASICTrans - provides a translation of some messages used by the BASIC module.
TaskWindow - dummy module which always returns that we are not in a TaskWindow (configurable).
TaskManager - dummy information on the system's tasks.
- Allows enumeration of the Tasks present on the system (only the TaskManager itself is present; configurable).
- *TaskManager_Acknowledgements displays the acknowledgement results for the system.
DDEUtils - provides only a few interfaces:
- The extended command line interface is supported.
- Throwback SWIs are supported, and have multiple implementations:
  - null - does nothing.
  - console - writes the throwback information to the console, and may be configured to use links to open the referenced files.
  - posturl - sends the throwback information to a remote URL.
Portable - Provides multiple implementations to read the system state.
- Can power off the system, and may pass through the host power state.
- Portable_Idle will sleep for a centisecond.
- psutil implementation reports host battery time.
- osx implementation reports most variables from the host system.
- Services are not issued.
- Events are never issued.
Territory - Stub implementation, which only supports a few SWIs.
- Supported territory SWIs: Territory_Number, Territory_NumberToName, Territory_NameToNumber.
- Supported alphabet SWIs: Territory_AlphabetNumberToName, Territory_SelectAlphabet, Territory_WriteDirection
- Supported time SWIs: Territory_ReadCurrentTimeZone, Territory_ConvertDateAndTime, Territory_ReadTimeZones, Territory_ConvertStandardDateAndTime, Territory_ConvertStandardDate, Territory_ConvertStandardTime, Territory_ConvertTimeToOrdinals, Territory_ConvertOrdinalsToTime, Territory_ConvertTimeStringToOrdinals.
- Supported character SWIs: Territory_CharacterPropertyTable, Territory_LowercaseTable, Territory_UppercaseTable, Territory_ReadSymbols, Territory_ControlTable, Territory_PlainTable, Territory_ValueTable.
- Territory_Collate is supported, but does not honour the ordering of alphabetic characters (unicode code point ordering is used).
- The character property tables are generated from the Unicode categories for characters in Latin 1. This means that the control characters in the C1 range (&80-&BF) will not be correct for Acorn Latin 1. The accent information is inferred, as accents are not special to Unicode, and may be labelled incorrectly.
- TimeZone information is read from the host system.
URI - can launch URIs in the host system (configurable whether it's able to function)
- Configurable to disable the module, or disable the launching of certain schemes.
ClipboardHolder - can transfer clipboard text to and from the host system (configurable whether it's able to function).
- *Clipboard_FromFile copies a file in RISC OS to the host clipboard.
- *Clipboard_ToFile copies the host clipboard to a file in RISC OS.
- Multiple implementations are available:
  - null - does nothing
  - static - holds the content and never transfers it out of the system.
  - pyperclip - uses the python pyperclip package to interface with the native clipboard.
  - posturl - sends clipboard contents to an external URL.
OSCommands - provides simple CLI commands
- Supported commands: *FX, *TV, *Key, *Time, *Quit, *Error, *Set, *SetEval, *Unset, *SetMacro, *Show, *Help, *Go, *Echo, *ChangeDynamicArea, *If.
- Missing commands: *Ignore, *Shadow, *Configure, *Status.
- *Help DynamicAreas will list the state of the dynamic areas.
- *Help supports dictionaries.
ModuleCommands - provides some module commands.
- Supported commands: *RMLoad, *RMKill, *RMRun, *Modules (and *Help Modules), *ROMModules, *RMEnsure.
- Missing commands: *RMClear, *RMInsert, *RMTidy, *Unplug.
- *Help Modules includes text indicating which are internal Pyromaniac modules.
Debugger - provides disassembly SWI and CLI commands.
- Supported SWIs: Debugger_Disassemble, Debugger_DisassembleThumb, Debugger_Flags, Debugger_DisassembleArch, Debugger_DisassemblePlus.
  - Disassembly of FPA instructions is supported.
  - Debugger_Flags is only partially supported and limited flags are supported.
- Unsupported SWIs: Debugger_CPU.
- Supported commands: *Memory, *MemoryI, *MemoryA, *ShowRegs, *InitStore, *DisassembleFlags, *DumpI.
  - *DisassembleFlags will update the flags in the same way as the SWI Debugger_Flags. See *Help DissassembleFlagas for details.
- Missing commands: *Debug, *BreakSet, *BreakClr, *BreakList, *Continue.
- New commands:
  - *Vector shows current vector claimants, or lists all the vectors.
  - *TickerStats shows statistics for the ticker calls (if enabled with ticker.statistics).
  - *Tickers lists the currently claimed ticker routings.
  - *DumpI disassembles a file.
- New SWIs:
  - Debugger_DisassembleArch allows the disassembly of instructions for different architectures.
- *ShowRegs includes information about the exception information:
  - The region is shown for LR and PC.
  - The last abort information from the Kernel is shown.
  - The state of IFSR, DFSR, IFAR and DFAR are shown, if relevant.
  - The disassembly of code leading up to the PC is shown, using the Exception Dump Region if present.
- *MemoryI may display disassembly with colouring if Debugger$Options contains a C.
- *MemoryI supports Thumb and AArch64 disassembly when the T or 6 prefix is used.
EvaluateExpression - provides the implementation of OS_EvaluateExpression.
- Supported command: *Eval.
- May not evaluate the same as the original EvaluateExpression in some cases (particularly unary operators are not as well supported).
- Supported extensions:
  - LEAFNAME, DIRNAME, CANONICALISE - convert argument as a filename
  - TIMEFORMAT - format the current time in a given format
  - INSTR - return the offset of a substring
  - SET - check whether a system variable is set
  - MODULEVERSION - return the version of a module * 100, or -1.
FileTypes - sets up the system variables for the standard filetypes.
FileSwitchCommands - provides many of the commands that were previously within the FileSwitch module, and some that are in FSCommands.
- Fileswitch commands supported: *Cat, *LCat, *Ex, *LEx, *EnumDir, *Info, *Dir, *Back, *Up, *CDir, *URD, *Lib, *SetType, *Run, *Rename, *Spool, *SpoolOn, *Copy, *Count, *Wipe, *NoDir, *NoLib, *NoURD, *Access, *Stamp.
- Fileswitch commands missing: *Shut, *Shutdown.
- FSCommands commands supported: *Append, *Build, *Load, *Save, *Delete, *Remove, *Exec, *Create, *Type, *List, *Print, *Dump, *Close.
- FSCommands commands missing: *Opt.
- New commands: *Help OpenFiles, *Free (previously this was in filesystem modules).
MimeMap - provides translations between different filename formats.
- RISC OS Type (name and number), Media Types, Extensions and Mac Types are supported.
- Wildcard matching on Media Types is not supported.
- Configuration of the MimeMap file is not supported.
SpriteUtils - provides system sprite area and the *ScreenSave command.
- *ScreenSave - saves the screen as a sprite, but a new -native switch allows saving in native format if the graphics implementation supports it. The Cairo implementation saves as a PNG.
- *ScreenLoad - loads the first sprite of a file to the screen.
- *S<command> - system sprite pool commands, most of which are implemented
- *SList - includes information about the sprite's size, depth and mask.
Pyromaniac - provides an interface to the workings of the Pyromaniac system.
- All features of the Pyromaniac module are configurable, to allow the restriction of its operation within the guest:
  - pyromaniacmodule.enable - controls whether any of the module functions are available.
  - pyromaniacmodule.debug_enable - controls whether the *PyromaniacDebug command is usable.
  - pyromaniacmodule.watchpoints_enable - controls whether the *PyromaniacWatchpoints command is usable.
  - pyromaniacmodule.config_enable - controls whether the *PyromaniacConfig command is usable.
  - pyromaniacmodule.config_allow - provides a list of configuration groups are allowed to be accessed. If empty, all groups are allowed.
  - pyromaniacmodule.config_deny - provides a list of configuration groups are not allowed to be accessed. If empty, all groups are allowed. The deny list is checked before the allow list and so takes precedence.
  - pyromaniacmodule.hostcommand_enable - controls whether the *PyromaniacHostCommand command is usable.
  - pyromaniacmodule.hostcommand_cwd_riscos - controls whether the current directory is used for execution.
  - pyromaniacmodule.hostcommand_print_rc - controls whether the return code is printed after execution.
  - pyromaniacmodule.hostcommand_output_encoding - controls whether the output is reencoded in the current alphabet.
  - pyromaniacmodule.hostcommand_ansiescapes - controls whether ANSI escapes in the output will be converted to RISC OS colour operations
  - pyromaniacmodule.urlcopy_enable - controls whether the *URLCopy command is usable.
  - pyromaniacmodule.unixexecutable_enable - controls whether files with the type UnixEx on the native filesystem can be run with the command *PyromaniacUnixExecutable, which is assigned to the runtype for that file.
- *PyromaniacFeatures - displays this document within the emulated system, paged if configured to do so. The document may be viewed in sections for easier viewing.
- *PyromaniacConfig - interacts with the configuration system. Not all configurations will take effect immediately, and some may be destructive to the running environment, so care should be taken. Configurations may be prefixed with -help for information on the group or option.
- *PyromaniacDebug - interacts with the debug system. All debug options should be safe to change whilst the system is running, although some may make the system unusable.
- *PyromaniacWatchpoint - provides a convenience for setting memory watchpoints.
- *PyromaniacTimings - controls the timings and counters interface.
- *PyromaniacHostCommand - executes commands on the host system. Output will be encoded to the current alphabet (controlled by output_encoding), and ANSI escapes can be converted to RISC OS colour operations with hostcommand_ansiescapes.
- *PyromaniacUnixExecutable - runs a native command within the RISC OS environment.
- *URLCopy - allows files to be downloaded from URLs.
OSPointer - limited functionality for the pointer.
- Does not provide pointer operations in the way that it does under Select.
- Provides *Pointer command, and programs a pointer shape when selected. This command was in the WindowManager in RISC OS Classic.
Hourglass - provides a variety of implementations:
- Implementation vdu and console provide text output for the hourglass module's operations.
- Implementation pointer provides a pointer animation in the graphics system.
  - Hourglass percentages are supported.
  - Hourglass LEDs not supported.
Podule - provides a way to load collections of modules from a ROM image.
- RISC OS Select 32bit ROM images and RISC OS 5 ROM images are supported, but it is vital that some modules be unplugged to prevent them from interacting badly with the system.
- *Help Podules gives more information on the loaded ROM images.
International - provides alphabet translations and the selection of BBC fonts according to those alphabets.
BootCommands - provides a few commands command:
- *Do - supported.
- *X - supported.
- *AppSize - supported, by resizing the application space.
- *FreePool - does nothing (no Free Pool dynamic area exists)
- *IfThere - supported.
SysLog - provides the SysLog interfaces.
- Supported SWIs: SysLog_LogMessage, SysLog_GetLogLevel, SysLog_FlushLog, SysLog_SetLogLevel, SysLog_LogUnstamped, SysLog_Indent, SysLog_UnIndent, SysLog_NoIndent, SysLog_ReadErrorMessage, SysLog_LogComplete, SysLog_LogCharacter
- Unsupported SWIs: SysLog_OpenSessionLog, SysLog_CloseSessionLog, SysLog_LogData, SysLog_LogFormatted, SysLog_IRQMode, SysLog_Control, SysLog_Enumerate
- Session logs are not supported.
- Network logging is not supported.
- Configuration of logs is not supported.
- Background flushing of logs is not supported.
- Error messages are just tokens.
- Timestamp format is configurable.
- Default logging directory is configurable.
ColourTrans - provides colour translation operations; see the ColourTrans section.
Zipper - provides SWIs for reading and writing Zip archives.
- Application bound zip handles are not supported.
- Compression level is not configurable.
PyromaniacModes - provides extensions to numbered modes to allow selection of customised numbered modes through configuration (modes.numbered_modes).
Draw - provides path based rendering.
- Supports all the main SWIs, but see the caveats described in the Graphics section.
FontManager - provides user interface to the font system provided by the graphics implementation.
- See the Fonts section for more detail.
SpriteExtend - provides the JPEG rendering SWI calls.
- SpriteV is not handled by SpriteExtend.
- JPEGs are supported:
  - All the information and rendering SWIs are supported.
  - Non-square transformation matrices are supported.
  - Printer driver intercept is not supported.
  - Colour mapping is not supported.
  - Dithering is passed on as antialiasing.
ImageFileRenderPyromaniac - provides an ImageFileRender component for different image formats.
- Non-square transformation matrices are supported.
- Colourmap is not supported.
- The following filetypes are supported: PNG, XBM, WMF, PNM, Targa, BMP, PCX, GIF, ICO, TIFF, WebP, JPEG 2000.
- 3 quality levels are supported.
Squash - provides an interface to decompress content.
- Squash_Compress - not supported
- Squash_Decompress - supported, although its behaviour differs from that of the original module in that output is deferred until the input has been completely consumed.
TimerMod - provides a high resolution timer.
- Timer_Start, Timer_Stop, Timer_Value are supported.
- *TimerStart, *TimerStop, *TimerValue are supported.
- *TimedOS is not supported.
CDFSSoftPyromaniac - provides an interface to access CD data through CDFS. CDFS and CDFSDriver must be softloaded (as must a FileSwitch, as no filing system registrations are implemented within RISC OS Pyromaniac).
CDFSDriver - provides a dispatcher for access to the hardware CD drivers.
CompressJPEG - provides a simple interface to compress bitmap data to JPEGs.
- Basic interfaces supported (CompressJPEG_Start, CompressJPEG_WriteLine, CompressJPEG_Finish)
- CompressJPEG_Comment supported
- CompressJPEG_WriteLineExtended supported
- CompressJPEG_Transcode not supported
ParallelDeviceDriver - provides a stub interface for Parallel port operations.
- Parallel_HardwareAddress - supported.
- Parallel_Op - depends on configured implementation.
- No filesystem support.
- Implementations available:
  - null - tracks state only
  - file - writes to (or reads from) native files
  - socket - connects to a remote server and diverts input and output to it.
ADFS - provides an interface for accessing disc images.
- Only RISC OS 3 interfaces are currently supported.
- Disc images are configurable (adfs.drive#_*):
  - Disc images may be configured for any floppy or harddiscs (0-7).
  - Disc images may take the form of either raw disc dumps, or HDF disc images as used by RPCEmu.
  - Disc image data ranges may be limited within the file (allowing multiple drives in a single file).
  - Disc images may be marked as read only.
- The module will register with FileCore on initialisation, if it is present.
- SWI support:
  - ADFS_DiscOp, ADFS_SectorDiscOp - support depends on reason code.
  - ADFS_MiscOp - support depends on reason code.
  - ADFS_DiscOp64 - not supported.
  - ADFS_HDC - not supported.
  - ADFS_Freespace, ADFS_Freespace64 - supported with fake values (does not call FileCore).
  - ADFS_Retries - not supported.
  - ADFS_DescribeDisc - supported with fake values (does not call FileCore).
  - ADFS_VetFormat - not supported.
  - ADFS_ControllerType - not supported.
  - ADFS_PowerControl - not supported.
  - ADFS_SetIDEController - not supported.
  - ADFS_IDEUserOp - not supported.
  - ADFS_ECCSAndRetries - not supported.
  - ADFS_LockIDE - not supported.
- DiscOp support:
  - DiscOp Verify (0) - ignored.
  - DiscOp ReadSectors (1) - supported.
  - DiscOp WriteSectors (2) - supported (when not read only).
  - DiscOp ReadTrackOrId (3) - not supported
  - DiscOp WriteTrack (4) - not supported
  - DiscOp Seek (5) - ignored.
  - DiscOp Restore (6) - ignored.
  - DiscOp FloppyStepIn (7) - not supported.
  - DiscOp FloppyStepOut (8) - not supported.
  - DiscOp ReadSectorsViaCache (9) - not supported.
  - DiscOp Specify (15) - not supported.
- MiscOp support:
  - MiscOp Mount (0) - supported.
  - MiscOp PollChanged (1) - not supported.
  - MiscOp LockDrive (2) - supported.
  - MiscOp UnlockDrive (3) - supported.
  - MiscOp PollPeriod (4) - not supported.
  - MiscOp EjectDisc (5) - supported.
  - MiscOp ReadInfo (6) - not supported.
  - MiscOp ReadStatus (7) - supported (always returns unlocked).
ShareFS - Stub module which tracks the status of the discs that are shared.
Freeway - Stub module which tracks the status of the objects that are shared.
ResourceFS - Tracks the registrations of resources.
- SWIs supported:
  - ResourceFS_RegisterFiles - supported
  - ResourceFS_DeregisterFiles - supported
- Does not provide a filing system.
- *ResourcesFS_List will list the files that have been registered.
InetServices - module providing information about Internet services.
- Supported SWIs:
  - InetServices_GetServiceByPort - supported
  - InetServices_GetServiceByName - supported
  - InetServices_DecodeError - supported
  - InetServices_GetServicesMenu - supported
Speak - Provides text to speech synthesis (Jonathan Duddington API).
- All SWIs are mostly supported, but features may vary between implementation.
- Language and voice variant are not properly supported.
Speech! - Provides text to speech synthesis (Superior Software API).
- Most SWIs are supported.
- Uses the same implementations as the Speak module.
WebColours - Provides a conversion between different forms of colour specification used on the Web.
GPIO - Provides an interface to allow access to GPIO pins, with different implementations. See the 'Devices (I/O access)' section for more details.
RTCHWDS1307 - Provides an implementation of the RTC through the IIC DS1307 chip. This device may be provided by the internal IIC implementations.
RTCHWDS3231 - Provides an implementation of the RTC through the IIC DS3231 chip. This device may be provided by the internal IIC implementations.
RTCHWPCF8563 - Provides an implementation of the RTC through the IIC PCF8563 chip. This device may be provided by the internal IIC implementations.
RTCHWPCF8583 - Provides an implementation of the RTC through the IIC PCF8583 chip. This device may be provided by the internal IIC implementations.
PyromaniacWimpDebug - Experimental module for tracking Wimp tasks and messages.
TimerManager - Provides registration of 'hardware' timer handlers.
PyromaniacGit - Provides an interface to the host 'git' command.
- Git operation is modelled on the same commands and syntax as the original, passing through to the host commands.
- *Help Git gives information on the commands supported.
- *Git help <command> describes the syntax supported for each command.
- Commands taking filenames are translated from RISC OS format to native format.
- Environment variables are mapped to RISC OS style variable names.
  - *Help GitVariables describes the variables and their mapping from the standard format.
  - Variables holding paths are translated from RISC OS format to native format.
  - Variables holding lists of comma-separated paths are translated from RISC OS format to native format as colon-separated paths.
- Transformations will be performed where possible on the git inputs and outputs:
  - Output from the git commands will be displayed in the RISC OS alphabet, with ANSI colour operations converted to RISC OS VDU operations.
  - Author and committer names in environment variables are translated from RISC OS alphabet to UTF-8.
  - Commit messages in files will be translated from the RISC OS alphabet to UTF-8.
  - Remote and branch names will be translated from the RISC OS alphabet to UTF-8.
  - Filenames in the command output are not translated to RISC OS format.
  - User configuration is not supported, although it can inherit from the host system.
- Authentication with a remote server can be performed through the console input.
  - Credentials can be configured to be stored in a file on the RISC OS file system with the variable Git$Credentials$Store (pyromaniacgit.credential_store_filename).
  - Credentials can be configured to be stored in a file on the native filesystem (pyromaniacgit.credential_store_native_filename).
- Commands supported:
  - add - Add file contents to the index
  - annotate - Annotate file lines with commit information
  - blame - Show what revision and author last modified each line of a file
  - branch - List, create, or delete branches
  - checkout - Switch branches or restore working tree files
  - cherry-pick - Select changes from another branch
  - clean - Revert working directory to a clean state
  - clone - Clone a repository into a new directory
  - commit - Record changes to the repository
  - describe - Give an object a human readable name based on an available ref
  - diff - Show changes between commits, commit and working tree, etc
  - fetch - Fetch from another repository or a local branch
  - grep - Search for strings
  - help - Display help for a given command
  - init - Create an empty Git repository or reinitialize an existing one
  - log - Show commit logs
  - merge - Merge branches onto the current branch
  - mv - Move or rename a file or directory
  - pull - Fetch from and integrate with another repository or a local branch
  - push - Push changes to remote repository
  - rebase - Rebase branches onto the current branch
  - reflog - Manage reflog information
  - remote - Manage repository mapping
  - reset - Reset current HEAD to the specified state
  - restore - Restores files
  - rev-parse - Pick out and massage parameters
  - rm - Remove files from the working tree and from the index
  - show - Show various types of objects
  - shortlog - Summarize 'git log' output
  - stash - Stash the changes in a dirty working directory away
  - status - Show the working tree status
  - switch - Change current branch (use checkout if not supported by host git tool)
  - tag - Create, list, and delete tags on objects
  - version - Report the version of git on the host and RISC OS system
- Notable commands not supported (incomplete list, with workarounds where necessary):
  - worktree - Manage multiple working directories from a single repository
  - submodule - Manage inner module relationships
  - notes - Manage notes
  - bisect - Bisect failures to a commit
OwnerBanner - Provides the system startup banner.
VideoTTX - provides an implementation of the VideoV teletext display.
- Arbitrary mode sizes are supported.
- Text rendering and updates are supported.
- Update deferral is supported, but not controllable by VDU sequences.
- Flashing cursor is supported.
- Scrolling is supported.
- Conceal/reveal is supported.
- Flashing is supported.
- Double height text is supported, but only for fully double height (partial characters are not supported).
- Corrected characters are supported, although still may not match the correct characters from the character set.
- Contiguous and separated graphics supported.
- Font is the standard RISC OS font.
- High resolution setting has no effect.
- Hold graphics are not supported.
- Black background configuration is not supported.
ImpressionSpell - provides spell checking interface, supporting different implementations: null, wordsfile.
- Wordsfile uses simple lists of words from the host, like /usr/share/dict/words:
  - File to use may be 'none', 'auto' or an explicit native filename, or a RISC OS filename. (spellwordsfile.native_filename, spellwordsfile.filename).
  - Typo only returns a match or not.
  - Anagram only returns exact anagrams of the word, not subgrams (spellwordsfile.anagram_algorithm).
  - Fuzzy applies the SoundEx algorithm to match words. Algorithm is itself configurable (spellwordsfile.fuzzy_algorithm)
- User dictionaries are supported, although the file format may not be exactly that of Impression's dictionaries.
  - Adding, removing and checking words are supported.
  - Loading and saving dictionaries are supported.
  - Converting dictionaries to word lists and vice-versa is supported.
  - Browse window is not supported.
  - Miscellaneous operations only really supports the version and count of reason code 0.
  - Impression integration SWIs are not supported.
- Ignore dictionaries are supported.
PathUtils - provides the path variable manipulation SWIs and commands.
FanController - provides a registration and management interface for fan drivers. API documentation for the FanController is provided alongside the installation.
WimpSpritePool - provides the sprite pools used for icon and tool sprites, together with the *Commands. See the Desktop section.
WimpCommands - provides some commands which would usually be handled by the WindowManager.

64 bit support

AArch64 emulation is supported through configuration (emulation.implementation).
Memory is only 32 bit.
- Whilst registers are 64bit wide, no memory above 32bit is supported.
Privilege modes are partially supported:
- Internally, SVC, UND and ABT will go to EL1; USR will go to EL0, IRQ will go to EL2 (although the memory map is unchanged).
SP alignment will be 16 bytes, where possible.
Exception handlers partially supported:
- Abort handlers don't necessarily report the correct addresses, although backtrace should be accurate.
SWIs are supported through SVC #0, with SWI number in x10, registers passed in x0-x9 and returned in x0-x9.
Disassembly and trace supports disassembly of AArch64 by default.
Modules are supported.
- Module base addresses will be aligned to page + 4 bytes.
- Module flags have the AArch64 architecture type set.
- Module initialisation should have bit 30 (architecture present) set.
- Module flags may include bit 2 to indicate zero-initialisation is present.
- Module SWIs and services will be called with x0 pointing to a 10 register block (in 32bit terms).
- Modules will be loaded into a dynamic area 'Module area', distinct from the RMA.
SWI calls are mostly compatible, with a few differences for flags:
- In general, a return in the C flag is now returned in the register X0 or X1, depending on the interface for the SWI.
- Documentation for each of the SWI changes can be found in the PRM section of the Pyromaniac documentation.