I started out coding in 2012 while still in school. Most of my first projects (a lot of them being 2D RTS games) were games as they allow you to experiment with lots of different areas of computer science (rendering, networking, multithreading, …) while also immediately rewarding your effort with something that can be intuitively understood.

After multiple (of course unfinished, as usual 🙂 ) two dimensional games and collecting some basic knowledge about programming, I soon became interested in 3D graphics and, being in the “do it yourself” mindset back then, started on trying to figure it out myself. After some initial experiments, I decided to work on writing a software point cloud renderer for geometrical shapes with a friend as part of a school project.

After some more attempts at optimizing the renderer by e.g. rasterizing polygons instead of displaying point cloud data, I quickly reverted back to sticking to 2D graphics for my projects. I also started doing non game related side projects, e.g. investigating and experimenting with unsupervised neural networks which lead me to implementing a hand writing recognition system using backpropagation.


While understanding everything from the ground up was still important for me, I soon realized the effectiveness of relying on libraries instead. At that time I also became interested in hardware rendering so I started exploring the world of OpenGL using the LWJGL Java binding. This lead to the development of multiple projects each building upon the knowledge about rendering gained in the previous one. Some of them resulted in prototypes for games, e.g. OrangeJuice which only relies on display lists instead of VBOs/VAOs and uses a constant ambient lighting while generating its visual cues about the environment’s geometry from a color gradient in the textures themselves.

A screenshot of OrangeJuice, one of my early attempts at 3D rendering using OpenGL. There is no lighting in this scene.

My next attempts soon grew more sophisticated, I really enjoyed figuring out and understanding how hardware based rendering pipelines worked, writing the first shaders, getting phong shading/lighting to work.

At one point, this cumulated in me starting development on my own game engine (Matella). It was mainly motivated by my discontent with the unflexibility of popular engines and wanting control of my own game update loop and rendering pipeline. For private projects, I most of the time still use Matella although for bigger projects I’d choose one of the popular engines as there are still a lot of features missing in mine which can be easily achieved using a commercial engine, e.g. an animation system, a physics engine or a deferred rendering system for more lights. The engine by now supports a lot of features including wavefront loading, terrain heightmap rendering, shadow mapping, post-processing, reflective water and particle rendering.

A demo scene from Matella

It has a model and world editor and allows dynamically shaping the terrain heightmap in real time.

The Matella world editor allows you to manipulate objects in the world like entities, lights, water and portals as well as shape the terrain heightmap. The portals shown in this image can be traversed seamlessly.

Later on, I also got interested in portal rendering which I implemented in Matella as well and used in a LudumDare entry (Shards).

Afterwards, I’ve somewhat diverted from rendering and games engineering, as, while I still have a tremendous amount of fun doing it, I’m sure that I don’t want to do it professionally.

After obtaining a VR headset, this is also what drove me back to implement VR support within my engine.

As I’m a huge fan of RTS games, I developed multiple games, one of which, Kirella, is based on the Matella engine. It is played in first person and uses a decentralized architecture (lockstep networking) in combination with flowfield pathfinding.

A scene from Kirella

Forged Alliance Forever

I’ve been contributing to the Forged Alliance Forever open source project since December 2016. FAF is a community made Lobby/Tournament/Map-/Mod-Vault project for the real time strategy (RTS) game Forged Alliance from 2007.
I’ve spent quite some time on one of their clients (Downlord’s FAF Client) using Spring and JavaFX.

The game internally uses a peer to peer network architecture that tends to disconnect players from the game regularly. Due to this I’ve also invested some time into fixing/writing an ICE adapter for NAT traversal which aims at tunneling all game connections through the local adapter and using the Interactive Connectivity Establishment (RFC 5245, candidate discovery, STUN+TURN) protocol for connecting to other players. It was deployed and is operating since 2019.

The debug window of the ice adapter after having established a connection to all players in game

Web developement

Although not being a fan of JavaScript, especially on the server side, in the beginning, at some point I decided to get into Web developement a bit. I’ve worked on different projects like a browser based RTS (rtsIO) and a meta game for the FAForever community with tight discord integration.
By now I’ve come to embrace the power of writing a web app that can then be deployed on desktop and mobile systems, using a web browser or electron, no matter the infrastructure.

I prefer statically typed languages though which is the reason I started learning Kotlin after discovering its ability to transpile to JavaScript as well as its interopability with existing Java code allowing usage for JVM cross platform deployment, building a web app and a native app, all from the same code base.


I’ve also got some experience with developing Android apps as I have implemented multiple games including a location based hide and seek application. (