There are three kinds of personal open source projects:

  • projects that address a real problem,
  • projects that were made to be put on a portfolio, and
  • projects that serve to facilitate learning.

Most of my projects land in the “real problem” or “learning” category, but I dislike publishing them unless they are presentable.

Following through with proper execution is hard. Most effort in a software project isn't the programming, but the research, testing, documentation and packaging that's necessary to move from a throwaway hobby project to a shippable product others can use.

For a full list of my public projects, take a look at my GitHub.


Gcovr generates code coverage reports with GCC or Clang.

I didn't start the project, but acted as maintainer from 2018 to 2022. This allowed me to get experience which otherwise wouldn't be available to me:

  • Coordinating multiple contributors, and responding to bug reports from users. My other open source projects are all solo affairs and don't really have users. Gcovr was a very relaxed introduction into “people things” for me. It helped that there isn't any kind of looming deadline, and things just happen at the pace that they happen.

  • Working on a legacy codebase late in its life cycle. Gcovr was a bit untidy (and still is, to a degree). Refactoring the project, making it more approachable, and fixing bugs is something I actually enjoy doing.

Perl Projects

For a long time, Perl was my primarily language. It also started my experience with Open Source contributions.

This started with my Util::Underscore module in 2014, a convenient collection of various helper functions. In 2017, I was more active and created a Dist::Zilla plugin bundle, an Async::Trampoline module that isn't actually async but helps avoid deep recursion (and features components written in C++), and the Data::ValidateInterdependent module that combines the idea of "static single assignment" with complicated validation pipelines.


  • released: 2017
  • languages: Python, Bash, C++, Go

A tool/workflow to generate batch jobs with various configurations and execute them on a cluster via GNU Parallel. This tool was developed for evolutionary algorithm research. read more


  • released: 2019
  • GitHub:
  • language: Rust

Another tool for evolutionary algorithm research. The tuning tool combines an evolutionary technique with Bayesian techniques like Gaussian Process Regression. This project has its origin in my Bachelor's thesis, and was later presented as a poster at GECCO 2020 (see my research).

This was my first larger Rust project.

Unfortunately, since then bitrot has set in, and it is difficult to get it to compile with newer OpenBLAS versions. There's also something wrong with the test cases – the software no longer converges properly onto solutions. But so much time has passed that I can no longer confidently debug the mathematics.


Zettel is the codename for my personal note taking system, essentially an Obsidian clone. It is a large-scale Rust application with a browser-based frontend that uses a Vue single-page application. I've mentioned some additional details in my programming language list.

Unpublished projects

Various other unpublished or unreleased projects include:

  • The Perl module MarpaX::Grammar::Preprocessor, a syntax extension for Marpa::R2 SLIF grammars. Status: mostly ready for a release, but requires more design for a blocking feature, some refactoring, and another quality focus. It should already be usable as alpha software.

  • The Perl module MarpaX::DSL::InlineActions a predecessor or MarpaX::Grammar::Preprocessor. It was a far more ambitious project to offer a completely separate interface to Marpa::R2, but I lost interest while I was trying to port it to the low level Marpa API. It should be somewhat usable for prototypes, but not for production-grade parsers.

  • A text templating language, roughly imitating Liquid. I took multiple shots at this. The MarpaX::Grammar::Preprocessor was a spin-off from the first attempt. However, I found that I would need a deeper understanding of language implementation techniques to proceed. The second attempt used more Mustache-like semantics, and actually works (it powers the layout for this blog). Unfortunately, it's rather slow (using a recursive descent/Marpa hybrid parser), and is in no shape to be made public. Async::Trampoline was a spin-off from the parser.

  • A lightweight markup language, similar to Markdown but with a richer semantic model and with extensibility in mind. Markdown (as standardized by CommonMark) lacks many crucial features which I need for nontrivial articles on this website or as a LaTeX substitute in my studies. ReStructuredText has an attractive semantic model, but braindead syntax (you cannot nest inline syntax, and block syntax has the uglies). I currently use Pandoc which adds many missing features like tables and mathematics to Markdown, without addressing the underlying issue around extensibility. I have attempted a sketch at a solution so often that it's now almost a hello-world program for me. I have tried attempts in Perl, C++, Haskell, Python, and Rust. For a while, this page was compiled with a Rust-based prototype!

  • Some toy languages to learn about interpreter implementation. I used Perl and Golang as the host languages.

If you want to take a look at these projects or need some help with them, please contact me.