The Debugging Systems I Built for My Game Engine

Building a game engine has completely changed the way I think about debugging software.

For a long time, my workflow was simple: Open the code editor, add breakpoints everywhere, inspect variables, and hope I could eventually find the root cause of the problem.

That worked when the engine was smaller.

But as the Untold Engine grew more complex — with rendering systems, tile streaming, texture mip streaming, and XR features — I realized I was debugging blind.

So I started building diagnostic and instrumentation systems directly into the engine.

In this video, I walk through:

  • Engine performance instrumentation
  • Render target debugging
  • Tile streaming visualizers
  • Texture mip streaming debuggers
  • Rendering diagnostics for SSAO, SMAA, G-Buffers, and more
  • How these tools changed my development workflow

I also talk about the biggest realization I’ve had as an engineer over the past few years:

Modern debugging is less about staring at code… and more about building tooling that gives you visibility into what your application is actually doing.

The Untold Engine is a Swift + Metal renderer and engine focused on XR, streaming, and real-time rendering for Apple platforms.

Untold Engine: https://github.com/untoldengine/UntoldEngine

If you enjoy engine development, rendering architecture, XR rendering, or graphics programming, consider subscribing.

The Hidden Cost of Building a Game Engine Editor (Why I Scaled Mine Back)

Building a game engine taught me something unexpected:

The hardest part isn’t always writing the renderer, implementing XR support, or optimizing performance.

Sometimes, the hardest part is deciding what NOT to build.

In this video, I talk about why I decided to dramatically scope down the Untold Engine Editor, the mistakes I made, and the engineering tradeoffs that come with maintaining complex tooling as a solo developer.

We’ll talk about:

  • Why I removed scripting from the editor
  • The hidden cost of maintenance
  • Why building an engine and building an editor require completely different skill sets
  • And why simplifying the editor was ultimately the right decision for the future of the Untold Engine

Untold Engine is a Swift + Metal renderer and engine focused on XR, streaming, and real-time rendering for Apple platforms.

Untold Engine: https://github.com/untoldengine/UntoldEngine

If you enjoy engine development, rendering architecture, XR rendering, or graphics programming, consider subscribing.

I Thought Unit Tests Would Slow Me Down… I Was Wrong

When I started building the original C++ version of the Untold Engine back in 2013, I focused on building systems from scratch:

  • Rendering
  • Physics
  • Collision
  • Math libraries

But there was one engineering practice I completely ignored:

Unit Testing.

At the time, I thought tests would slow development down.

Instead, the opposite happened.

As the engine grew, regressions became part of the workflow. Features would randomly break, bugs would reappear, and I would spend days re-debugging problems I had already solved before.

So when I rewrote the Untold Engine in Swift, I made testing part of the workflow from day one.

Today, the engine has over 1000 unit tests covering rendering, streaming, physics, animation systems, and more.

In this video, I talk about the engineering lesson I learned building a renderer and game engine for over a decade.

The Untold Engine is an open-source Swift + Metal renderer and engine focused on XR and Apple platforms.

Check out the Untold Engine: https://github.com/untoldengine/UntoldEngine

I Thought SMAA Would Fix XR Shimmering

I implemented SMAA in the Untold Engine hoping it would solve the shimmering and aliasing artifacts I was seeing in large XR scenes on the Apple Vision Pro.

At first, things looked promising.

SMAA uses multiple rendering passes, edge detection, blend weight calculations, and precomputed lookup textures to produce sharper anti-aliasing than FXAA.

But once I started testing massive stadium scenes and distant geometry in XR, I realized the problem was much deeper than I expected.

In this video, I walk through:

  • Implementing SMAA in my Swift + Metal renderer
  • Debugging the SMAA rendering passes
  • Building a magnifier tool to inspect pixel-level differences
  • Why XR aliasing is much harder than standard post-processing

The Untold Engine is an open-source Swift + Metal renderer and engine focused on XR and Apple platforms.

Check out the Untold Engine: https://github.com/untoldengine/UntoldEngine

I Tried Rendering This Archviz Scene in Vision Pro… Then This Happened

I tried rendering a full archviz bedroom scene on the Apple Vision Pro using the Untold Engine… and while the results looked immersive at first, I started noticing some strange XR rendering artifacts.

In this video, I test the scene live inside Vision Pro, explore issues like shimmering walls and unstable surfaces, and talk about some of the rendering challenges that start appearing when pushing real-time archviz scenes into XR.

This is one of the reasons I enjoy building the Untold Engine in public — not just showing what works, but also documenting the rendering problems and technical walls that show up along the way.

If you’ve worked on XR rendering before, or recognize what might be causing these artifacts, I’d genuinely love to hear your thoughts.

The Untold Engine is a Swift + Metal renderer focused on XR rendering, large scene streaming, and real-time graphics for Apple platforms.

Check out the Untold Engine: https://github.com/untoldengine/UntoldEngine