Having spent an overly long day working on packaging OpoLua, Friday proved a slow one, with little visible progress: I took some time to plan out the remaining work to ship OpoLua; added Thursday’s binary Arch builds to the releases¹; and tidied up the repository a little. Good work, but unexciting.

Without a doubt, the highlight of the day was this screenshot from Alex, host of the Psion Discord and maintainer of Haiku’s MAME package:

I continue to be amazed by how portable Qt is, and there’s little better in life than a Haiku screenshot.

Continuing with my goal of trying to ship the Qt variant of OpoLua—our modern OPL interpreter—for macOS, Windows, and Linux, I spent much of the day diving into the ugly world of Linux packaging. To make things a little more palatable, I also treated myself to a small update to Reconnect, my Psion connectivity suite for macOS.

OpoLua

My primary focus for the day was to set up Linux smoke-test builds to ensure that we don’t unintentionally break builds on the platform. Having already figured out how to build on Ubuntu, setting up automated builds proved easy—a matter of adding a GitHub Actions job to the workflow, and crafting a lightweight build script. I continue to be impressed by Qt’s tooling, which reduces builds on almost all platforms to:

qmake6
make

Spurred on by a quick win, and lulled into a false sense of security, I decided to try tackling packaging for Ubuntu. When I’ve built Debian packages in the past using the standard tooling, I’ve been frustrated by the need for distro-specific directory structures so, to avoid polluting our source tree, I decided to look for an alternative. This took me to fpm or ‘Effing Package Management’, a multi-distro packaging tool which proved incredibly powerful, allowing me to generate a .deb from the directory output of Qt’s make install using a single command:

ARCHITECTURE=`dpkg --print-architecture`
fpm \
    -s dir \
    -t deb \
    -p "opolua-ubuntu-24.04-$ARCHITECTURE-$VERSION_NUMBER-$BUILD_NUMBER.deb" \
    --name "opolua" \
    --version $VERSION_NUMBER \
    --architecture "$ARCHITECTURE" \
    --description "Runtime and viewer for EPOC programs and files." \
    --url "https://opolua.org" \
    --maintainer "Jason Morley <[email protected]>" \
    --depends libqt6core6 \
    --depends libqt6gui6 \
    --depends libqt6widgets6 \
    --depends libqt6multimedia6 \
    --depends libqt6core5compat6 \
    --chdir "$INSTALL_DIRECTORY" \
    .

(You’ll notice I’m getting the architecture with dpkg --print-architecture—using ARM and Intel runners with GitHub Actions matrix builds, the build script can output releases for both architectures.)

I shared the builds with a few members of the Psion Discord, and Colin kindly sent me a couple of screenshots of OpoLua running on Kubuntu—it’s a real reward to see others using our creation.

Jumpy! is a wonderful showcase for OPL

While there are still many different Linux distributions and versions to add to the build script (and I’d like to set up an apt repository to ensure folks can get automatic updates), I’m pretty pleased with this progress.

… But I couldn’t leave it there. I decided to try tackling Arch Linux—a distro I’ve little experience of. Starting this at 10pm was perhaps a poor choice. fpm did its job well, and I able to change a couple of flags and output a pacman binary package, but Alex quickly dissuaded me of the notion that this was good enough: binary packages are (understandably) frowned upon in Archland and PKGBUILD source builds (distributed via AUR) are preferable as they increase transparency.

PKGBUILD configuration files seem mostly well designed and, with Alex’s help, I was able to craft something that worked. The big challenge was how Git submodules are (or aren’t) handled: while there’s good support for Git, there’s absolutely no support for submodules—you have to manually recreate these in your prepare. For a project like OpoLua that relies heavily on recursive submodules, this is a miserable experience. makepkg (which processes PKGBUILD files) will check out each submodule at the top-level, and you have to rewrite all the submodule urls from the bottom up:

prepare() {

    cd "$srcdir/opolua"
    git submodule init
    git config submodule.LuaSwift.url "$srcdir/LuaSwift"
    git config submodule.diligence.url "$srcdir/diligence"
    git config submodule.scripts/changes.url "$srcdir/changes"
    git config submodule.scripts/build-tools.url "$srcdir/build-tools"
    git -c protocol.file.allow=always submodule update --recursive

    cd "$srcdir/opolua/dependencies/LuaSwift"
    git submodule init
    git config submodule.Sources/CLua/lua.url "$srcdir/lua"
    git -c protocol.file.allow=always submodule update

}

