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.

Source control management

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

Cross-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.

Rosetta 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

Software repository

I use Artifactory for storing software components.

Docker RISC OS development environment

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

Automated testing internally

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

Automated 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.

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

Build 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.

Presentation tool

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

OSLib 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

RISC 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.

Non-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.

Hourglass 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.

Tests for RISC OS APIs

Some of the test for Pyromaniac are available for others; or for others to submit more.

Documentation 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)

Tun-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

Toolchain 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.

Changelog management

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