GEM is my personal repo for learning and implementing new graphics techniques,
currently these are implemented in OpenGL, when the renderer is complete and the
shaders are stable, this will be ported over to SDL-GPU for cross platform compatibility,
as well as a dedicated Vulkan backend, which will allow for cutting edge features to be added
to the renderer (including hardware-accelerated RT, AI assisted upscaling and Frame Generation)
Harmony is a 3D game engine I have been developing since 2022. Built
using SDL2 + BGFX as the primary graphics stack, the engine has a
strong focus on compatibility and cross platform support. It
currently compiles and runs on Windows, Linux (personally tested
Ubuntu 22.04) and macOS (tested using an M1 Mac Mini.)
Modular design: Harmony is comprised of a core and several modules.
This allows for features with complicated dependencies (e.g. Mono)
to be optional to the engine, and be added if the destination
platform can support the module. Additionally, this also allows
editor-specific modules to keep the size of the Harmony Runtime App
small, for instance Assimp, a hefty model importing library, can be
excluded from the runtime of the game once the engine has processed
the model into a custom format.
True ECS design: Entities are simply identifiers, all component data
is stored in an optimal fashion in the scene. This allows for
greater cache coherency when processing systems with many entities,
and also allows for flexible querying of related entities.
Editor built using ImGui meaning users of the engine can easily access the immediate mode UI
API to add additional editor functionality for their game.
Harmony also features Jolt Physics integration, which allows for a vast number of physical bodies to be
simulated efficiently, and provides a clean interface to the physics
world & bodies.
Harmony also has extensive scripting support, with the ability to
script your game using C# (Mono) or Lua (Lua & LuaJIT available
through a compile option). When using C#, Harmony also features a Visual Studio extension that allows debugging of C# Scripts at runtime, an invaluable asset
debugging logic errors.
Simple Pipeline Renderer architecture which relates shaders +
renderers to the framebuffers + attachments they require. NOTE: this area of the engine is currently being rewritten to be more efficient
and make use of Vulkan which supports
the platforms Harmony targets and allows for greatly increased
performance through minimised CPU usage by offloading of essential tasks
such as skinning and particle systems to the GPU.
Serialization infrastructure via JSON.
Hot reloading of Shaders, Lua Scripts and Mono Assemblies.
Bubble & Squeak is a platforming puzzle and exploration game. The game centers around a small mouse
whose nest was destroyed and who must now navigate a farm house to find a new shelter, solving small puzzles and exploring the house along the way.
Bubble & Squeak was a game jam entry for Global Game Jam 2025. The team consisted of 4 artists, a single designer and a single programmer (myself).
The jam served as an excercise for the artists to gain some intuition & experience of the game development process, while myself and the designer used the opportunity to familiarise ourselves with Godot.
Key insights from this project:
Familiarization with Godot Engine
Using C# with Godot.
Exposing performant scripts & prefabs to be reused by designers in
the Godot Editor.
3C (Character, Camera and Controller) programming for main character.
Gallery
Playthrough
Helin
Group UE5 Project
Helin is a space puzzle and exploration game. The game revolves around
local and online co-op (through Steam) where the players must work
together to solve puzzles and uncover the secrets of the planet.
Helin was a group project I was involved in during 2021. We intended
to produce a portfolio piece with the then early access release of
Unreal Engine 5.
I was the lead programmer in this project with two other programmers
working with me, alongside three designers and two artists.
The main responsibility of the programmers was to implement the core
logic components in C++ and expose these building blocks to designers
who could author new behaviour and puzzles using only blueprints.
Programmers also had to ensure that the correct replication logic
(MultiCast, ServerOnly etc.) was considered as a core constraint for
all new gameplay components.
Key insights from this project:
Networked C++ with Unreal.
Exposing performant components to be reused by designers in
Blueprints.
Networked physics & puzzle interactions between multiple players.
Replication logic for a networked Unreal engine game.
