# Gaussian-native creation toolset audit

Reviewed September 20, 2026, America/Denver. Research check: September 21, 2026 at approximately 04:02 UTC. This is a documentation and local-source audit of 30 substantial workflow domains, not an exhaustive operator-by-operator audit or a hands-on certification of every Blender/Unreal tool. The reference pages were current official documentation retrieved during this review; Blender pages identified themselves principally as 5.2 LTS and Epic pages as Unreal Engine 5.8. Individual linked versions are retained when the official result uses a versioned URL. Some Blender index pages failed direct retrieval; the cited specific official pages were available through indexed documentation results.

**Recommendation:** build a complete, small Gaussian authoring loop before adding dozens of disconnected panels. The immediate priorities are precise multi-object editing, connecting the existing sparse-edit foundation to the browser builder, typed reusable behaviors, trustworthy asset inspection, and measured rendering budgets. Skeletal animation, relighting and streamed worlds are separate engineering programs with explicit acceptance gates.

No parity with Blender or Unreal is claimed. This document proposes original workflows informed by documented capabilities, not copied source code or UI assets. No 100× speedup, photorealism, automatic whole-world reconstruction, general physics, working public multiplayer, or paid export service is established here.

## September 23 source update: what changed and what to build next

This addendum records newer source behavior without changing the September 20 research provenance. Public availability is established separately by a deployment receipt.

| Workflow | Current Guassia implementation | Comparison and next useful Gaussian-native step |
| --- | --- | --- |
| Scene navigation and placement | Orthographic top-down and navigable perspective authoring view; mouse drag, WASD/Q/E, touch movement, conservative object picking, frame selection and Shift-click placement. Instance transforms preserve original source data. | Blender's mature viewport/transform tools remain broader. Add shared world/local gizmos, pivot modes, support-aware snapping, selection isolation and a single editor-wide undo transaction history. |
| Large Gaussian worlds | Five million authored instantiated Gaussians, one million per asset, independent source-library and render working sets. Device-tier preview samples preserve stored/exported sources. Never-shown instances avoid generator allocation. | This is not Unreal World Partition or a streamed Gaussian renderer. Introduce covariance-aware cluster bounds, asynchronous byte-range/chunk transport, per-cell residency and reversible projected-error LOD. |
| Game behavior | Optional Guassia Script v1: validated event/action JSON, variables, conditions, bounded instructions/signals, instance-state commands and debug information. New worlds have no mandatory script. | Unreal's Blueprint/C++ and Blender's Python ecosystems are much larger. Build a visual graph that compiles to this same validated representation, source-aware breakpoints, reusable behavior assets and versioned command APIs before widening privileges. |
| Native distribution | A packaged desktop-editor source and per-user installer build path; fixed-origin offline content, sandboxed renderer, preserved project storage and signed-manifest update policy. Artifact/installation verification is tracked separately. | Mature editors have complete platform-specific install/update pipelines. Add code signing, native OS CI, clean-install/upgrade/rollback tests, real update delivery and an explicit migration backup. Packaging does not make Gaussian memory unbounded. |
| Creator marketplace | Server and account/entitlement foundations are under development; prepared forms or checkout interfaces do not establish live account, payment, payout or delivery services. | Game storefronts require authoritative entitlements, refund/revocation behavior, tax/payout support, moderation and publisher operations. Keep player content/identity out of game scripts and test ledger idempotency before enabling paid flows. |

### Prioritize reliable world scale before a larger resolution label

1. **GPU instance batching and actual profiling.** The prior 2,048-object fixture exposed per-instance overhead; the new dense five-million-authored fixture still reported 84.2 ms CPU plus awaited-renderer work with only 350,000 preview splats in one headless Chrome observation. This is useful failure evidence, not a speed claim. Measure CPU/GPU separately, identify generator/sort/blend costs, and compare identical scenes before and after batching.
2. **Cluster streaming and quality-aware LOD.** Store spatially coherent chunks and parent approximations; schedule I/O outside the render loop; expose residency, pending requests and evictions. Test a walk through a world larger than its cache with constrained network/memory and cancel rapid travel safely. The existing preview sampling is deliberately not called hierarchical LOD.
3. **Close-range quality preservation.** Build a sign, arch, thin door, foliage and overlapping glass regression set. Preserve SH where the capture supplies it, distinguish radiance from material color, and show original versus current preview counts. A 4K/8K output cannot restore removed detail; use matched view/render settings and a defined visual error tolerance.
4. **Animation plus navigation.** Start with one skinned Gaussian character and one articulated door. Require correct covariance deformation, clip blending/seeking, event timing and invisible collision proxies. Add bounded navigation routes and obstacle handling before promising convincing crowds or military simulation.
5. **Large-world coordinates and provenance.** Use cell-local positions plus high-precision geographic origins; publish the map coordinate system, source license, capture date, processing history and uncertainty. Georeferencing or satellite imagery alone does not reconstruct a physically correct navigable 3D scene. Separate visible source data from gameplay and private capture data.
6. **Creator iteration.** Make the same project run in editor, browser export and desktop with scene-aware error links, version migrations and repeatable tests. Add optional prefabs/components and graph authoring, without forcing a story, music room or paid account into a blank local project.
7. **Trustworthy commerce.** Validate account ownership, signed asset manifests, immutable purchase records and download authorization server-side. Asset licenses, engine notices and creator copyright are different records. A hidden string is provenance, not DRM; paid upload/revenue-share operations need actual settlement/refund evidence before revenue is reported.

Success should mean a creator can import a detailed asset, inspect it at arm's length, place many shared instances, author behavior, play, export, reinstall/update and reopen without losing detail or ownership information. That complete loop is a better near-term differentiator than claiming every feature of established engines.

