Untold Engine Updates: Multi-Platform support and Camera Behaviors

Hi guys,

Me again with some updates on the status of the Untold Engine. As always, I’ve been working diligently on the engine. Over the past two weeks, I focused on implementing multi-platform support, fixing several async issues with scene loading, and starting work on a couple of camera behaviors that I needed for benchmarking and game testing. So let me walk you through what’s new Untold Engine Studio

Multi-Platform Xcode Project Support

With the Untold Engine, you’re no longer limited to building a game for a single platform. You can now create an Xcode project with multi-platform support, either through the CLI or directly from the Untold Engine Studio.

This makes game development a lot smoother: you code once, and your game runs on macOS, iOS, iOS + AR, and Vision Pro. The only platform still missing is tvOS, but that will be added soon.

Fixed Async Issues

There was an issue when loading large scenes in async mode that could cause a runtime crash. This was tricky to debug, but I eventually tracked it down, and the crash is no longer present.

If you’ve been following the progress of the engine, you’ll know that one of my core rules is that the engine should never crash. If you do encounter any crashes while loading a scene, please let me know by opening a GitHub issue.

Camera Behaviors

Finally, I started implementing the following camera behaviors:

• Camera path follow using waypoints
• Camera follow with a dead zone

It’s interesting that I still haven’t implemented first-person or third-person camera behaviors, yet I decided to work on these first. The reason is simple: I’ve been benchmarking the engine, and I needed a camera that could follow a predefined path using waypoints. The goal is to measure frame rate as the camera traverses a heavy scene. Since this behavior didn’t exist, I implemented it and made it part of the engine, as I do see it being useful for game development in general.

The second behavior is one you often see in soccer (fútbol) games. The camera only follows the entity if it moves beyond the boundaries of a box; otherwise, the camera remains stationary. I implemented this because I’m currently developing a soccer video game using the new Untold Engine and Editor.

There’s a clear purpose behind developing this game, and the effort has already paid dividends. I’ve run into several bugs and API confusions that I would not have discovered otherwise. Even though I’m not in the business of making games, I do see game development as a core part of building a game engine. I mean, how else would I really test my own tools?

That’s it for now. I’m going to get back to coding. Stay tuned for upcoming features.

Thanks for reading. And don't forget to download the Untold Engine Studio

Untold Engine Updates: Faster Scene Loading, SSAO improvements, CLI

Hey guys, I’ve been working hard on improving the engine lately—both performance-wise and editor (user-experience) wise.

Faster Scene Loading with Async Asset Loading

One of the main issues I fixed in v0.7.0 was the long wait times when loading heavy scenes. I don’t have hard numbers, but it was definitely taking longer than what’s acceptable for a game engine. The main issue was that we didn’t have an async loading system in place. All models were being loaded synchronously, which caused long stalls.

With v0.7.0, scenes are now loaded through an async loading system, which makes the overall experience much better and more responsive.

Here is an example of how you can use the new async loading:

// Create entity
let entityId = createEntity()

// Load mesh asynchronously (fire and forget)
setEntityMeshAsync( entityId: entityId, filename: "large_model", withExtension: "usdz")

For more info, read the UsingAsyncLoading.md under the docs folder.

SSAO Performance Improvements (Especially on Vision Pro)

Another issue I worked on was improving SSAO performance, especially on mobile and Vision Pro. I added three quality modes for SSAO computation:

• Fast
• Balanced
• High

Fast mode is the most performant but has the lowest quality, while High mode provides the best quality at the cost of performance. Fast mode did improve performance on Vision Pro, but unfortunately, not enough—the FPS is still not acceptable. Until I find a better solution, I recommend disabling SSAO entirely when using Vision Pro.

To use it in code, simply set the quality as shown below:

SSAOParams.shared.quality = .balanced //.fast or .high

Command-Line Project Creation (Xcode Integration)

