Untold Engine & Editor v0.20.0 — Code Components, Swift Plugins, and Improved Gaussian Workflows

[untoldengine]

Untold Engine and Untold Editor v0.20.0 are here!

This release introduces a new way to extend your games, applications, and the editor using native Swift code. It also brings improvements to Gaussian splat rendering, capture preparation, and debugging tools.

The biggest addition is UntoldComponentKit, a new extension system that allows developers to create their own gameplay components, custom entity types, procedural geometry, and editor tools without modifying the engine itself.

Together with the editor's new compilation and hot-reloading capabilities, you can now write custom functionality in Swift, attach it to entities, configure it through the Inspector, and iterate directly within your project.

Let's take a look at what's new.

Build Your Own Components in Swift

One of the main goals of this release is to make Untold Engine more extensible.

With Code Components, you can define your own gameplay behavior in Swift and expose configurable properties directly in the editor.

For example, you could create a component that controls how an entity moves, responds to interactions, or behaves during gameplay. Its configurable properties can then be adjusted through the Inspector without modifying the component's source code.

Code Components integrate with the existing editor workflow:

• Define strongly typed components using native Swift.
• Attach custom components through the Inspector's Add Component menu.
• Expose public component attributes as editable Inspector controls.
• Serialize component values with the scene.
• Restrict components to compatible entity types.
• Organize components within your project or distribute them as reusable Swift plugin packages.

The editor automatically discovers, compiles, and loads project-authored components when a project opens. It also watches source files for changes, allowing project code to be rebuilt and reloaded as you iterate.

Newly generated projects include Code Components support, and the editor app bundle now includes the Component SDK required to compile project code.

We've also improved component lifecycle handling to safely handle cases where one component removes another during attachment.

Create Custom Entity Types

Beyond individual components, you can now introduce entirely new kinds of entities into Untold Engine.

Using the new EntityPlugin interface, developers can define custom entities with their own properties, behavior, required components, and geometry.

Custom entities can also provide editor-specific functionality, including visual representations and placement behavior.

For example, you could build:

• A procedural path entity with editable control points.
• A custom spawn point with an editor-only visual indicator.
• A volume that exposes its dimensions through interactive handles.
• A procedural shape that regenerates its geometry when its properties change.
• Specialized entities for architectural visualization, simulations, or other project-specific workflows.

Custom entity types discovered in project code or reusable plugin packages appear alongside the editor's built-in entity options.

Entity-specific components are automatically associated with their intended entity type and remain hidden from the general Add Component menu.

This makes it possible to build specialized tools and higher-level scene objects without adding them directly to the engine.

Interactive Viewport Handles

Custom entities can now provide editor-only representations and interactive viewport handles.

These representations allow plugins to display helper geometry, control points, and other visual information that is useful during editing but does not appear in the running game.

Viewport handles can be selected using either mouse button and moved with the standard transform gizmo.

When you move a handle, the editor automatically:

• Updates the associated Swift property.
• Rebuilds the custom entity.
• Refreshes its Inspector values.
• Marks the scene as modified.
• Records the complete drag as a single undoable action.

This provides the foundation for building interactive authoring tools such as procedural paths, editable volumes, and other custom scene objects.

Extend the Editor with Swift Plugins

The new extension system also allows developers to customize the editor itself.

Three primary plugin interfaces are now available:

• ComponentPlugin — Define reusable components with custom behavior and editable properties.
• EntityPlugin — Introduce custom entity types with their own components, geometry, and editor representations.
• EditorMenuPlugin — Add project-specific commands to the editor's menus.

Editor menu extensions can provide custom actions such as content generators, validation tools, project utilities, and other workflow-specific commands.

Extensions can live directly within a project or be distributed as reusable Swift plugin packages.

We've also introduced separate naming and packaging conventions for project-local plugins and reusable packages, including correctly named editor-side libraries.

The goal is to give developers more freedom to build the tools their projects need while keeping the engine and editor extensible.

Runtime Mesh Creation

Untold Engine now includes a public API for creating meshes directly from CPU-side vertex and index arrays.

This is particularly useful for procedural geometry, custom entity plugins, and applications that need to generate or modify geometry at runtime.

