Untold Engine and Untold Editor v0.19.0 are now available

[untoldengine]

This release represents a major step forward for Gaussian splats in Untold Engine, expanding them from a rendering feature into a much more complete engine subsystem. The work now covers the full pipeline—from cooking and asset storage to runtime streaming, rendering, memory management, culling, and debugging. A special thanks to @miogds for the improvements done with the Gaussian Splat system in the engine.

The editor has evolved alongside the engine, bringing the new Gaussian workflow directly into the UI while also introducing major improvements to viewport navigation, asset importing, scene management, and general workflow.

---

Untold Engine v0.19.0

A native asset format for Gaussian splats

One of the biggest additions in this release is .untoldgs version 3, a native Untold Engine asset format designed specifically for Gaussian splats.

Rather than treating a Gaussian capture as one large buffer that must be loaded all at once, .untoldgs divides the capture into independently loadable chunks. The format includes page-aligned chunk payloads, per-chunk validation, a chunk index and tree structure, and compact 16-byte splat records containing position, rotation, scale, color, and opacity.

Spherical harmonics can also be stored at different degrees, and the runtime can inspect the header and chunk index of very large captures without loading the entire asset into memory.

This gives the engine a much stronger foundation for streaming and rendering large Gaussian scenes.

Cooking Gaussian captures directly from the CLI

Gaussian .ply and .spz captures can now be converted directly into .untoldgs assets using untoldengine export, without having to pass through Blender first.

The cooking pipeline exposes controls for chunk size, spherical harmonics, opacity pruning, splat budgets, cropping, capture transforms, up-axis conventions, and other properties of the resulting asset.

Progressive LOD tier sets can also be generated during cooking, while --splat-max-count makes it possible to target different memory and performance budgets depending on the device.

The exporter reports how many splats were kept or removed during the process, making it easier to understand how the source capture was transformed into the final runtime asset.

Chunked loading and runtime streaming

The runtime Gaussian path has grown considerably beyond the original whole-buffer .ply workflow.

.untoldgs assets can now be loaded through setEntityGaussian, including asynchronous and byte-range loading paths. Because the format is chunked, the engine can request individual portions of a capture rather than requiring the entire asset to remain resident.

Disk paging and per-chunk LOD tiers allow very large captures to scale to the memory available on the target device. Packed Gaussian chunks can also be decoded directly on the GPU, with a CPU fallback available when needed.

The engine keeps the .untoldgs chunk table available at runtime as well, allowing individual chunks to participate in visibility and culling decisions before their splats reach the more expensive parts of the rendering pipeline.

Progressive Gaussian tier sets are supported too, providing another way to scale large captures according to runtime requirements.

A shared Gaussian rendering path

The Gaussian renderer itself has also changed substantially.

Previously, Gaussian entities were treated more independently. The renderer now builds a shared visible working set across Gaussian entities and performs a shared sort and draw.

This becomes especially important when multiple Gaussian assets overlap. Splats from different entities can now participate in the same depth ordering instead of being blended as separate objects.

Gaussian pass sizing is also derived from the actual GPU-visible splat count rather than a stale readback, keeping rendering consistent from frame to frame.

Before splats reach the per-splat rendering stages, entire .untoldgs chunks can now be rejected through chunk-level visibility tests, including frustum and stereo-aware culling as well as HZB-assisted occlusion culling.

Together, these changes reduce the amount of Gaussian data that needs to reach the more expensive stages of the rendering pipeline.

Better Gaussian debugging tools

As the Gaussian pipeline has become more sophisticated, being able to understand what it is doing has become increasingly important.

New Gaussian debug switches make it possible to progressively disable parts of the pipeline—including chunk culling, HZB occlusion, working-set budgeting, and mesh occluder shells.

This makes it much easier to isolate rendering problems instead of treating the Gaussian pipeline as a black box.

Mesh and Gaussian twins

Another important addition in v0.19.0 is the ability to associate a traditional mesh asset with its Gaussian counterpart.

.untold assets can now contain a gaussianAsset reference pointing to a corresponding .untoldgs capture. At runtime, the engine can discover and load that relationship automatically, while scenes serialize Gaussian assets as lightweight references rather than embedding resident Gaussian data directly.

The engine also provides the pieces applications need to transition between the two representations. Meshes can fade using a screen-door transition, Gaussian opacity can be controlled independently per entity, and meshes can remain as depth-only occluder shells while their Gaussian representation is visible.

Untold Engine deliberately doesn't dictate when that transition should happen. Applications can build their own distance-, visibility-, or context-driven transition systems on top of these components.

Linking Gaussian captures to existing assets

To support mesh/Gaussian workflows without forcing existing assets to be completely re-exported, v0.19.0 introduces UntoldAssetPatcher.

Existing .untold files can have Gaussian asset links added, removed, or inspected while preserving unrelated chunks in the asset.

The CLI exposes this through the new untoldengine gaussian-link command, making it possible to cook a Gaussian capture independently and then associate it with an existing mesh asset as part of an asset-processing pipeline.

Better support for multi-model assets

The asset pipeline now handles Blender scenes containing multiple independent models more naturally.

Instead of forcing everything into a single .untold asset, these scenes can be exported as an .untoldpack. Each independent model receives its own .untold file, while the pack manifest describes how those assets belong together.

At runtime, an .untoldpack can be passed through the normal mesh-loading path, allowing the engine to reconstruct the collection without requiring application code to manually load every model.

Animation and locomotion improvements

Gaussian rendering isn't the only area receiving attention in this release.

Root motion received several correctness fixes. It's now applied once per anchor on modular assets, translation deltas are applied relative to the root's heading, and root yaw is stripped correctly so rest-rotated roots remain upright.

