Tinker Tails marks the apex of our university programme, second only to the research thesis itself. The game, along with the engine, has been built from scratch using agile/scrum methodology in a team of 12 developers. All engine development, networking, architecture, devops, resource management, gameplay scripting, and art/music was done in-house.

The program is built in two main layers: a game engine programmed in C++, along with the game itself developed entirely in LUA. The engine works off of an entity-component system and powers a completely custom and extensive scripting interface for gameplay development.

One of my largest contributions was the resource precompiler, and resource manager system. The precompiler is an external utility for managing assets and compiling/preprocessing asset binaries from raw asset files. It operates a chain of loading and packing operations for each file, where the artist has the option to configure settings for each asset regarding compression and formatting. This system is fully multithreaded and works on many files at once. Metaresources referencing eachother and bunching assets into materials, or whatever else, are also a core feature. The asset binary is shipped with the game alongside a metadata file on how to read it. The resource manager system in the live applicaiton opens and tracks all resources, both synchronously and asynchronously during the course of the game.

These are my other contributions to the project:

• Cloud volumetrics.
• Debugging and logging systems.
• Argument handling.
• TOOL, the standard library. Read more about it here.
• TOON, another library for noise generation.
• Many gameplay systems.
• Devops and build automation. I set up submodules for asset handling and custom GitLab hosting on a teammate’s home server.
• Lots of work regarding engine architecture and system design.
• Responsible for game and gameplay systems architecture.
• Codebase maintenance and refactoring.
• Music and iconography.

Made for projects that distance themselves from the monolithic language standard libraries, the library is built for simplicity and real usability in game software. TOOL is the newer standard library of mine, more or less replacing the object-oriented CHSL. In recognizing that good low-level software strives to be simple to maintain both performance and modifiability, TOOL aims to break down the most common and useful software tools into digestible functional interfaces.

TOOL on GitHub

The Tired-Of-Objects Library, or TOOL, is a constantly evolving multi-platform function-oriented standard library built for performance, simplicity, and flexibility. The library was born out of dissatisfaction with much of modern object-oriented design, along with the massive C++ standard libraries that follow. While these massive and feature-rich libraries naturally serve an important purpose, having a simpler, more direct alternative for all of the most common functionality serves to streamline and speed up development. From these feelings spring a desire for something better, and more suited to my needs and the needs of my peers.

Headers are intentionally built short, simple, and straight-forward. This works in a low-level software developer’s favor for a number of reasons.

• It cuts down the horrendous compile times often experienced with the humongous templated C++ standard library includes to near-zero. Wanting a translation unit to act on a string of text should not require an extra second on every compile.
• It simplifies error logging, as functionality is more specific and less templated. The smallest perceivable error in a call to std::format or std::regex_search can produce a short novel for you to read through, a waste of time if there ever was one.
• It self-documents the functionality through a legible and digestible interface. Following a #include <string> link to the source file seldom provides enlightenment on anything. Well-designed code can benefit from, but should not require, extensive commenting or documentation to be comprehensible.
• It breaks down the humongous array of esoteric utilities made available through large modern standard libraries into the most core constituent parts. Performance-oriented programmers often strive to optimize their software and understand its workings, not pray to higher powers that the standard library becomes the bottleneck.

Captain Catnip is our submission to ScoreSpace Jam 29, ranking 14th overall out of 139 entries. It is the second game jam entry made by me and a friend of mine under the KONGSTRONK name. As with the previous game, our reason for participating is three-fold: grow as game developers, finish more games, and have fun.

If you’re on desktop, you can try out the game right in your web browser by following the link!

Captain Catnip was made in 72 hours from scratch in Unity. For this game I acted as the main programmer, and we incorporated a number of interesting features to distinguish it from the rest. Besides being one of the few 3D games, we added fun realistically based fluid dynamics for controlling the ship through the water.

Besides procedurally generating the obstacles and pickups in the environment, the geometry for the water and game world itself is generated programmatically as the game runs, continuously building a cylindrical “barrel world” for the ship to move over. This skips any illusions and instead physically represents the horizon and objects appearing over it in the world itself. Through our custom water shading and other tricks, it looks seemless!

The FastNeurons neural network library is centered around training performance above all else. When comparing with a popular sequential LeNet5 C implementation, training and testing over the MNIST handwritten digit datagbase, FastNeurons manages a speedup of more than 100x.

FastNeurons on GitHub

Below you’ll find a comparison of two LeNet5-esque neural network training sequences (using MNIST), showing first FastNeurons, then an equivalent sequential CPU implementation available here.

Parallel version:

Train average 1:	3.751 seconds
Train average 2:	4.073 seconds
Train average 3:	3.732 seconds
Train average 4:	3.688 seconds

Test time 1:		1.062 seconds
Test time 2:		1.121 seconds
Test time 3:		0.915 seconds
Test time 4:		0.945 seconds

               Predicted label
               0     1     2     3     4     5     6     7     8     9     Total