## Representation contract

Every domain below must use the same source-of-truth model:

```text
Immutable local-space Gaussian asset + stable IDs + provenance
    → shared instance transform / appearance / gameplay references
    → ordered, reversible sparse edit layers and structured deformation
    → visible Gaussian renderer

Separate invisible collision / navigation / acoustic proxies
    → gameplay and simulation
    → instance or deformation-state changes
```

1. Ordinary move, rotate, scale, duplicate, tint and opacity edits modify references or instance records, never all source positions. They require no mesh rebuild, UV unwrap or neural retraining.
2. Gaussian means, anisotropic scale/orientation or covariance, opacity and appearance stay authoritative. A mesh may be an explicitly imported conversion source or invisible auxiliary proxy; it is not silently substituted for Gaussian visuals.
3. Attribute brushes produce sparse deltas or masks. Expensive operations are explicit, cancellable and previewable. Baking creates a new asset identity and preserves the source.
4. Shared asset edits and instance-local overrides must be visibly different scopes. Editing one tree must not unexpectedly alter every tree.
5. Rigid transforms apply covariance consistently: for affine linear part `A`, `Σ′ = A Σ Aᵀ`. Ordinary transforms use renderer state; only explicit bake writes a derived covariance dataset. Future deformation must preserve this principle.
6. Source provenance and actual attribute support are inspectable. Baked radiance color is not silently relabeled as albedo, and missing normals/SH/material channels are not invented.
7. GPU buffers, caches, simulation, saved documents and public delivery are distinct. A partial-upload request counter does not measure actual driver traffic; CPU elapsed time is not GPU execution time.

## What currently exists, and where

The following observations come from local source and `BUILD-STATUS.md`, not from assuming every engine prototype is integrated into the public builder:

| Evidence | Observed scope | Consequence for the roadmap |
| --- | --- | --- |
| `gaussia/project.js`, `asset-workbench.js`, `authoring-tools.js` | Empty-room defaults, shared-source instances, numeric transforms, tint/opacity, undo/redo, optional story/NPC/audio controls and groups. Existing group operations move/duplicate members. | Extend the existing editor transaction path instead of creating a second project model. |
| `gaussia/asset-pipeline.js`, `asset-quality.js`, `asset-edit.js` and their tests | Static GLB sampling; anisotropic PLY; native GAsset; flat image art; detail-prioritized reduction; source-preserving import option; cleanup to a copy; covariance-aware explicit bake. | Asset quality tools are bounded foundations, not sculpting, 3D reconstruction or PBR capture. |
| `gaussia/asset-workbench.js` | Lazy Gaussian inspection at fit, player-eye and arm-length distances. | Preserve the lazy initialization; add quality fixtures and comparisons before raising budgets. |
| `engine/gaussian-core.js` | Immutable source ownership, ordered sparse color/opacity/deletion/semantic layers, history and dirty ranges. | A real foundation exists. The browser builder must integrate it rather than claim to have no layers or rebuild them independently. |
| `engine/gaussian-render-bridge.js` | Shared sources, instance overrides, anisotropic transforms, fog/dissolve and a bounded per-asset sparse color/opacity table, currently at most 256 edits. Metrics explicitly exclude measured GPU time. | Bridge support is limited; a million-point brush cannot simply be routed through the current small table. |
| `gaussia/asset-pipeline.js` | `inspectBuilderAsset` rejects nonempty edit layers and asks for a bake before builder import. | Engine-level layers are not yet a normal round-trippable browser authoring workflow. Fixing this integration gap is a major priority. |
| `engine/spatial-index.js` | Local-space hierarchy of Gaussian means with original-index indirection; bounds exclude covariance/radius and instance transforms. | Useful selection foundation, not ready-made world culling, surface picking, collision, GPU selection or rendering LOD. |
| `engine/native-format.js` | Versioned binary GAsset/GWorld chunks with CRC32; raw storage, access within an already loaded buffer. | Not compressed network streaming. CRC detects accidental corruption and is not authentication. |
| `gaussia/story-schema.js`, `story-runtime.js`, `spatial-audio.js` | Optional validated objectives, achievements, gates, transitions, notes/doors, basic NPC behavior and bounded sound. | Useful game primitives, not arbitrary visual scripting, navmesh pathfinding or general rigid-body simulation. |
| `gaussia/export-world.js`, `import-world.js`, `authoring-export.test.mjs` | Portable site ZIPs preserve authored references and original audio bytes; failures are checked before restoration writes. | Reuse this packaging boundary and schema migration discipline for future asset layers/graphs. |
| `gaussia/BUILD-STATUS.md`, `i18n.js`, `education-license.js` | Partial 21-locale UI, 20 distinct languages, RTL and English fallback; optional education entitlement foundations only. | Do not imply complete translation, public education onboarding, accounts, payments or activated cloud builds. |

The latest source revision allows 2,048 objects and a 2 MiB UTF-8 project description, with independent limits of 16 NPCs, 24 rooms, 16 imported asset definitions, 1,000,000 Gaussians per asset and 5,000,000 total authored instantiated Gaussians. The source library has a separate 5,000,000-Gaussian ceiling. These are product limits, not universal performance guarantees; the private capacity fixture has passed browser import/start/render checks, with public deployment tracked separately. At the maximum object count, five million authored Gaussians average about 2,441 per object, so 2,048 million-splat captures are not implied. Device-tier source sampling is non-destructive and explicitly separate from exported source quality; see GAUSSIAN-CAPACITY.md. This remains bounded preview sampling, not hierarchical LOD or streaming.