The third feature I added, which I think will be really helpful, is the ability to create an Xcode game project with Untold Engine as a dependency directly from the command line. This is especially useful for users who want to bypass the editor and work directly in Xcode. That said, this doesn’t mean you can’t use the editor later—projects created this way can still be opened in Untold Engine Studio.

Here is an example on how to install and use the cli tool:

# clone the repo
git clone https://github.com/untoldengine/UntoldEngine.git
cd UntoldEngine

# Install the CLI globally:
./scripts/install-create.sh

# Verify installation:
untoldengine-create --version
untoldengine-create --help

# After installing the CLI, create a project from anywhere:

#  Create project directory
cd ~/anywhere
mkdir MyGame && cd MyGame

#  Create the project
untoldengine-create create MyGame

#  Open in Xcode
open MyGame/MyGame.xcodeproj

For more information, see: Tools/UntoldEngineCLI/README.md

Editor Workflow Improvements

I also spent time improving the user experience in the Untold Editor. The workflow is starting to take shape:

1. User opens Untold Engine Studio
2. Creates a new project or opens an existing one
3. Populates the scene
4. Writes game logic using Swift or scripting
5. Builds & plays
6. Repeat steps 3–5

This is still a work in progress, but I’m liking how everything is coming together.

What’s Next

For this week, I’m planning to focus on:

1. Benchmarking + metrics harness
2. Improving performance on Vision Pro and iOS

That’s the plan.
Feel free to checkout the the Untold Engine Studio v0.7.0.

Thanks for reading.

Untold Engine is Growing Up

I’ve been working on the Untold Engine for nearly 12 years.

I started in 2013, back when I didn’t even know what version control was. The early versions of the engine were crude, fragile, and limited—but seeing it improve, fix by fix, was deeply motivating.

There were many points along the way where I wanted to quit. Days where I was tired of touching the engine at all. At one point, I stopped entirely for about six months before coming back.

What I learned over time is that building a game engine isn’t technically hard in the way people expect. The real difficulty isn’t math, rendering, or architecture—it’s consistency. Showing up every day after the excitement wears off. Continuing when motivation is gone.

That’s the part most people underestimate.

I eventually realized something about myself: I’m not a good engineer because I write good code. I’m a good engineer because I don’t leave problems unfinished. I stay with them. I’ve done that since I was a kid—I just didn’t recognize it until much later.

That persistence is the reason Untold Engine still exists today.

After rebuilding the engine twice—from C++ to Swift—the project is finally reaching a point where it feels grown up. Today, I’m releasing Untold Engine Studio, the first bundled desktop release of the Untold Engine ecosystem.

This release exists for one reason: to remove friction.

With Untold Engine Studio, developers can:

• Download a single DMG and start immediately
• Skip repository cloning and local build setup
• Create and manage projects from a standalone app
• Work visually with scenes, assets, and entities
• Iterate quickly using Play Mode and Scripting language

From the beginning, my focus has been user experience. I’m not trying to compete with Unreal on performance or Unity on market share. My goal is simpler—and harder: to build a tool that feels intuitive, stable, and dependable. Something that doesn’t fight you. Something that just works.

That’s not easy. It requires constant iteration and restraint. But this release is a meaningful step in that direction.

If you’re curious, I encourage you to download Untold Engine Studio and try it for yourself. Your feedback—good or bad—is genuinely valuable, and you can share it through the Untold Engine GitHub issues.

I’ve also invested a significant amount of time in documentation to make getting started easier, and I hope it helps.

As 2025 comes to a close, I’m proud of where Untold Engine is today. I have ambitious plans for 2026, and I’m excited to see how much further this project can go.

Thank you for reading.

Untold Engine Update: Gaussian Splats, Scripting Support, and macOS Build System

It has been a while since my last update, but I’ve been quietly working behind the scenes on several major features. Today, I want to share three big milestones for the Untold Engine.

Gaussian Splats

The first major update is that the Untold Engine now supports Gaussian Splat Rendering. This is a feature I’ve wanted to implement since I first learned about Gaussian Splatting last year. Other priorities kept delaying it, but a few weeks ago I finally had enough time to focus on it—and I got it working.