----------------------------------------------------------------------
True label
         0   970     0     2     0     0     0     4     1     3     0       980
         1     0  1125     0     4     0     0     3     0     3     0      1135
         2    11     7   969     9     5     1     5    10    15     0      1032
         3     2     0     4   970     1    13     0    11     6     3      1010
         4     0     0     1     1   958     0     8     0     2    12       982
         5     6     1     0     9     1   862     2     1     6     4       892
         6     9     3     0     1     4     5   931     0     5     0       958
         7     2    12    17     4     0     1     0   950     2    40      1028
         8    10     4     1     7    10     3     2     7   915    15       974
         9    10     6     0     5    17     7     0     4     7   953      1009
----------------------------------------------------------------------
                                Total number of input images tested =      10000
----------------------------------------------------------------------

Correct guesses: 9603 / 10000 (96.0300%)

Sequential version:

Total 1:	424 seconds
Total 2:	420.54 seconds

               Predicted label
               0     1     2     3     4     5     6     7     8     9     Total
----------------------------------------------------------------------
True label
         0   971     0     1     0     0     1     3     1     3     0       980
         1     0  1122     1     3     1     0     1     0     7     0      1135
         2    10     2   989     2     5     0     5     9    10     0      1032
         3     1     3    12   949     0    21     0    11    12     1      1010
         4     1     2     1     0   961     0     6     1     2     8       982
         5     4     3     0     2     0   872     3     1     5     2       892
         6    10     4     2     1     4     3   930     0     4     0       958
         7     1    11    22     1     3     0     0   978     2    10      1028
         8     7     4     2     3     7     4     1     4   938     4       974
         9     9     8     0     3    27     9     1     7    10   935      1009
----------------------------------------------------------------------
                                Total number of input images tested =      10000
----------------------------------------------------------------------
Testing: Correct predictions = 9645 (96.45%)

When training over multiple epochs, this classic convolutional neural network design can achieve accuracy of over 99%! While this is one possible network using the library, a developer could build any other design incorporating fully connected, pooling, and convolutional layers. Below you’ll find a code snippet showing how LeNet5 is implemented using FastNeurons.

void NetworkCreateLeNet5(Network* network)
{
	const int kernelWidth = 5;
    
	NetworkCreate(network, 8);
    
	// Add the layers
	NetworkAddLayerInput2D(network, 1, 28, 28, 4);
	NetworkAddLayerConvolution2D(network, 6, kernelWidth, ActivationTypeReLU);
	NetworkAddLayerPooling2D(network, 2, PoolingTypeMax);
	NetworkAddLayerConvolution2D(network, 16, kernelWidth, ActivationTypeReLU);
	NetworkAddLayerPooling2D(network, 2, PoolingTypeMax);
	NetworkAddLayerFullyConnected(network, 120, ActivationTypeReLU);
	NetworkAddLayerFullyConnected(network, 84, ActivationTypeReLU);
	NetworkAddLayerFullyConnected(network, 10, ActivationTypeReLU);
}

Push Hour is our prize-winning submission to SpeedJam 4. For the game, we won the streamer’s choice award, becoming one of three winning games for the first section of the 72-hour game jam!

The first game made as part of the the KONGSTRONK project: a game development duo made up of myself and a close friend of mine. The goal of these jams has always been a three-way split: grow as game developers, finish more games, and have fun. While I’ve been making games for many years, putting the pressure on each other really helps bring out my enthusiasm for game development.

If you’re on desktop, you can try out the game right in your web browser by following the link below!

Push Hour was developed from scratch in 72 hours using the Unity game engine. We both have lots of prior experience using Unity, and for this game I acted as lead programmer. Trying out new techniques and features to distinguish the game, we decided to build a core part of the game on simulated crowd dynamics. Commuters are individual agents and all move with respect to each other. The entire game exists within a one-scene environment, with individual games stopping and starting smoothly without transitions and loading screens: the player gets thrown right into the action.

Representing the culmination of our first three years in university, Whisperwoods shows off many facets of video game tech, rendering, creative optimization, and software engineering. Developed with little integration of external software libraries, the game features a renderer built from scratch using DirectX 11, custom resource asset formats, procedural world generation, and fast-paced strategic stealth gameplay, all optimized to run smoothly on very rudimentary hardware.

Whisperwoodson GitHub

The team, consisting of six developers specialized and interested in different things, synergized to build a fairly well-rounded game engine. The software features and gameplay overview are demonstrated in an early build trailer available on YouTube.

Of course, I was not the totality of the development group. These are my contributions:

• Initial rendering and lighting
• Render pass optimizations and mass instancing
• Program infrastructure and core system design
• Codebase maintenance and refactoring
• Procedural world generation
• Contributions to core software architecture
• Build system configuration and build automation
• Music and iconography

CHSL is a more fully featured object-oriented counterpart to TOOL, my newer library.

CHSL on GitHub

The Crazy High Standards Library, or CHSL, is an older but more feature rich standard library adhering to object-oriented principles. It has been used in a number of my other projects since, and has grown over time to include many features.