The private capacity fixture uses 2 rooms with 1,024 non-solid static instances each, sharing one 100-Gaussian source (204,800 instantiated Gaussians). Its 5,600 source-array bytes remain unchanged across transform edits and runtime updates, with one source upload; encoded GAsset size is 6,072 bytes. The portable ZIP roundtrip preserves all 2,048 instance records and restores one source. Node CPU bookkeeping on the measured Ryzen 9 5900HS host took a median 5.37 ms to validate the project and 0.014 ms for one transform edit plus mocked dispatch; unchanged static frames dispatched no instance updates. These synthetic in-memory measurements exclude the renderer, GPU, browser, VRAM and actual frame rate. They establish schema/storage and update-path behavior only. The reproducible fixture and measurement scripts are `scripts/build-large-scene-qa.mjs` and `scripts/benchmark-object-limits.mjs`. Runtime room/identity indexes and dirty-instance updates avoid a whole-object scan on ordinary static frames; collision remains an active-room scan, without a spatial broad phase.

In the separate live-browser capacity check, the 2,048-object fixture imported, started and rendered without a reported loading error. At an automatic 1,181 × 780 drawing buffer, with 1,024 objects in the active room, the runtime diagnostic showed observations of 162.8 ms and 248.1 ms for CPU work plus the awaited renderer. Those observations are **not smooth interactive performance**, are not isolated GPU timings, and are not a percentile benchmark. They establish that the capacity path works while revealing substantial renderer/instance cost. The raised limit is advanced authoring headroom; practical scene density must remain device-tested and much lower where necessary.

The multi-object transform panel and NPC controls are **source-implemented and covered by focused unit tests, with selected authoring workflows verified in a browser; no public deployment is claimed here**. Selection supports same-room move, pivot yaw/uniform scale, grid snap, origin alignment/distribution and batch appearance, with routes following objects and existing undo/redo. NPC controls include visual route authoring, guard/companion/flee/watcher presets, field of view, line of sight, last-known-position memory, home bounds, contact/reset controls and route patterns. Automated checks cover transform/source immutability, route propagation, perception, state transitions and authoring normalization. Selected browser checks do not certify every combination or device; formal public-delivery receipts and the latest complete test totals remain separate release records.

## Capability matrix

Status: **Available** means a bounded local implementation is present; **Source-tested** means newly implemented source passed focused automated tests but browser/public verification remains separate; **Foundation** means reusable lower-level code exists but the complete creator workflow does not; **Proposed** means not implemented. A milestone is a dependency gate, not a delivery-date promise. Each official link supports the referenced product workflow; the Gaussian design is our proposal.

### Authoring and assets