Gaussian Splats now run inside the Untold Editor, on iOS, in AR, and on the Vision Pro, running directly on the device. This means both 3D models and splats render natively on visionOS hardware, not just the simulator.

There are a few current limitations:

• I’m using Bitonic Sort instead of Radix Sort for depth sorting. Bitonic Sort works, but it is slower for large splat counts. Radix Sort is the long-term goal.
• Spherical Harmonics support is not implemented yet. I’m hoping to add this before the end of the year.

Even with these limitations, this is a major step forward for the engine’s rendering capabilities.

Scripting Support

The engine now supports runtime scripting directly through the Untold Editor.

You can write game logic in Xcode, attach scripts to entities, and instantly see the results while the engine is running. All scripts appear in the Asset Browser, and you can add, link, or reload them with a click. This makes the development workflow smoother and faster.

This feature was long overdue, but I approached it carefully because of past experience integrating scripting languages. Instead of Lua or Python, I built a lightweight DSL (Domain-Specific Language) specifically for the Untold Engine. I used ChatGPT heavily at the beginning to help with the initial structure, and once everything made sense, I took over and customized the system for the engine.

If you see anything that can be improved, please let me know—this is a brand-new system and will evolve with feedback.

Feel free to check out the Scripting Section in the Docs to learn more.

Build System

Another major milestone is the new Build System.

After you set up your scene in the editor and attach scripts, the Untold Engine can now generate a macOS build of your game. The Build System packages your scenes, assets, and scripts and produces an app ready for the App Store. All you need to do is provide a project name and a destination path.

At the moment, the Build System supports macOS only, but iOS and visionOS support is planned.

What’s Next?

I’m currently working on a packaged app bundle for the Untold Engine. The idea is to let developers download a .dmg file and start building games immediately—without cloning the repo or setting up dependencies. Developers who want full control can still clone and build from source.

This bundled version will be called Untold Engine Studio, and it will include everything required: the Untold Engine, the Untold Editor, and all dependencies. My goal is to make the development experience as smooth and accessible as possible.

More updates coming soon. Thanks for following the journey!

Untold Engine Progress Update – New Editor and VisionOS Support!

This past couple of months have been amazing for the Untold Engine — from getting its first contributor and sponsorship to adding VisionOS support.

Let me tell you all about it.

Engine & Editor

You may recall that I had both the core and the editor integrated tightly in the engine. It worked nicely, but the coupling was going to give us headaches in the future.

Thanks to the effort of our first contributor miogds, the core of the engine and the editor are now de-coupled.

So, this is the new architecture of the engine:

• Core: Handles the runtime — rendering, physics, ECS, and all engine systems.
• Editor: A dedicated app for scene creation, entity manipulation, and asset management.

Untold Engine - Core

This separation makes development cleaner, more modular, and sets the stage for headless or custom integration workflows.

Additionally, the core engine will continue in its original repository UntoldEngine, while the editor now lives in a new, dedicated repo UntoldEditor.

Untold Engine Editor

Unit Tests & Workflows

I've also been working on making the Untold Engine repository more professional.
This includes adding unit tests, GitHub Actions workflows, and automatic formatting and linting.

My hope is that these improvements will make contributing to the project much easier and more reliable.

Website & Documentation

Another area of progress has been the new website and documentation.
The documentation site covers how to install the engine, explore the APIs, and contribute to development.

You can check it out here: Untold Engine

Each engine release will include its own version of the docs for consistent developer onboarding.

VisionOS Support

Lastly, the engine now compiles and runs on the VisionOS simulator — the first step toward supporting Apple’s Vision Pro platform.

However, this is still early support — the engine has not yet been tested on an actual Vision Pro device.
We’ve already received an issue report related to Vision Pro hardware, so if you happen to have one and would like to help debug, you’re more than welcome to contribute!

Thanks for reading.