Technology stack

Many technologies are discussed in the ROUGOL talk, both those that are used, and which were created or updated during the project. Some of these technologies are available to the public. The technologies that were used for a project are always interesting.

2020Source control management

I use a self-hosted GitLab on my own server. It's got some publicly accessible parts, but most is private.

2020Cross-compiling toolchain

To build my own RISC OS components on modern systems, I needed to port the Norcroft compiler and the related toolchain to work on 64bit Linux and macOS.

2020Rosetta Code extraction tool

To test the compiler, I needed some C code. I built a tool that would allow me to download all the example code from the Rosetta Code website.
Open source: Rosetta Code Parser

2020Software repository

I use Artifactory for storing software components.

2020Docker RISC OS development environment

I created a small RISC OS docker containers for use building RISC OS components, using the cross-compiling tools.

2020Automated testing internally

I use GitLab CI triggers on every change. This pulls resources from Artifactory, builds, then pushes results up to Artifactory.

2020/2021Automated build and testing for others

I built JFPatch-as-a-service as an aside to make it possible for others to build RISC OS components online.

Update (2021): Updated to the most recent version of Pyromaniac, and has fixes for various tooling problems.

The system itself uses a number of technologies:


Parsing YAML using the common YAML parser would mean requiring an external module - and one that would require compiling. I created a more limited and easy to drop in parser.
Open source: SimpleYAML parser


I have needed a way to run commands in the background and collect the output in a safe way, a few times. For JFPatch-as-a-service, and for host commands in Pyromaniac, the StreamedInput module provides the interface to the command systems.
Open source: Streamed input library

2020Build client for JFPatch-as-a-service

The robuild-client is a client for Linux, macOS and RISC OS which can submit sources to JFPatch-as-a-service for building.

Open source: robuild-client

The client itself is based on a 3rd party JSON library, and a 3rd party WebSockets communication library, both of which I ported to RISC OS for this tool.

2020/2021Presentation tool

To present the talk, a presentation tool was created to run on RISC OS. This used a number of technologies:

2020OSLib parser

OSLib provides definitions for many of the RISC OS interfaces in a well structured way. I needed a way to parse OSLib files so that I could use the definitions, and the OSLib code itself does not lend itself to being re-targetted.
Open source: OSLib parser

2020/2021RISC OS Alphabets for Python

RISC OS Alphabets are not quite the same as the international standards, so I have codec modules created for the RISC OS Alphabets.
Update (2021): Alphabets now include those for the Selwyn, Sidney and WIMPSymbol fonts.

2020/2021Non-RISC OS editor syntax modes

Editing RISC OS files on non-RISC OS systems means not having context colouring, which is sad, so I created some colouring definitions.
Update (2021): Both syntax modes now have improved matching for tokens, variables and numbers. Shouldn't be quite so confused by compressed BASIC.

2020/2021Hourglass maker

I wanted to create an hourglass module. Before I did so in Python, I created some modules in assembler. But in a nice generic way so that I could turn any image into an hourglass.
Update (2021): The repository contains an experimental percentage and bar. The Cog mdoule has been included here to demonstrate the new module.

2020/2021Tests for RISC OS APIs

Some of the test for Pyromaniac are available for others; or for others to submit more.
Update (2021): More test updates from Pyromaniac including the addition of tests for the Internet module.

2020/2022Documentation system

As part of the work I was doing, I had to document some APIs, so I resurrected the PRM-in-XML templates.
Release: PRM-in-XML example files (89K)
Update (2022): The PRM-in-XML examples repository is now publicly available, together with the staging repository which contains many documents and functional specifications. The PRMinXML tool itself is also available.
Open source: PRM-in-XML tool

2020Tun-Tap JSON server

For testing the network stack with Ethernet drivers, I needed a way to connect multiple clients together. I created a simple TCP service which clients can connect to, which distributes Ethernet frames. The service can be attached to a tap, and thus bridge on to real networks.
Open source: Tun-Tap JSON server

2020Toolchain updates

Some parts of the toolchain were updated, although there's not a lot to say about them.

I created analogues of the RISC OS copy, wipe and destroy tools so that I could build on RISC OS and Unix systems in the same way.

I needed a BASIC tokeniser so that I could handle storing files in git sensibly, and editing them on other systems. The tokeniser needed to be able to run on RISC OS and other systems, and I didn't want to compile anything. The code I'd previously written for HdrToH was a good starting point.

2020Changelog management

For my own use I wanted to manage the changelogs in a better way - particularly avoiding conflicts when merging branches.

2020/2021/2022Examples of the use of RISC OS APIs

Example programs show how the interfaces can be used.
Update (2021): Font_Caret and Font_Paint examples updated, together with the Portable module.
Update (2022): New examples for IIC and GPIO interfaces.

