Building Games with Untold Engine | State of the Engine Oct 2026

What can you build with Untold Engine?

Over the past six months, Untold Engine has evolved significantly, bringing together rendering, animation, physics, and spatial computing to power increasingly interactive games and immersive experiences.

In this State of Untold Engine update, we're showcasing what six months of development, experimentation, and collaboration have made possible.

What's new in Untold Engine:

  • Rendering improvements, including lighting, anti-aliasing, and performance
  • Gaussian splatting with progressive streaming
  • Advanced animation with GPU compute skinning, inverse kinematics, and morph targets
  • Expanded physics integration
  • Swift Code Components and engine extensibility
  • A redesigned Untold Editor with improved scene-building workflows

Throughout the video, you'll see demos showcasing these capabilities, from tabletop mixed-reality games to immersive spatial interactions.

A huge thank you to everyone contributing to Untold Engine. Your ideas, code, and experiments are helping shape its future.

About Untold Engine

Untold Engine is an open-source game engine built with Swift and Metal for macOS, iOS, and visionOS.

Our vision is simple:

An engine that empowers creativity and never stands in its way.

Explore the engine, build something new, or join the development!

GitHub: https://github.com/untoldengine/UntoldEngine

What can you build with the Untold Engine?

The Untold Engine is an open-source 3D engine built with Swift and Metal, designed for creating interactive 3D experiences on macOS, iOS, and Apple Vision Pro.

In this video, I'm showcasing a collection of demos highlighting what Untold Engine can do today, from immersive mixed-reality experiences to realistic 3D environments and interactive applications.

The showcase includes:

  • Mixed-reality experiences on Apple Vision Pro, including interactive lightsabers, hand tracking, and virtual objects in real-world environments.
  • Realistic 3D environments and Gaussian splat rendering.
  • Untold Editor, demonstrating how developers can build and edit 3D scenes.
  • Architectural visualization and interactive interior environments.
  • Real-time rendering, lighting, reflections, and other graphics capabilities.

Untold Engine is built around the idea that an engine should empower creativity and never stand in its way.

My goal is to build a reliable, accessible 3D engine that allows developers to focus on creating immersive experiences rather than troubleshooting the tools they depend on.

The engine is under active development, and this showcase represents some of the capabilities and improvements we've been working on.

If you're interested in computer graphics, Metal rendering, game engine development, or spatial computing, I invite you to explore the project, try the demos, and follow along as the engine continues to evolve.

Explore Untold Engine

Untold Engine (source code):

https://github.com/untoldengine/UntoldEngine

Untold Editor:

https://github.com/untoldengine/UntoldEditor

UntoldArcade (demo collection):

https://github.com/untoldengine/UntoldArcade

If you enjoy seeing the development of a 3D engine from the ground up, consider subscribing for future updates, technical breakdowns, and new demos.

Special thanks to the collaborators for making these demos possible.

The Performance Fix That Accidentally Solved Anti-Aliasing

A few weeks ago I ran into a frustrating problem in the Untold Engine.

Thin geometry would shimmer noticeably on Apple Vision Pro, and no matter what I tried, I couldn't get the results I wanted. I experimented with SMAA, explored a few other options, and eventually reached a point where I wasn't sure what to do next.

So I stopped working on the problem.

Instead, I focused on performance.

What happened next surprised me.

A renderer optimization led me down the path of implementing Tile-Based Deferred Rendering, and somewhere along the way I realized that the architectural changes might finally allow me to use MSAA in the engine.

This video is the story of how a performance project unexpectedly became the solution to a completely different rendering problem.

Building a game engine is funny sometimes. You spend weeks looking for an answer in one place, only to discover it while working on something else entirely.

If you're interested in rendering, engine development, and the lessons learned while building the Untold Engine, consider subscribing for future devlogs.

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 Wish I Added This to My Game Engine Sooner

When I first started building the Untold Engine, I was obsessed with adding new features.

Rendering systems, lighting, post-processing, you name it.

What I wasn't doing was measuring.

Looking back, one of the biggest mistakes I made was waiting too long to build instrumentation and profiling tools into the engine. As the project grew, performance slowly regressed, and I had very little visibility into where frame time was actually going.

In this video, I talk about why instrumentation became one of the most valuable systems in the engine, how profiling changed the way I approach rendering, and why I believe every engine developer should build diagnostic tools much earlier than they think.

Whether you're building a game engine, renderer, graphics application, or any large software project, learning how to measure your system can save you countless hours of guesswork.

If you're interested in rendering, engine development, and the lessons learned while building the Untold Engine, consider subscribing for future devlogs.

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 Promised Myself I'd Never Build Another Asset Format

A few years ago, while working on the C++ version of the Untold Engine, I made a decision that came back to haunt me: I built my own asset format.

When I rewrote the engine in Swift, I promised myself I wouldn't make the same mistake again. Instead, I adopted industry-standard formats like USD and built the asset pipeline around them.

For a while, that worked great.

But once I started implementing asset streaming and testing larger scenes, I ran into a problem. Every streamed asset required parsing files, traversing scene hierarchies, creating runtime resources, and performing work that was becoming increasingly expensive at runtime.

In this video, I talk about why I eventually changed my mind, why USD wasn't the right solution for this particular problem, and why I ended up building a native runtime asset format for the Untold Engine after all.

This is the story of a decision I never wanted to make—and why it turned out to be the right one.

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.