RealtimeMeshComponent for runtime-generated Unreal Engine geometry

What RealtimeMeshComponent replaces in an Unreal Engine project

RealtimeMeshComponent, commonly shortened to RMC, addresses a specific Unreal Engine rendering problem: a project needs to display meshes that do not exist as fixed assets when the packaged game begins. Geometry may be loaded into a running application, edited while it is active, generated procedurally, or visualized through debug tooling. Unreal's built-in ProceduralMeshComponent and DynamicMeshComponent already occupy this area, and the repository describes RMC as a high-performance replacement for them.

The intended users are C++ developers working in Unreal Engine 5, with Blueprint and C++ APIs available for runtime mesh control. The README also points to examples for schools and larger studios, but it does not document hardware requirements, concurrency limits, or a capacity target for the component. Consequently, the project should be judged by its architecture and examples rather than by an undocumented claim that it will fit a particular scene size.

RMC is not a general world generator. It is the rendering and mesh-data layer beneath such a system. A project can use it for a model loaded at runtime or for live edits, while more elaborate procedures remain the responsibility of the game code. The Core repository also does not claim that RMC automatically creates Nanite geometry, streams chunks spatially, or converts imported assets into runtime meshes. Those capabilities need to be checked against the feature boundary described below.

Core architecture: stream data, sections, and a copy-on-write proxy

The documented design centers on a stream-based mesh data layer and a copy-on-write render proxy. That division matters because a runtime mesh can change even though rendering occurs elsewhere in Unreal Engine's renderer. The stream data holds mutable mesh information, while the render proxy is the side used for rendering. Copy-on-write means a change should require a new representation rather than an indiscriminate mutation of shared render data. The README does not expose the synchronization protocol, thread-safety contract, or allocation behavior, so those details require inspection of the source and API documentation before concurrent generation is designed.

At the logical level, the Core runtime covers LODs, sections, section groups, materials, and collision. A mesh can therefore represent more than one undifferentiated vertex and index buffer. Material assignment is handled through the component, while collision is part of the same runtime feature set. The documentation also states that both Blueprint and C++ APIs are available, giving projects a choice between editor-facing workflows and native integration.

The examples module adds evidence about intended patterns. `RealtimeMeshExamples` includes a simple triangle, basic shapes, collision, asynchronous builds, LODs, fast updates, and other cases. These are not merely samples around the plugin. They are the documented starting point for understanding how geometry is submitted and updated, especially when the intended production pipeline is asynchronous. Still, the README does not promise that every update path is non-blocking, and it does not publish latency or memory figures.

Core edition limits and the separate Pro feature set

The most important adoption constraint is the boundary between the free Core repository and RealtimeMeshComponent-Pro. Core includes `RealtimeMeshComponent`, `RealtimeMeshExamples`, and `RealtimeMeshEditor`. It does not include mesh providers, the Constructed mesh system, or `UDynamicMesh` integration.

The Pro edition is also where the README places static-mesh and OBJ conversion, CPU and GPU mesh-to-SDF generation with Lumen card support, compute-shader mesh generation, spatial streaming, a runtime Nanite builder, and meshoptimizer-based mesh optimization. A team should not read references to those capabilities and assume they ship in this repository. Its release history does establish Core releases named v5.1.0, v5.2.0, and v5.3.2, but release names alone do not provide the detailed compatibility matrix for these optional workflows.

This boundary makes Core a plausible choice for direct runtime mesh management through its documented component APIs. It is the wrong repository for a design centered on Constructed meshes, spatial chunk streaming, or runtime Nanite generation unless the project can add or separately acquire those capabilities. Installation from Fab is listed as an option, but the README does not identify whether the Fab listing is Core, Pro, or multiple editions, so the edition should be checked before using that route.

Installing RMC and locating the first working example

The documented source installation begins by cloning or copying this repository into the project's `Plugins/` directory. The example location in the README is `MyProject/Plugins/RealtimeMeshComponent/`. No `git clone` command is supplied in the README, so none is invented here.