| Domain and official reference | Gaussian-native counterpart | Current evidence | Next dependency, milestone and acceptance test |
| --- | --- | --- | --- |
| **01. Workspace, selection and inspection.** Unreal organizes specialized editors around a primary level editor. [Tools and Editors](https://dev.epicgames.com/documentation/unreal-engine/tools-and-editors-in-unreal-engine) | One selected entity/asset/layer identity shared by viewport, outliner and inspector; lazy close-range Gaussian preview; explicit edit/play modes. | **Available, bounded:** builder room/object lists, numeric inspector and lazy preview; not a general dockable workspace or full 3D transform gizmo. | **M0:** shared selection store and command history. Keyboard selection, focus, frame-selection and edit/play round trip must retain the same IDs without initializing a hidden render loop. |
| **02. Precision transforms, snapping and alignment.** Blender distinguishes snapping individual origins from offsetting a selection together. [Snap](https://docs.blender.org/manual/en/latest/scene_layout/object/editing/snap.html) | Transform selected instance records around a declared pivot. Offer object-origin grid snap first, then surface/extent-aware snapping using Gaussian bounds. | **Available:** single-object numeric transforms and group move. **Source-tested:** same-room multi-edit panel; browser verification in progress, no deployment claim. | **M0:** pure edit planner, one transaction, visible origin-vs-surface label. Hash source arrays before/after 100 transforms; expect identical bytes. Undo must restore NPC routes, selection and all instance values. |
| **03. Asset library, prefabs and overrides.** Blender assets organize reusable data; library overrides separate local property changes from linked data. [Asset Libraries](https://docs.blender.org/manual/en/5.2/files/asset_libraries/introduction.html), [Library Overrides](https://docs.blender.org/manual/en/5.1/files/linked_libraries/library_overrides.html) | Content-addressed Gaussian assets; reusable entity assemblies referencing the source once; per-instance appearance and sparse deltas; explicit update/conflict preview. | **Available:** local library and source-sharing duplicates/groups. **Proposed:** versioned prefab definitions, dependency updates and portable catalog metadata. | **M0 → M1:** stable IDs plus dependency manifest. Duplicate 100 instances without 100 source copies; update a prefab while retaining an overridden tint; report a deleted referenced child before commit. |
| **04. Modeling and constructive operations.** Unreal Modeling Mode separates creation, transformation, deformation, processing and other mesh operations. [Modeling Tools](https://dev.epicgames.com/documentation/unreal-engine/modeling-tools-in-unreal-engine) | Direct Gaussian primitives, seeded surface sampling, cluster cuts, instanced arrays and optional density/SDF-based constructive operations. No automatic Gaussian-to-mesh round trip. | **Available:** box, sphere, arch and pillar primitives; explicit combine/bake. **Proposed:** editable primitive parameters and constructive field operations. | **M1:** parameterized source generators and bounds. Change an arch opening without retraining; inspect close silhouettes; retain original source on bake. Field-based boolean results must be labeled approximate. |
| **05. Sculpting and deformation brushes.** Blender provides brushes, masks, gesture tools and adaptive sculpt workflows. [Sculpting Introduction](https://docs.blender.org/manual/en/latest/sculpt_paint/sculpting/introduction/index.html), [Brushes](https://docs.blender.org/manual/en/latest/sculpt_paint/brush/introduction.html) | Brush selection of splat IDs; sparse mean/covariance displacement or a structured deformation field; symmetry and falloff; bounded local densification. | **Foundation:** spatial mean index and sparse attributes. **Proposed:** positional deformation layer, GPU brush and sculpt UI. | **M1 → M2:** transformed ellipsoid picking and persistent IDs. A small brush changes only selected regions; cancel restores baseline; thin structures survive; edit cost/bytes scale with affected working set. |
| **06. Painting, masks and semantic labeling.** Blender can paint color attributes and derive masks from color. [Sculpt Painting](https://docs.blender.org/manual/en/latest/sculpt_paint/sculpting/introduction/painting.html) | UV-free color/opacity/material/semantic brush layers, optional projected decals with explicit coordinate space; local edit masks. | **Available:** instance tint/opacity. **Foundation:** core sparse color, opacity, deletion and semantic layers, limited bridge table. **Proposed:** browser brush/layer UI. | **M1:** end-to-end layer serialization and per-instance scope. Paint one instance without altering siblings; toggle/reorder layers; reload ZIP and compare resolved values and immutable base bytes. |
| **07. Modifier stack.** Blender supports ordered non-destructive operations and an explicit apply step. [Modifiers](https://docs.blender.org/manual/en/latest/modeling/modifiers/introduction.html) | Reorderable Gaussian tint/mask/noise/deformation/LOD operators over immutable data, with dependency revisions and dirty-region invalidation. | **Foundation:** core attribute layer order/toggles/history. **Proposed:** generic modifier schema, browser stack and incremental evaluator. | **M1 → M2:** typed operator contract and evaluation cache. Reordering opacity then mask must reproduce documented semantics; disabled layers cause no visual change; bake generates a new asset. |
| **08. Procedural geometry and scattering.** Blender Geometry Nodes defines node-based geometry operations; Unreal PCG builds procedural content workflows. [Geometry Node Editor](https://docs.blender.org/manual/en/latest/editors/geometry_node.html), [PCG Framework](https://dev.epicgames.com/documentation/unreal-engine/procedural-content-generation-framework-in-unreal-engine) | Typed Gaussian-set and instance-set nodes: filter, transform, sample, scatter, merge references, assign semantics and output. Seeded determinism and bounded counts precede arbitrary graphs. | **Available:** procedural primitive constructors in code. **Proposed:** creator graph, incremental evaluation and exposed inputs. | **M1 → M2:** node IR and budget estimator. Same seed produces same instance IDs/positions; changing tint does not regenerate placement; an excessive scatter refuses before allocation. |
| **09. Cleanup and detail allocation.** Unreal's modeling processing tools distinguish inspection and optimization categories. [Modeling Tools](https://dev.epicgames.com/documentation/unreal-engine/modeling-tools-in-unreal-engine) | Preserve Gaussian attributes; preview masks for opacity/scale/outliers; spend detail on small features/color boundaries rather than globally increasing count. | **Available:** detail-prioritized import, preserve mode, bounded cleanup-copy tools and near preview. **Proposed:** persistent cleanup layers and visual error heatmap. | **M1 → M4:** source feature fixtures and support-aware bounds. Compare equal-budget lettering, thin doors and transparent overlaps from eye/arm distance; preserve a protected thin feature and report uncertain outliers. |
| **10. Import, reimport and provenance.** Unreal Interchange describes customizable asynchronous import pipelines and conflict handling. [Interchange](https://dev.epicgames.com/documentation/unreal-engine/importing-assets-using-interchange-in-unreal-engine) | Parse → inspect attributes/units → choose preserve or explicit derived conversion → preview → commit. Reimport maps stable IDs or requires an explicit conflict decision; all derived assets retain provenance. | **Available:** PLY/GAsset/static GLB/image import, progress/cancel and local storage. **Proposed:** reimport mapping, SH preservation and richer material/bone channels. | **M1:** format capability table, content hash and unit metadata. Malformed input/cancel leaves library unchanged; unsupported channels are disclosed; photo import remains flat art unless a separate reconstruction pipeline is deliberately invoked. |

### Animation, appearance and simulation

| Domain and official reference | Gaussian-native counterpart | Current evidence | Next dependency, milestone and acceptance test |
| --- | --- | --- | --- |
| **11. Rigging and skinning.** Blender's Armature modifier and Unreal Control Rig bind controls to articulated motion. [Armature](https://docs.blender.org/manual/en/latest/modeling/modifiers/deform/armature.html), [Control Rig](https://dev.epicgames.com/documentation/unreal-engine/control-rig-in-unreal-engine) | Skeleton asset, inverse bind transforms, Gaussian bone weights and GPU deformation of means/covariance; source stays in bind pose. | **Available:** rigid grouped figures and authored demo choreography. **Proposed:** general skinned import, weights, retargeting and rig authoring. | **M3:** skeleton schema and material/normal handling. Two-bone elbow fixture across extreme poses must not collapse, leave visible gaps or mutate bind data; clip import/export preserves timing and weights. |
| **12. Keyframes, curves and clips.** Blender's Graph Editor edits property curves; Unreal Sequencer binds tracks to scene objects. [Graph Editor](https://docs.blender.org/manual/en/5.2/editors/graph_editor/introduction.html), [Sequencer](https://dev.epicgames.com/documentation/unreal-engine/unreal-engine-sequencer-movie-tool-overview) | Stable property paths for transforms, layer weights, materials, emitters and cameras; reusable clips and deterministic absolute-time sampling. | **Available:** simple spin/bob and separately authored music choreography. **Proposed:** unified browser timeline for arbitrary world properties. | **M0 → M3:** reflected property registry and transport. Seeking directly to t=10 must equal forward playback at t=10; no accumulation drift; delete an animated target with explicit reference repair. |
| **13. Constraints, rig controls and IK.** Unreal Control Rig exposes controls and manipulators independent of animation tracks. [Control Rig Quick Start](https://dev.epicgames.com/documentation/unreal-engine/how-to-create-control-rigs-in-unreal-engine) | Look-at, parent/aim/limit constraints operate on transforms or bones; solve a bounded dependency graph, not splat topology. | **Proposed:** general constraint graph and IK. Current rigid NPC movement is not this system. | **M3:** transform hierarchy, update order and cycle detection. Foot/hand target fixture meets tolerance without jitter; cycle errors name involved controls; disabling a constraint restores authored pose. |
| **14. Materials and appearance graphs.** Unreal PBR distinguishes physical surface inputs. [Physically Based Materials](https://dev.epicgames.com/documentation/unreal-engine/physically-based-materials-in-unreal-engine) | Explicit radiance-only and relightable classes; Gaussian/material channels for albedo, roughness, normals and emission; triplanar/world coordinates; small typed shader graph. | **Available:** baked/DC color, tint/opacity and Gaussian effects. **Proposed:** full material channels, lighting model and material graph. | **M4:** versioned attribute contract plus renderer support. Material inspection must identify missing channels; a radiance capture does not become plausible PBR merely because a roughness slider is shown. |
| **15. Lighting, shadows and exposure.** Unreal documents measurable light units separately from material properties. [Physical Lighting Units](https://dev.epicgames.com/documentation/unreal-engine/using-physical-lighting-units-in-unreal-engine) | Gaussian-aware direct lighting, exposure and opacity/surface shadow methods; invisible proxies may support shadows, disclosed as such. | **Available:** stylized reactive light/effect objects and fog. **Proposed:** physically grounded relighting and dynamic shadows. | **M4:** normals/albedo or a documented radiance fallback. Test moving flashlight, changing light direction and day/night against calibrated fixtures; distinguish emitted visual particles from actual illumination of surrounding assets. |
| **16. Particles, fog and visual effects.** Niagara groups reusable emitters and modules into effects. [Getting Started in Niagara](https://dev.epicgames.com/documentation/unreal-engine/getting-started-in-niagara-effects-for-unreal-engine) | Bounded Gaussian particle pools, spawn/update modules, deterministic seeds, field forces and lifetime/opacity curves; compatible depth composition. | **Available:** optional fog/dissolve and music-reactive components. **Proposed:** general particle graph and compute simulation. | **M2 → M4:** pool allocation, sorting/contribution budget and event bindings. Worst-case emission stays within memory budget; restart repeats seeded behavior; overlapping translucent effects do not destabilize exposure. |
| **17. Collision and queries.** Unreal separates collision responses and trace responses. [Collision Overview](https://dev.epicgames.com/documentation/unreal-engine/collision-in-unreal-engine---overview) | Invisible boxes/capsules/convex or SDF proxies with independent layers; rays query the chosen proxy or explicit visual-picking structure. | **Available:** separate mathematical compound boxes, walkable arch openings and proxy line of sight. **Proposed:** richer shapes, swept queries and response channels. | **M0 → M3:** proxy coordinate contract. Scaling/rotating an instance moves its proxy correctly; doorway is walkable while frame blocks; collision edits leave rendered source hashes unchanged. |
| **18. Rigid-body, soft-body and fluid physics.** Blender's rigid-body simulation changes object motion without deforming the shape. [Rigid Bodies](https://docs.blender.org/manual/en/latest/physics/rigid_body/introduction.html) | Rigid solver outputs instance transforms; cloth/soft/fluid solvers output structured Gaussian deformation or particles. Visual data and simulation resolution are independent. | **Foundation:** deterministic ground-plane controller in `engine/topdown-game.js`; **not** general rigid-body simulation. General joints, CCD, cloth and fluid are **Proposed**. | **M3:** choose/validate a bounded solver and fixed-step contract. Stack/drop/contact fixtures, pause/resume and variable render FPS agree within tolerance; no per-step rewrite of rigid source arrays. |
| **19. Navigation and movement planning.** Unreal derives tiled navigation from collision and distinguishes pathfinding from avoidance. [Basic Navigation](https://dev.epicgames.com/documentation/unreal-engine/basic-navigation-in-unreal-engine), [Avoidance](https://dev.epicgames.com/documentation/unreal-engine/using-avoidance-with-the-navigation-system-in-unreal-engine) | Navigation graph/grid derived from invisible proxies, dirty-cell rebuilding, local avoidance and traversable links; no visual polygon requirement. | **Available:** basic room movement and authored patrol points. **Proposed:** robust pathfinding across rooms and moving obstacles. | **M3 → M5:** collision layers and room/world coordinates. NPC reaches an unobstructed destination around a U-shaped barrier; closing one door invalidates only affected navigation cells. |
| **20. AI and behavior authoring.** Unreal Behavior Trees compose patrol, perception and pursuit. [Behavior Tree Quick Start](https://dev.epicgames.com/documentation/unreal-engine/behavior-tree-in-unreal-engine---quick-start-guide) | Typed state/behavior graphs operate on entities, conditions and events; perception queries proxies/visibility; Gaussian animation is a presentation output. | **Available:** basic patrol/pursuit/look-away. **Source-tested:** visual routes, companion/flee behavior, FOV, line of sight, target memory, home bounds and contact/reset controls. Browser verification in progress; general graph remains **Proposed**. | **M2 → M3:** event model and deterministic simulation. Look-away figure remains still while genuinely visible, including partial visibility policy; occluded target does not grant sight; transitions reset on restart. |

### Games, worlds, delivery and operations

| Domain and official reference | Gaussian-native counterpart | Current evidence | Next dependency, milestone and acceptance test |
| --- | --- | --- | --- |
| **21. Gameplay and visual scripting.** Blueprints connect typed data, components and execution events. [Blueprints Overview](https://dev.epicgames.com/documentation/unreal-engine/overview-of-blueprints-visual-scripting-in-unreal-engine) | Validated event/action graph over ECS-style components, with reflected Gaussian opacity/tint/layer/cluster operations, no arbitrary uploaded code by default. | **Available:** bounded declarative story/objective/gate/transition systems. **Proposed:** typed general graph, reusable behavior assets and debugger. | **M1 → M2:** registry of types, stable references, event budget and graph validation. Build a key/door/ending game without code; reject cycles that exceed a step budget; replay produces the same state. |
| **22. Level composition and data layers.** Unreal Data Layers organize scene content and runtime visibility/loading. [World Partition Data Layers](https://dev.epicgames.com/documentation/unreal-engine/world-partition---data-layers-in-unreal-engine) | World → region → cell → entity → shared asset/cluster; semantic scene layers distinct from Gaussian attribute edit layers; prefab instances stay linked. | **Available:** bounded room list, visibility and authored progression. **Proposed:** region/cell authoring and general layer hierarchy. | **M1 → M5:** stable world coordinates and ownership. Hide an environment layer without disabling its required gameplay proxy unless requested; move a prefab across cells without duplicating its source. |
| **23. Streaming, LOD and residency.** Unreal partitions worlds into streamable cells and uses HLOD for distant representations. [World Partition](https://dev.epicgames.com/documentation/unreal-engine/world-partition-in-unreal-engine), [HLOD](https://dev.epicgames.com/documentation/unreal-engine/world-partition---hierarchical-level-of-detail-in-unreal-engine) | Chunked Gaussian cluster hierarchy with representative Gaussian LOD, asynchronous fetch/decode, measured error and VRAM cache eviction. Do not copy Unreal's merged-mesh visual proxy as the authoritative Gaussian representation. | **Foundation:** native chunk directory and local mean index. **Available:** room visibility/audio caching. Full geometry streaming and hierarchical visual LOD are **Proposed**. | **M4 → M5:** support-aware cluster bounds, network chunk reader and allocation telemetry. Traverse a world larger than cache; peak memory stays bounded; canceled/out-of-order fetches never resurrect stale chunks; crossfade avoids visible popping. |
| **24. Cameras, cinema and music-video timelines.** Sequencer organizes object, character and camera tracks; audio tracks support fades and object attachment. [Sequencer](https://dev.epicgames.com/documentation/unreal-engine/unreal-engine-sequencer-movie-tool-overview), [Audio Track](https://dev.epicgames.com/documentation/unreal-engine/cinematic-audio-track-in-unreal-engine) | One deterministic timeline for camera rails, cuts, object/layer changes and audio-reactive envelopes, evaluated identically in interactive playback and offline export. | **Available:** perspective/orthographic bridge and separate ASHVEIL film/render workflows. **Proposed:** unified browser world/cinema authoring and reliable frame-accurate export UI. | **M3 → M6:** absolute-time scene sampling and encoder pipeline. Frame N equals an interactive seek to N/FPS; audio stays at intended continuous source time; no invented musical-drop confirmation. |
| **25. Spatial audio, mixing and acoustic interaction.** Unreal separates sound spatialization, attenuation and occlusion. [Audio Engine Overview](https://dev.epicgames.com/documentation/unreal-engine/audio-engine-overview-in-unreal-engine) | Sound assets remain original audio; emitter/listener transforms, room sends and proxy-based occlusion are independent of Gaussian appearance. | **Available:** spatial emitters, cues, fades, bounded decoded cache and voice count. **Proposed:** buses, ducking, occlusion and authored acoustic transitions. | **M2 → M3:** audio event graph and lifetime tracking. A behind-wall cue is filtered according to proxy state, moves without a click and fires once; pause/resume/restart cannot duplicate voices. |
| **26. Runtime UI, accessibility and localization.** UMG authors menus/HUDs with dynamic bindings. [UMG Quick Start](https://dev.epicgames.com/documentation/unreal-engine/umg-ui-designer-quick-start-guide-in-unreal-engine) | Optional HTML/accessibility-first HUD graph bound to typed world state; Gaussian-only applies to world appearance, not to preventing readable screen controls. | **Available:** controls, journal/ending UI, input fallback and 21 locale dictionaries. **Proposed:** creator HUD editor and full reviewed translations. | **M2:** binding registry and focus rules. Complete a game using keyboard and touch; overlay captures input without walking; RTL layout and zoom retain every action; authored text is inserted as text, not executable HTML. |
| **27. Profiling, diagnostics and automated testing.** Unreal Timing Insights separates CPU/GPU tracks and frame spikes. [Timing Insights](https://dev.epicgames.com/documentation/unreal-engine/timing-insights-in-unreal-engine) | Per-operation/frame traces for CPU, actual GPU timing when supported, bytes requested, cache residency, source revisions, loading failures and render quality settings. | **Available:** unit suites, CPU/awaited-render diagnostics and explicit unavailable GPU metric. **Proposed:** real GPU timestamps, memory attribution and repeatable quality/performance scenes. | **M0 → M4:** telemetry schema and benchmark harness. Export a trace where a long upload/selection operation can be attributed; unsupported counters remain unavailable; compare equivalent visual quality before any efficiency claim. |
| **28. Collaboration and source control.** Unreal Multi-User uses transactions, with different synchronization policies for levels and assets. [Multi-User Overview](https://dev.epicgames.com/documentation/unreal-engine/multi-user-editing-overview-for-unreal-engine) | Content-addressed immutable assets plus validated entity/layer transactions, permissions, conflict handling and explicit saves; gameplay multiplayer remains a separate service. | **Available:** local history and source Git workflow. **Foundation:** previously disabled invitation-room service. Hosted coediting and integrated gameplay multiplayer are **Proposed**. | **M1 → M7:** authenticated identity, authoritative transaction log and conflict semantics. Two clients edit separate objects then the same property; reconnect/dedup yields a documented result without losing assets or granting unauthorized edits. |
| **29. Packaging, publishing and paid builds.** Unreal packaging creates target-specific application artifacts. [Packaging Projects](https://dev.epicgames.com/documentation/unreal-engine/packaging-your-project) | Dependency-closed Gaussian/audio/gameplay package; web build and native host are distinct targets; deterministic manifest, provenance and isolated build workers. | **Available:** ZIP export/reimport and local package prototypes. **Proposed:** hosted publishing, paid/native build queue and signed public delivery. | **M6 → M7:** package compatibility, native QA, job isolation and entitlement/billing verification. Export/reimport preserves bytes and references; launch an actual Windows build on a clean machine; a web ZIP is never labeled an EXE. |
| **30. Extensibility, tutorials and reusable tools.** Unreal Editor scripting allows content-production tools and widgets separate from runtime behavior. [Editor Scripting](https://dev.epicgames.com/documentation/unreal-engine/scripting-the-unreal-editor-using-blueprints) | Versioned safe editor-command API, capability-scoped plugins, example projects and visual tutorials generated from actual supported actions. Editor code is not implicitly embedded into games. | **Available:** illustrated guides and optional authored tools. **Proposed:** public plugin SDK, interactive task tutorials and curated templates beyond current examples. Education issuance remains inactive. | **M0 → M2 → M7:** command registry, tutorial fixtures and plugin sandbox. Tutorial assertions check actual world state after each step; a plugin cannot run arbitrary privileged server operations or silently alter unrelated sources. |

## Highest-impact implementation gaps

### 1. Complete the existing data path before inventing a new one

The engine core already has sparse edit layers and history, while the browser asset importer rejects layers. This is a specific integration gap. First support native layer preservation through asset metadata, builder import, renderer resolution and ZIP reimport. Resolve whether a layer belongs to a shared asset or a single instance, then make that scope visible in the editor.

The current renderer's 256-edit table is appropriate for a bounded demonstration, not a scalable brush design. Introduce chunk-local sparse storage and per-chunk dirty ranges, with a dense local working-set representation when a region becomes heavily edited. Promotion thresholds need measurements. Do not advertise GPU sculpting when selection and edits still happen on the CPU.

### 2. Make placement accurate and reversible

Finish the in-progress instance tools, then add a shared transform gizmo and support-aware world bounds. Origin alignment is useful if labeled honestly. It is not equivalent to aligning visible surfaces. Gaussian covariance extends beyond its mean; the current mean-only selection index cannot supply tight visual contact points by itself.

### 3. Build one reusable gameplay authoring language

Current objectives, notes, doors, NPCs, sound cues and transitions have useful schema validation. Promote these into typed components and event/action definitions, then expose a small graph that compiles back into the same bounded runtime representation. Do not make every new feature a separate hard-coded side panel forever. Add version migration, debugger inspection and deterministic restart before custom scripts.

### 4. Treat fidelity as source data plus rendering, not a resolution menu

A 4K framebuffer cannot reconstruct missing lettering, faces, thin surfaces or view-dependent appearance. Preserve complete source attributes where supported, expose what was dropped, author close-range quality fixtures and quantify equal-budget detail. Relighting requires an actual material/normal/appearance model. Captured lighting cannot be removed by adding a flashlight button.

### 5. Build streaming and character animation as explicit vertical slices

For streaming, prove one multi-room scene exceeds cache safely with asynchronous fetch, cancellation, residency reporting and stable Gaussian LOD. For animation, prove one articulated character imports, bends, plays/seeks a clip, exports and survives close inspection. Each slice has substantial renderer/data work and should not be represented as a quick extension of rigid object movement.

## Bounded precision-edit contract for the next panel

The actual source-tested entry point is `transformSelection(input, ids, command)` in `asset-transform-tools.js`, returning a fully validated project. Its command types are `translate`, `snap`, `align`, `distribute`, `rotate`, `scale` and `appearance`. `mountSelectionTools` connects it to the existing one-operation undo path. The fuller proposal below is a future preview/transaction contract; it is not the implemented signature, and live preview/cancel is not claimed as completed. This audit does not edit that module.

```js
planSelectionEdit(project, {
  objectIds, roomId,
  command: {
    type: 'move' | 'rotate-y' | 'scale-uniform' | 'snap-origins' |
          'align-origins' | 'distribute-origins' | 'appearance',
    // Typed, command-specific fields; never arbitrary property names.
    delta, radians, factor, grid, axis, target, tint, opacity
  },
  pivot: { mode: 'centroid' } // optional explicit pivot later
})
// -> { project: candidate, changedObjectIds, label, warnings }
// Validate whole candidate before a single existing history/commit operation.
```

Rules:

- Require a nonempty unique selection of known IDs in one room. Existing groups may select members, but a group name is not a license to transform unrelated rooms.
- Calculate the centroid once from selected origins. Move maps `p′ = p + d`. Group rotation/scale maps `p′ = c + s R(p−c)`. Use a room-space yaw quaternion composed with each object's orientation; adding Euler components to arbitrarily rotated objects is incorrect.
- Restrict initial group scale to a positive uniform factor. Nonuniform scaling of rotated groups can introduce shear not represented by the current object TRS schema; reject or defer it instead of silently approximating.
- Transform NPC route points with the same affine map. Translation/alignment of an individual object moves that object's route by its actual delta. Local collision shapes stay local and follow the object transform; do not double-transform them.
- Room triggers and unrelated sound emitters do not move unless explicitly part of the selected assembly. Future prefab hierarchy must declare attachment semantics rather than guessing from proximity.
- Snap **origins** to the specified grid. Align one axis to the active/declared origin or selection statistic. Distribute along an axis using stable ordering with an ID tie-break; preserve first/last endpoints and no-op for fewer than three items. Clearly identify origin spacing, not equal surface gaps.
- Batch appearance modifies only declared instance tint/opacity fields. Preserve source references, story links, collision and all unrelated fields.
- Validate every resulting position, scale, route and reference before commit. An invalid member rejects the entire batch; no partial application, storage writes or history entries.
- One user Apply produces one undo item. Preview changes remain separate from persisted project state. Cancel returns to the original state.
- Count only instance/route changes as edited data. Do not load, decode, bake, upload or rewrite source arrays to perform these operations.

Required tests: frozen input object/source snapshots; centroid rotation of already pitched/rolled objects; uniform scale and route mapping; negative/zero/NaN factors; cross-room/duplicate/missing selection IDs; one invalid member rolls back all; deterministic distribution with tied origins; nonselected fields unchanged; source bytes unchanged; complete undo/restart/export round trip.

## Milestone gates and order

| Gate | Deliverable | Dependencies | Evidence required before calling it complete |
| --- | --- | --- | --- |
| **M0 — Trustworthy editor transactions** | Precision instance tools, shared selection, preview/cancel and undo, clear diagnostics. | Current project and story schemas. | Automated invariants plus actual browser mouse/keyboard/touch checks; no Gaussian rewrites for ordinary transforms. |
| **M1 — Integrated Gaussian editing** | Layer-preserving import/export, per-instance/shared scope, stable IDs, support-aware selection and new-asset bake. | M0; existing core/bridge/native foundations. | Save/reopen and ZIP round trip preserve base bytes and visible layer results; cancel/undo and dirty ranges verified. |
| **M2 — Reusable authoring language** | Small typed material/procedural/gameplay node representations, bounded events and reusable component assets. | M1 and command registry. | A short game authored from reusable components; serialized graph validation, deterministic replay and step-budget enforcement. |
| **M3 — Motion and interaction slice** | Transform curves, one articulated Gaussian asset, proxy physics/navigation integration, sound bindings. | M1/M2, skeleton/solver schemas. | Close-range character/door/gameplay fixture; seeking, pause/resume, restart and export match; timing and failures disclosed. |
| **M4 — Fidelity and measured renderer** | Full supported appearance channels, relighting prototype, actual GPU profiling where available, visual-error fixtures. | M1; renderer/material contract. | Calibrated lighting/close-view comparisons and hardware-specific measurements, including failure cases. No generic 100× claim. |
| **M5 — Streamed Gaussian world** | Cell/cluster residency, async loading, cancellation, representative Gaussian LOD and eviction. | M4 plus chunk transport and world bounds. | A world larger than memory budget is traversed without unbounded allocations; documented stalls, error quality and pop metrics. |
| **M6 — Reproducible release artifacts** | Versioned web/native builds and deterministic cinematic sampling. | Relevant M1–M4 data support. | Independent hosting, offline/native launch where applicable, byte/reference checks, audio/video sync and compatibility matrix. |
| **M7 — Hosted creator platform** | Accounts, authoring collaboration or multiplayer, deployment/build jobs and optional commerce. | M6, identity/permissions/operations/entitlements. | Actual user flows, authoritative server checks, recovery and delivery receipts. Local code does not satisfy this gate. |

These gates can overlap where dependencies allow, but enabling unfinished UI should not substitute for completing one. Keep optional systems unloaded and hidden until a creator opts into them; the blank engine must stay useful for asset creation alone.

## Performance and quality protocol

Use small fixed benchmark scenes plus a larger stress scene: readable sign, thin door/arch, overlapping translucent forms, detailed close prop, repeated instances, one animated figure and an occluded multi-room traversal. Preserve source/camera/output hashes, renderer settings, browser/build, hardware and warm/cold cache state.

For each editing operation report p50/p95 latency and worst observed stall; CPU utilization if actually sampled; CPU allocations and memory scope; real GPU time/utilization/VRAM only when actually available; logical bytes modified; upload requests separately from measured transfers; storage reads/writes; and canceled-work costs. Frame-rate measurements must include the same visible results, camera path, resolution and scene activity.

A transform record can have constant editing cost with respect to the number of source Gaussians. That does not make rendering, sorting, instance traversal, source loading or the entire application constant-cost. Current project snapshots may still clone metadata for the bounded object list. Measure the actual end-to-end interaction, not only a favorable inner function.

Compare equivalent quality against a conventional representation. Document representation preparation, memory and preprocessing costs, and report operations where Gaussians lose as well as win. “Up to 100×” remains an objective until a reproducible comparable benchmark proves a precisely scoped result.

## Maintenance and release use

Re-read the actual changed modules and test receipts before promoting any row from proposed/foundation/in progress to available. A module filename, schema field, mockup, test fixture or test count alone is insufficient proof of an end-to-end creator workflow. Update this audit alongside `BUILD-STATUS.md` and the developer changelog when a material milestone is verified.

Official documentation describes inspiration and comparison points, not permission to copy third-party implementations or an endorsement of Guassia. Recheck changed APIs before implementation. Keep future research precise: choose the next milestone and the smallest supported vertical slice instead of announcing a complete clone of two mature production applications.