Projects
The following is a list of projects I’m working on, or have worked on.
Background
I am a strong believer in free and open source software, especially software which is permissively licenced or weak copylefted. Hence, all the code I write I release open source. Software which I believe doesn’t have the potential to be used in commercial applications, or which I feel doesn’t need any upstream contributions, I release under the permissive ISC licence (basically MIT minus outdated wording). Software I believe is potentially useful for commercial users I release under the MPL 2.0, a weak file-level copyleft licence that’s easy to comply with. The MPL I believe is a fantastic licence that allows me to balance the goals of allowing wide-scale commercial usage, while also encouraging these commercial users to contribute improvements back to the upstream codebase.
Active projects
TaMaRa
Category: Computer engineering/EDA
Licence: Mozilla Public License v2.0 (weak copyleft) (not yet released, however)
TaMaRa is an automated Triple Modular Redundancy EDA flow for the open-source Yosys EDA tool to protect FPGAs and ASICs from Single Event Upsets in spaceflight and other harsh envionrments. There is some existing literature in this area, but TaMaRa is unique in that it’s integrated into Yosys directly, and has an extensive test suite using a combination of manual tests, formal verification and RTL-fuzzing techniques.
In further detail, copied from my thesis’ description:
An automated triple modular redundancy EDA flow for Yosys
For safety-critical sectors such as aerospace and defence, silicon ICs and FPGA gateware must be designed to be fault tolerant in order to mitigate the effects of Single Event Upsets (SEUs) triggered by ionising radiation. One common fault-tolerant design technique is Triple Modular Redundancy (TMR), which mitigates SEUs by triplicating key parts of the design and using voter circuits to select a non-corrupted result if an SEU occurs. Typically, TMR is manually designed at the HDL level. However, this approach is an additional time-consuming and potentially error-prone step in the already complex design pipeline. Instead, I propose TaMaRa: a novel fully automated TMR flow for the open source Yosys EDA tool. TaMaRa will accept any Yosys-compatible HDL input, and use graph theory algorithms to synthesise a TMR netlist. I will also use a combination of formal methods and simulation to prove the correctness of the TMR flow.
I will be working on TaMaRa through to about July 2025. The plugin is written in C++20. When it’s finished, TaMaRa will be available under the permissive Mozilla Public License v2.0, and the papers under CC-BY (n.b. the code licence is already approved by my supervisor, but I need to check on the papers).
The code is currently unavailable while I work on it, but rest assured will be released when it’s done. One of the key elements of this project is making an end-to-end solution that’s available to the wider open-source EDA community, so a public release is essential. I am also planning to write a journal article or conference paper about TaMaRa, and possibly attend a conference too if I’m able!
Slingshot
Category: Computer engineering/EDA
Licence: Mozilla Public License v2.0 (weak copyleft)
Slingshot is a language server for the SystemVerilog hardware description language, with a focus on accurate multi-file completion. The overarching goal is to make SystemVerilog as intuitive to edit as C++ or Python. Slingshot is written in Kotlin and runs on a Java 17 JVM or higher. In the past, it was also written in Rust, although I ended up rewriting it in Kotlin due to problems with ANTLR and problems with concurrency (no fault against Rust, I just don’t know how to write the language lmao).
Compared to other SV LSPs, the main feature that Slingshot brings to the table is a powerful completion system, backed by ANTLR, that supports multi-file projects through automatic indexing. Slingshot also supports instant linting, backed by Verilator.
At the moment, my time to work on Slingshot is limited, but I still consider it to be an active project. The next upgrade will be rewriting the parsing system away from ANTLR, as its error recovery has issues that makes it not suited for writing an LSP server. My current method to achieve this will be slangd, a gRPC daemon for the Slang SystemVerilog frontend, which is one of the highest quality around. Another option is to rewrite the server (again…) in C++, but the C++ LSP library ecosystem is severely lacking - so I’ll either need to yoink clangd’s, which is tied to LLVM, or hack on an existing library.
Kural and EDTear
Category: Data and optimisation
Licence: ISC (permissive)
Kural and EDTear are each respectively tools I have written in Rust to compute optimal trade routes, and collect trade data, for the video game Elite: Dangerous. EDTear records data from EDDN, which is basically a large ZeroMQ relay for E:D users. I record this data and insert it into a PostGIS enabled PostgreSQL database. Kural connects to this database, and uses integer linear programming to solve large-scale (i.e. galaxy-wide) instances of the bounded knapsack problem to compute optimal cargo hold layouts.
EDTear stands for the “E:D Trade Ear” (inspired by bear, the Build Ear), and Kural is named after the Tirukkuṟaḷ, an ancient Tamil language text that may be the first documented discovery of supply and demand.
View my blog for more details →
Past projects
musicvis3d (2024)
Category: Computer graphics
Licence: ISC (permissive)
This is a semi real-time 3D audio visualisation using OpenGL. The visualisation consists of offline spectral data that is rendered in real-time in the form of 3D bars. A multitude of graphics techniques are used, including: quaternion camera animation, camera shake using Simplex noise under fractal Brownian motion, a skybox, and a post-processing stage that implements chromatic aberration. The application is written in a mix of C++ (for rendering) and Python (for DSP). The spectrum of bars is computed using the Fast Fourier Transform.
I implemented this for the course COSC3500 at UQ, in 2024.
Hermes/Atlas (2023)
Category: Computer graphics, data and optimisation
Licence: Mozilla Public License v2.0 (weak copyleft)
Hermes/Atlas is a custom simulator and 3D renderer for Brisbane’s public transport network. It was written for our DECO3801 capstone group project during my BCompSc degree at UQ, in 2023.
I was responsible for the renderer (“Atlas”), which is built on top of the libGDX framework in Kotlin. The main features of Atlas are:
- Multi-threaded rendering architecture that allows for efficient streaming of network resources (OpenStreetMap raster tiles) without blocking
- Dynamically queries and extrudes PostGIS building polygons into plausible 3D building models
- Optimisations: distance culling, frustum culling, 2-tier LoD system
- Custom garbage collected cache data structure for managing a large number of map tiles efficiently
- First-person camera controller
- Cross-platform: Windows, Mac and Linux
- I was also responsible for Dockerizing and importing offline OpenStreetMap data
Visited the Hermes/Atlas repository →
Open-source contributions
I’ve had a few minor contributions to open-source projects over the years, listed here.
2025
2024
- I patched Intel’s media-driver to fix a segfault bug.
- I fuzzed Yosys in a Docker container, which uncovered a bug, that I should submit a patch for (but have not had time yet!)
- I contributed new game features to edsm-dumps-model, a Rust Serde model for Elite: Dangerous Star Map JSON dumps. This was done as part of the Kural/EDTear project.
2020
- I contributed documentation improvements to the rcsoccersim user manual.
2018
- I improved exception handling in jwalkable