How to Use Unreal Engine Nanite: Mesh Preparation and Checks

What will you learn in this guide?

Nanite is Unreal Engine’s virtualized geometry system for handling high geometric detail and large numbers of objects in scenes. It divides mesh data into hierarchical clusters of triangles; when rendering an image, it uses levels of detail appropriate to the camera view and streams the required data into memory as needed. This reduces the need to prepare traditional LODs manually for every mesh.

This guide covers preparing a mesh for Nanite, enabling support on assets already in a project, and checking the results. Nanite does not automatically make every task problem-free: geometry, material complexity, instance count, output resolution, and hardware all need to be considered together. That’s why the final section also covers fallback meshes, data size, and points to consider in a production workflow.

Requirements

Epic Games’ official guides require an Unreal Engine project and geometry supported by Nanite. Since the source material does not specify a particular engine version, paid license, or account requirement, no version or account requirement is assumed here. Meshes can be prepared for Nanite during import, and support can also be enabled on existing Static Mesh assets.

Nanite works with triangle meshes. According to the guide, good candidates include meshes with a high triangle count or many scene instances, meshes containing very small on-screen triangles, and meshes that occlude other Nanite geometry. High-detail digital sculpts and photogrammetry scans are also cited as source assets that can be used directly. However, each project’s content and hardware combination should be measured separately.

Because Nanite streams mesh data from disk as needed, Epic recommends using an SSD for runtime storage. This alone does not guarantee performance; the project content and hardware need to be tested together.

Enabling Nanite: step by step

1. Identify suitable meshes. Start by selecting assets with dense geometry or many instances in the scene. The source gives a sky sphere as a less obvious candidate because it has few instances, forms large triangles on screen, and does not occlude other geometry. Even so, which assets should use Nanite depends on the project.

2. Enable support when importing a new mesh. Check the Build Nanite box in the import settings. Converting each mesh to Nanite takes processing time, so account for this preparation time in projects with many assets. If the project does not use precomputed Lightmass lighting, Epic recommends turning off Generate Lightmap UVs. According to the guide, this option can create an additional UV channel and data for dense meshes; that cost may not be necessary if baked lighting is not required.

3. Enable Nanite in bulk for existing assets. In the Content Browser, select the target Static Mesh or Skeletal Mesh assets. Right-click the selection and choose Nanite > Enable from the menu. Converting multiple assets can take time, so include the process in your production schedule.

4. Enable Nanite for a single mesh in the asset editor. Open the mesh in its own editor. In the Details panel of the Static Mesh Editor or Skeletal Mesh Editor, find the Nanite Settings section and check Enable Nanite Support. For Geometry Collections, the editor’s Nanite section has an Enable Nanite option. Consider these options only for the relevant asset type and supported use cases.

5. Compare the Nanite view and the fallback. In the mesh editor, use the Nanite Fallback view to switch between the fully detailed Nanite mesh and the fallback mesh; according to the guide, Ctrl + N also switches between these two views. The Nanite Triangles view can help check the fallback geometry’s triangle count. Compare them not only in close-up, but also under the scene conditions in which the asset will be used.

6. Adjust settings as needed. Keep Triangle Percent and Trim Relative Error in Nanite Settings reduce the amount of mesh detail retained. Epic describes these settings primarily as a way to reduce disk or download size; don’t treat them as direct performance-boosting settings. For foliage meshes, enabling Preserve Area is recommended; the same source advises against using this setting for other geometry types. Explicit Tangents may be preferable when implicit tangent calculation is not accurate enough; enabling it increases storage by approximately 10 percent.

Common mistakes and limitations

Don’t assume that every engine feature will use the fully detailed Nanite mesh once Nanite is enabled. A fallback mesh may be used when Nanite is unavailable, when complex collision is needed, for baked lighting, and for hardware ray-traced reflections with Lumen. Fallbacks are also important on platforms that do not support Nanite. For this reason, inspect this geometry separately in the relevant scenes and on target platforms.

UV data is not always ordinary texture coordinates. The guide recommends keeping Lerp UVs enabled whenever possible when UVs are normalized coordinates that can be interpolated across surfaces. If UV channels contain data such as indices that cannot be meaningfully interpolated, leaving the setting enabled can break the shader result; check the intended use.

World Position Offset deformation is supported, but with limitations. Morph Targets deformation is not supported on Nanite meshes. Performance can also be affected by very dense geometry, material complexity, scene instances, and output resolution. The guide gives an upper limit of 16 million Nanite instances that can be present in a scene; the limit includes all streamed-in instances, not just assets with Nanite enabled.

What changes in architecture and visualization workflows?

Architecture firms and archviz teams working with high-detail façade elements, sculptural interior pieces, and scanned environmental assets may benefit from reduced manual LOD preparation for each mesh. Nanite manages visible detail according to the camera view; however, the final image should be tested with the chosen assets on the target hardware. It is especially important to check performance and streaming behavior in scenes containing many instances.

Projects that use lightmaps need to account for fallback meshes and UV generation. Because the fully detailed Nanite geometry is not used for some operations, checking only the result in the main view may not be sufficient. Evaluate the storage used by production workstations alongside scene scale and the engine features in use. Trimming Nanite data targets disk size; inspect the fallback view when balancing quality and size.

Next steps

Start by testing a few representative meshes. Compare import time, Nanite and fallback views, scene performance, and file size. Then set the options according to your project requirements and apply them to the remaining assets. Since Nanite’s supported features and limitations can vary with the engine workflow, check the relevant official guide sections before making decisions for a specific use case.

Sources and license

This article draws on Epic Games’ Unreal Engine Nanite Virtualized Geometry, Nanite in Unreal Engine, and Nanite Technical Details guides. The sources are marked as license=free in the provided list; the content has been reorganized and adapted in Turkish.