I’ve yet to work out how to synthesize per-release versions of the PKGBUILD file, or how to get those into AUR, but it’s good to have broken the back of this.

Reconnect Menu

While Apple’s Liquid Glass is incredibly divisive and widely derided (I personally dislike it), I’m keen for my apps to feel at home on the system—I don’t want to add to users' cognitive burden by rejecting platform choices. With that in mind, I’ve been slowly adopting the new menu icons, and I took a little time to add them to the Reconnect menu bar menu:

It’s not clear to me that this is an improvement—there’s a recent piece over at tonsky.me that captures many of the issues—but it’s where things are going. Perhaps I’ll use this investigation by Brent Simmons to give users a choice.

Having spent the first couple of days of the week bashing my head against Windows and GitHub Actions workflows, I decided to take a ‘break’ to focus on nailing down the licensing for OpoLua—it might not be glamorous, but it’s a necessity when shipping software in today’s world. Thankfully that didn’t take the whole day, so I was able to try out OpoLua Qt on Linux for the first time, and even squeeze in a little Psion-related fun. I also found myself returning—however briefly—to Game Play Color, my semi-retired JavaScript Game Boy emulator.

Re-licensing OpoLua

Qt’s licensing mandates that any software linking the Qt libraries be licensed GPLv2 or Later for non-commercial access to the library. Keen to keep the more permissive MIT License where possible, I’ve re-licensed just the Qt app under GPL2 or Later and updated our documentation to be far more explicit about the project’s components and licenses: the Lua code which provides the OPL runtime remains MIT licensed, as does the iOS app. You can read all the gory details on the website. This represents a significant milestone in officially shipping OpoLua Qt: we can now do so legally. 🥳

Desperate for a change of scene, I also spent a little time setting up an Ubuntu VM and getting OpoLua Qt building on Linux—Ubuntu’s status as the only GitHub Actions Linux runner makes it a natural first choice for automated builds. Once I realized qmake has been renamed to qmake6 on Ubuntu, I was happy to find everything just worked:

It’s incredibly exciting to see OPL running in so many places

Psion eBooks

After a morning of licenses and administration, I treated myself to a side-quest back into the world of Psions to explore another way that my Psion might offer daily utility: since letting my Kindle go (I’m exhausted by the modern trend of personal devices becoming marketing vehicles and storefronts), I’ve not had any digital reading solution and, recalling using a reader program for the Series 3c many years ago, I decided to fix that. Thanks to some help from the Psion Discord, I rediscovered eTxtReader:

Haruki Murakami’s Birthday Girl in eTxtReader on a Series 3mx

I used Calibre to convert some existing books to text files. They required some further massaging to translate from Unicode to ASCII (you’ll see some strange characters if you look closely at the photo above) and, with this secondary pass, everything worked perfectly:

eTxtReader is a really impressive program, barely breaking a sweat when viewing multi-megabyte files on a device with at most 2MB RAM—a must for the modern Psion user.

Game Play Color

Earlier in the week I received very short notice that Netlify is ending the platform I’ve been using to host Game Play Color. Not ready to let it go just yet, I decided to move to GitHub Pages. Fortunately, as a static site, it was a pretty easy process, and I was able to integrate it into the existing GitHub Actions workflows. (You can see the change here if you’re interested in the details.)

Game Play Color up and running with different hosting

At some point, I imagine I’ll let gameplaycolor.com go and continue my consolidation on jbmorley.co.uk subdomains—it just doesn’t make sense to continue paying for so many domain names.

With OpoLua Qt macOS and Windows builds complete and available for folks to download, I now have to decide how many of the remaining tasks need tackling before moving onto other projects (and perhaps even feature work). The remaining OpoLua Qt housekeeping I have in mind is:

• Update website:
  • download links
  • screenshots
  • documentation
• Set up Linux smoke test CI builds
• Consolidate shared resources in the source tree

This feels like more than I’ll manage in the remaining coupe of days this week (which are also being filled with various bits of immigration paperwork), so I’ll do what I can. Providing a clear download link for OpoLua Qt on the website feels like the highest priority, followed by a Linux smoke-test build to ensure we don’t unintentionally break those builds during development.

Since this kind of work doesn’t light up my creative and coding brain that much, I might also allow myself a small segue into tidying up a few aspects of Reconnect, my Psion connectivity suite—it’s a tool I use daily, and small quality of life improvements there have an outsize positive impact—self-care for the retro software engineer if you will.