Paul Engine

Project Overview

Paul Engine is my long term personal project. A custom C++ game engine built using OpenGL. It started as a simple C++ port of a C# engine I built during university, but quickly evolved into something far more complex and ambitious.

It represents my growth as a programmer and my mindset for learning. From scrappy and experimental beginnings focussed on features, to deliberate architecture and clean code.

Timeline & Evolution

• Initial inspiration (Late 2022 - Early 2023):
  A very basic C# engine built in a university course focussing on ECS design and general game architecture. I remember being disappointed that we built this using C# instead of C++, as it would have been a valuable confidence builder with the C++ language.
• Starting the project (October 2023):
  After graduating, I knew I needed more experience with C++ if I wanted to enter the games industry. So I started a basic port of the C# engine. Since we mainly used C# at university in general, this was the perfect opportunity to push myself into C++. However, I had a lot to learn.
• Increasing scope (Late 2023 - 2024):
  The project now far surpassing the original inspiration. Each feature implemented was done so at a higher quality than the last, showing my C++ skills evolve over time. But it was all being held together by a rotten core. Those early beginnings. I didn't want to have to add the footnote "don't look too closely at the early stuff" when asked about my work anymore.
  Features are great, I was enjoying learning about a variety of different topics. But, for me to feel comfortable showcasing this engine, work needed to be done fixing the core.
• A short break (Late 2024):
  After implementing screen space reflections in the engine, I suddenly became fascinated by ray tracing and wondered if it was something I could do. So, I took a break from the game engine and began exploring path tracing with another project: GLTrace
• ECS Re-write (Early 2025):
  After the break, I knew it was time to start re-writing this game engine. And so, I started with the entity component system. This is a core element of a modern game engine. My original implementation worked, but it was clunky to use and wasn't very flexible. But the main issue with the original was memory inefficiency. I re-designed the system to be significantly more cache consistent, more flexible and easier to use.
• Teardown (Early 2025 - Ongoing):
  I was happy with the ECS re-design. But the core of the engine was still a mess. Even down to the file structure. Something needed to change. So, I created a new branch in the github repo titled "Teardown" and deleted every single file.
  I knew I had a monumental task ahead of me. Taking what I learned so far, I set out to rebuild the engine from the ground up.
  My goal: feature parity, robust architecture.

The Teardown Branch

Earlier this year, I created a new branch in the project repo called teardown. I deleted everything and started fresh, applying everything I had learned. The goal is to rebuild all the features from the original version but with a much stronger design, as well as some much needed features.
This rewrite introduces:

• A proper separation between the engine and the game runtime
• Editor application
• Graphics API agnostic design
• Improved file structure
• Improved memory management
• Clean application backend
• Overhauled features
• Improved asset handling
• Scene serialization
• and more... (promise)

Progress Comparison

Showcase

Original version:

Sponza Scene

❮ ❯

Teardown version:

Sponza Scene

❮ ❯

Progress Reports

• Deferred Rendering and Render Passes in Paul Engine

  Date published: 27/07/2025

  The design and evaluation of the modular render pass and frame renderer system and how it was used to prototype the deferred render pipeline in Paul Engine.

Links

• Main GitHub Repository
• Teardown Branch (Re-write)