Meshes created through this API automatically receive a default submesh material, reducing the amount of setup required to get procedural geometry rendering.

We've also corrected the generated sphere primitive's dimensions so that its rendered extent matches the requested size.

Improved Gaussian Splat Workflows

This release also brings several improvements to Gaussian splat rendering and the tools used to prepare large captures.

The focus is on making large Gaussian scenes easier to cook, inspect, debug, and optimize for different devices.

Faster Gaussian Splat Culling

On the engine side, Gaussian splat rendering now performs a tree-walk pre-filter before the chunk culling pass.

This allows entire branches of the spatial hierarchy to be rejected earlier, reducing unnecessary chunk processing.

The optimization is particularly useful when large portions of a Gaussian capture fall outside the visible region.

Better Capture Cooking

The editor's Gaussian cook sheet now provides more control over how captures are prepared, along with additional information about their expected memory and storage requirements.

You can now choose between automatic, disabled, one-level, or two-level coarse LOD generation.

Before starting a cook, the editor displays additional information about the capture, including:

• Source splat count and spherical-harmonics information.
• Estimated cooking memory requirements.
• Warnings when a cook may cause heavy memory swapping.
• Estimated packed runtime size.
• Whether the resulting capture will load resident or page from disk.
• Runtime working-set information.

Memory and storage estimates now use the correct binary-size labels, MiB and GiB.

We've also added streamed bounds calculation when recentering large PLY captures, improving the preparation workflow for large datasets.

Better Task Progress and Cancellation

Gaussian cooking operations are now tracked through the editor's Tasks panel.

You can follow the current stage of a cook, including reading, cooking, chunking, coarsening, and writing.

Queued and running cooks can also be cancelled, with partially generated files cleaned up safely.

Gaussian placement and loading operations now appear as editor tasks as well, making it easier to follow long-running operations.

Gaussian Runtime Information

The Inspector now provides additional information about how a Gaussian entity is being handled by the engine.

You can inspect its runtime memory and streaming characteristics, making it easier to understand whether a capture is resident, progressively loaded, or paged from disk.

This provides more visibility into the runtime cost of large Gaussian scenes and helps developers make informed decisions when preparing content for different devices.

More Rendering and Debugging Controls

We've expanded the editor's Splat Debug menu with additional controls for investigating rendering performance and visual fidelity.

The new options include:

• Gaussian paging and LOD visualization.
• Working-set size selection.
• Forced splat paging.
• Splat blend caps of 64, 128, or unlimited.
• Splat-pixel anti-aliasing.
• Splat-pixel tone mapping.
• Crisp splat kernel rendering.
• Paging, level, and budget diagnostics.

These controls make it easier to compare rendering behavior, investigate visual artifacts, and tune Gaussian captures for different hardware.

We've also added an automated large-capture test workflow that can import, cook, place, and render Gaussian captures from multiple camera positions.

Additional Editor Improvements

The editor can now open a project folder containing project.yml even if its Xcode project has not been generated yet.

This makes it easier to open newly created, cloned, or manually configured projects without first running XcodeGen.

New projects also use the editor's compatible Untold Engine dependency and include the necessary setup for Code Components.

Documentation and Examples

To help developers get started with the new extension system, we've included a complete sample project and a new Code Components authoring guide.

The documentation includes examples covering:

• Project-local Code Components.
• Reusable Swift plugin packages.
• Custom entity types and entity-owned components.
• Editor menu extensions.
• Editor-only representations.
• Interactive viewport handles.

These examples demonstrate how the different extension APIs work together and provide a starting point for building your own gameplay systems and editor tools.

What's Next?

With v0.20.0, Untold Engine is taking another step toward becoming a platform where developers can build not only games and immersive experiences, but also the tools they need to create them.

UntoldComponentKit lays the foundation for a more extensible engine and editor, allowing developers to introduce new functionality through native Swift code and share reusable tools with the community.

At the same time, the improvements to Gaussian splat rendering and capture workflows continue to make it easier to work with large, complex scenes across different devices.

Thank you to everyone contributing to the project (@miogds), testing new features, and sharing feedback.

We're looking forward to seeing what you build with the new extension system!