2021Font string qualifier parser

To make sure that the font qualifiers are processed properly, the parser was implemented in a separate module. This allows it to be tested more easily.

2021Font control code parser

Like the font qualifier parser, the control code parser was implemented separate module and tested to make sure that it was working properly.

2021XML2 library port (XMLLint)

Back in the early 2000s the XML2 library was ported for use with the PRM-in-XML project. This port has been brought up to date with the latest version.
Open source: LibXML2 for RISC OS

2021XSLT library port (XSLTProc)

Back in the early 2000s the XXLT library was ported for use with the PRM-in-XML project. This port has been brought up to date with the latest version.
Open source: LibXSLT for RISC OS

2021DebugIt module

David Thomas was trying to debug the WindowManager, so I dug out my old DebugIt module which writes to SysLog.
Open source: DebugIt for SysLog

2021StrongHelp manual extractor

I needed to read some StrongHelp manuals, so obviously I wrote an extraction tool in Python, rather than run the application on RISC OS.
Open source: StrongHelp extractor

2021VNC server for Cairo surfaces

To make it possible to share the RISC OS Pyromaniac interface with others, a Python library was created to allow the Cairo surface to be served over VNC.

2022StrongHelp manuals

Long ago, I produced a StrongHelp reference manual for RFCs. The manual has been rebuilt from the previous scripts and released as an open source repository.

2022Version management

In ancient days in other lives, long past, but not forgotten, there was a script called 'srccommit'. This was used to commit code to the CVS repositories used at Acorn, together with updating the necessary VersionNum files which tracked components. At RISCOS Ltd, I created a 'commit' script which worked in a similar way. This script is still available on my site. With the advent of git, there's less need to manage committing in as structured a way. But managing the VersionNum files is still important. The 'vmanage' script can do this (for C, assembler, and BBC BASIC).

2022Joystick driver

I made one of my old Joystick modules available as open source. This was a simple interface to an Atari 9-pin joystick, using the parallel port.


Following some discussion of the very limited interface for customisation of buttons in RISC OS 5, I open sourced my example IconBorders modules from the original SDK. The example module includes documentation on the API used. An additional 'fob' module was also released which demonstrates a slightly different style of buttons.

2022Portable module

During development of RISC OS Select it was expected that there would be portable devices coming from hardware manufacturers. As I did not want to have more assembler code being written, and to make it easier to work with the modules, a prototype Portable module was created in C. This module just needs a few functions replacing to perform as expected. I realised this module as I was seeing a few portable devices appearing, and I assumed it unlikely that any work had gone in to making maintainable modules for them.

2022Jan Vibe graphical ditties

Jan Vibe wrote some great BASIC programs that demonstrated many features of the graphics system. They were a great test to exercise rarely used interfaces and provide examples of how the systems should work.

2022FanController stack

The FanController stack is small - a controll and a number of drivers. I created the modules to make it easy to add controls for hardware fans. The open source repository contains both the source for the FanController and an example module that you can use for your own hardware.
Open source: FanController stack

2022RISC OS build service examples

The example code used in the RISC OS build service is available as a separate repository which may be easier to browse.

2022RISC OS-like file explorer in WxPython

The WxWidgets user interface in RISC OS Pyromaniac provides an explorer for the files in the emulated system. This file explorer isn't actually specific to RISC OS Pyromaniac, although that's where it was written for. The implementation is generic enough that it can be used as a separate interface to a real filesystem, or to a virtual filesystem in a similar manner to Pyromaniac.

2022Memory dumper

The memory dump code used by RISC OS Pyromaniac is used by the *Memory implementation in Debugger, and the tracing code. To make it easier to work with, debug and maintain, the dumping code has been extracted into its own library. This library comes with a WxPython frame implementation as well.

2022RISC OS style disassembly in Python

The disassembly in RISC OS is performed by the Debugger module, and uses the original form of ARM assembler mnemonics. The layout of the instructions has changed over time, but Debugger remained the same. RISC OS Pyromaniac uses Capstone as its disassembler, but this produces the modern ARM format. This library converts from Capstone's format to the RISC OS format. It also handles the FPA instructions.
Open source: Disassembly in Python

2022RISC OS context mangling

In RISC OS there are many interfaces which enumerate data items. These interfaces generally use a 'context' value which is initially 0 and the enumeration terminates when the 'context' becomes 0. The meaning of the context is opaque, and should not be assumed to be manipulable by the user. However, people have done this, and it causes things to break. In RISC OS Pyromaniac the context value can be mangled so that it returns non-linear values, to shake out these cases. The implementation was extraced to this separate library so that it can be updated and tested more easily.
Open source: GBPB context mangling