Animation transitions can now inertialize root-motion velocity, while motion-matching jump frequency is better controlled to keep movement smoother when changing clips.

Foot IK also gained stance locking, along with fixes that keep the foot-lock release frame and catch-up after a re-plant continuous instead of introducing a visible pop.

Asset pipeline and runtime fixes

Several smaller improvements landed alongside the larger systems work.

Packed textures are now exported as separate files, and linked metallic/roughness sockets are handled correctly. Custom environments can be rebaked from the directory they were originally loaded from, while the .untoldgs writer now guards against non-finite splats and checks header sections for overlap.

On the runtime side, concurrent mesh loads in deserializeScene are now bounded to avoid a thread-pool deadlock, and an SSAO self-shadowing issue that caused the result to drift with camera movement has been fixed.

Documentation and testing

The new systems are accompanied by expanded documentation covering the Gaussian splat streaming architecture, the .untoldgs v3 format, and the gaussian-link workflow.

Test coverage has grown alongside the implementation, covering .untoldgs reading and writing, cooking, chunked loading, shared sorting, working-set budgeting, progressive LOD, .untoldpack, asset patching, root motion, foot IK, and other runtime systems.

Overall

The main story of Untold Engine v0.19.0 is the evolution of Gaussian splats from a rendering feature into a much more complete engine subsystem.

Instead of simply loading a .ply file and rendering its splats, Untold Engine now has a native .untoldgs asset format, a cooking pipeline for .ply and .spz captures, chunked runtime loading with disk paging, GPU decoding, visibility and occlusion culling, shared sorting and rendering, progressive tiers, dedicated debugging tools, and a way to associate Gaussian captures with traditional mesh assets.

Alongside the Gaussian work, v0.19.0 continues to improve the broader engine with multi-model asset support, animation and locomotion fixes, and improvements throughout the asset pipeline.

Together, these changes provide a much stronger foundation for larger Gaussian scenes and more practical real-time spatial visualization workflows.

---

Untold Editor v0.19.0

Untold Editor v0.19.0 brings the engine's new Gaussian splat pipeline directly into the editor, while also introducing significant improvements to viewport navigation, asset importing, scene management, and general workflow.

Gaussian splats in the editor

The editor now has first-class support for the engine's new Gaussian splat pipeline.

Gaussian .ply and .spz captures can be cooked directly into .untoldgs assets from within the editor and loaded as baked splats.

A dedicated Gaussian cook sheet exposes controls for splat budget and source count, capture up-axis, and recentering, allowing captures to be prepared without leaving the app. The cook sheet also reads its budget caps directly from the engine so the editor and runtime stay in sync.

Gaussian assets can be dropped straight into the scene from the asset browser using the same editor loader as other assets. Package folders (.untoldpack) can be placed in the same way through drag-and-drop or double-click.

A new View > Splat Debug menu also exposes the engine's Gaussian debugging switches directly inside the editor, making it much easier to isolate rendering issues while working on a scene.

Reworked viewport navigation

Viewport camera navigation has been rebuilt around familiar Blender-style conventions: scroll to orbit, Shift-scroll to pan, and Cmd-scroll to zoom.

Input is now routed by hit testing rather than through a single global handler, making interaction with the viewport more predictable.

The orbit pivot is smarter as well. It re-anchors using the view ray before navigation, stays close to the camera by preferring the nearest candidate within 5 units, and considers Gaussian splats—not just traditional meshes—when determining what's under the center of the view.

The vertical scroll axis has also been flipped to match expected behavior, and clicking empty viewport space now clears the current selection.

Asset browser and import workflow

The asset browser has received several workflow improvements in v0.19.0.

Models and Gaussian splats can now be dragged directly from the asset browser into the scene. Behind the scenes, the drag payload has moved from a custom UTType to plain public.json, improving drop reliability.

Importing has also been reworked into a cancellable, progress-reporting task. Source files are copied into the project first, and importing no longer automatically cooks the asset.

Instead, .blend and USD imports can be cooked to .untold or .untoldpack on demand, while imported Gaussian .ply captures can be cooked as their own task.

A new Tasks panel in the bottom dock makes this work visible and provides a central place to follow longer-running operations.

Double-click importing has also been added as a shortcut, while lights and primitives now live in the asset browser alongside other asset types.

Safer scene management

Scene switching is now safer.

The editor tracks unsaved changes and prompts before switching away from a dirty scene instead of silently discarding work.

This makes moving between scenes much closer to the workflow you'd expect from a traditional content creation tool while reducing the risk of accidentally losing changes.

Better viewport resizing

Viewport resizing has also been reworked to eliminate visual glitches.

During a resize, the Metal view now pauses and displays a frozen, screen-sized hold frame that is correctly clipped and scaled to the drawable instead of stretching the previous frame.

This keeps the viewport visually stable while the editor window is being resized.

Smaller fixes and improvements

Several smaller improvements round out the editor release.

SSAO parameters have been updated to match the engine's latest tuning, and the content browser now selects a row on the first click.

The editor also builds under Xcode 26 using an @main entry point and now tracks the engine's develop branch directly rather than relying on a pinned release.

Overall

Untold Editor v0.19.0 brings the editor up to par with the engine's new Gaussian splat subsystem.

Cooking, cook-sheet controls, drag-and-drop placement, and pipeline debugging are now available directly inside the editor, making it possible to work with the new Gaussian pipeline without constantly moving between external tools.

Alongside that, viewport navigation has been rebuilt around familiar Blender-style controls, the asset import workflow now includes real task tracking and cancellation, and scene switching is safer with dirty-state tracking.

Together with the viewport, asset browser, and stability improvements, v0.19.0 makes the editor a much more complete front end for Untold Engine's Gaussian and traditional mesh workflows.