After the repository is placed there, regenerate the Unreal Engine project files and build it. The README explicitly says that source builds require a C++ project. Then enable the Realtime Mesh Component plugin in the editor if it has not already been enabled automatically. These are installation instructions rather than a command sequence because the project does not document exact Unreal commands or a source dependency bootstrap command.

The first working use should come from the examples module. Begin with `RealtimeMeshExample_Simple_HelloTriangle` under `Source/RealtimeMeshExamples/`. The README identifies it as the recommended starting point and says that full guides, key concepts, and API documentation are available through the project documentation at `https://triaxis.games/realtime-mesh/`. The expected result of the first pass is the example-defined triangle scene, not a claim about a particular frame rate or scene scale, neither of which is documented.

Before committing the plugin to a production branch, check that the local engine version is one of UE 5.5, UE 5.6, UE 5.7, or UE 5.8. Although the README states UE 5.5 through 5.8 in prose, there is no provided per-release matrix identifying which minor plugin release targets which engine version.

Runtime update, collision, and LOD decisions in RMC

RMC's feature set points toward workloads in which topology changes after startup. The `RealtimeMeshExamples` module names fast updates and asynchronous builds as explicit example subjects. That distinction is important for an Unreal Engine project deciding between a straightforward synchronous construction path and a background mesh-building path. The README does not provide the exact API calls or synchronization requirements, so the sample source and linked guides remain the authoritative implementation references.

LOD support is another reason to consider RMC over a minimal procedural triangle component. Runtime-generated geometry can cover larger viewing distances, but selecting a suitable policy depends on generation cost, update frequency, collision requirements, and the target scene. The README does not specify automatic LOD generation, rebuild triggers, or memory behavior. It only confirms that LODs are a Core capability and that examples exist.

Collision is included, but the README does not state which collision representations are generated or whether collision can be updated at the same frequency as visual geometry. Projects should therefore avoid assuming that visual updates and collision updates have identical cost. The same caution applies to materials and section groups. Their presence in the component makes richer meshes possible, while their runtime costs remain undocumented.

DynamicMeshComponent is named by the README as a component RMC is intended to replace, but `UDynamicMesh` integration is assigned to Pro. This is a meaningful distinction for projects whose existing mesh pipeline relies on Unreal's Dynamic Mesh structures. Direct adoption of Core may require adapting that pipeline to RMC's own data and rendering interfaces.

Maintenance releases, upgrades, and MIT licensing

The repository is not archived, and its last push was on 2026-08-23. The latest listed release is v5.3.2, dated 2026-07-27. Earlier listed releases are v5.2.0 from 2024-04-22 and v5.1.0 from 2023-10-24. These dates indicate recent Core releases, but the README does not provide release notes for this repository, migration instructions, or a formal support policy for each Unreal Engine version.

Upgrading therefore requires attention to the source tree rather than a promise of drop-in compatibility. Projects should compare their current usage with the examples and API changes for the target release. In particular, any assumptions based on `UDynamicMesh`, Constructed meshes, Nanite generation, or spatial streaming do not belong to the Core edition and cannot be migrated from this repository because those capabilities are not included.

The Core edition uses the MIT License, with copyright held by TriAxis Games, L.L.C. That permits use and modification under the license's stated conditions, while redistribution obligations and third-party shader or engine terms remain matters for a project's own distribution review. This article does not interpret those legal obligations. The repository contains `LICENSE.txt`, `CREDITS.md`, and shader sources, so an adopting team should inspect those files alongside its Unreal Engine distribution obligations.

Editorial conclusion

Adopt the Core edition when an Unreal Engine 5 C++ project needs runtime-generated or runtime-modified meshes through a documented streaming and render-proxy architecture. Do not adopt it expecting Nanite generation, spatial streaming, dynamic mesh integration, or compute-shader workflows from the Core repository, because the README assigns those features to the separate Pro edition. Verify first that the required UE version falls within UE 5.5 through 5.8, then confirm that `RealtimeMeshExamples`, especially `RealtimeMeshExample_Simple_HelloTriangle`, covers the geometry and update pattern required by the project.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. TriAxis-Games/RealtimeMeshComponent on GitHub