Unreal Engine Nanite Guide: Using High-Detail Geometry in Architectural Scenes

Nanite is a system in Unreal Engine that processes mesh geometry virtually. According to Epic Games’ official documentation, geometry is analyzed in clusters of triangles during import. When rendering, the system uses the appropriate clusters based on the detail visible in the camera frame, streaming data into memory as needed. This guide looks at the Nanite and Static Mesh Editor features described in the documentation from an architectural visualization perspective. Since the sources do not specify a particular Unreal Engine version, these steps do not claim version-specific compatibility.

1. Which scene assets are suitable for Nanite?

Unlike traditional mesh-processing methods, Nanite handles levels of detail automatically. You don’t need to prepare conventional LODs individually for static meshes; the system dynamically determines the polygon count based on the screen resolution in use. When the camera moves closer to an object, Nanite can display detail down to the source triangles of the imported asset. This makes detailed geometry—such as high-poly source models, sculptural forms, and photogrammetry scans—available directly in the workflow.

Epic Games lists objects with very high triangle counts, triangles that occupy little screen space, many instances in a scene, or geometry that occludes other Nanite geometry as good candidates. In architectural projects, detailed façade components, repeated environmental elements, or models viewed up close can be assessed against these criteria. They are guidelines for asset selection, not a guarantee of performance.

Don’t assume every asset will perform better with Nanite. One example in the documentation is a sky sphere that appears only once in the scene, does not occlude other objects, and has triangles that occupy a large part of the image; it may be a typical exception. Suitability should be evaluated by considering the number of instances, triangle count per mesh, material complexity, output resolution, and hardware together.

2. How to enable Nanite

When importing a new model, you can use the Build Nanite option. For supported assets already in a project, the documentation describes ways to enable Nanite in bulk through the Content Browser or individually in the asset editor.

1. During import: Check Build Nanite for supported geometry intended for Nanite. Converting a mesh to Nanite takes processing time; importing high-detail models and building static mesh data can take longer.

2. For multiple assets: Select the appropriate static or skeletal meshes in the Content Browser. From the right-click menu, choose Nanite > Enable.

3. For a single static mesh: Open the model in the Static Mesh Editor. In the Nanite Settings section of the Details panel, check Enable Nanite Support.

4. While inspecting the view: Use the viewport panel in the Static Mesh Editor to check the model and mesh visualizers. The panel lets you inspect the model in its rendered view or, optionally, in wireframe.

Meshes with Nanite enabled are still triangle meshes at their core; what changes is how their geometry is stored and processed. Nanite also requires an enable flag on the mesh. While static mesh LODs are managed automatically, the documentation notes that skeletal meshes use animation LODs rather than geometry LODs.

3. Import, lighting, and storage decisions

When setting import options, consider the project’s lighting approach before choosing Generate Lightmap UVs. Epic Games recommends disabling this option if precomputed lighting with Lightmass is not being used. Importing high-detail geometry for Nanite and building static mesh data can take time; lightmap UVs also add another UV channel and can add a significant amount of data for dense meshes. This recommendation therefore applies to projects that do not need precomputed lighting with Lightmass.

Virtual textures are not required for Nanite, but Epic Games recommends using them. Nanite’s ability to handle high-detail geometry does not eliminate every scene-related constraint. Test combinations of content and hardware, and include material complexity and output resolution in performance evaluations.

The documentation gives an upper limit of 16 million instances in a scene. This total includes all instances streamed into the scene, not just objects with Nanite enabled. Nanite also has limited support for deformation: Morph Targets are not supported. Materials can use World Position Offset, but the amount of displacement must be limited; the system splits these meshes into small clusters and culls each cluster individually.

4. Impact on architectural and archviz workflows

Nanite could affect workflows at architecture firms and visualization teams by making it possible to use high detail from source models and reducing the need to prepare LODs manually for static meshes. It makes sense to test its suitability on detailed surfaces viewed up close or on repeated environmental assets. Nanite supports static meshes alongside Lumen global illumination and reflections, as well as virtual shadow maps.

However, you can’t assume that every model or project will produce the same results. Start by comparing a few representative assets with Nanite enabled and disabled. Measure performance again if import time, material setup, resolution, or target hardware changes. The SSD recommendation for runtime storage should also be considered when planning a project; the documentation presents it as a recommendation, not a mandatory hardware requirement.

Common mistakes

• Assuming that enabling Nanite will automatically improve performance in every scene. Test content, material complexity, output resolution, and hardware together.

• Changing the Generate Lightmap UVs setting without checking whether precomputed lighting with Lightmass is needed. The recommendation to disable it applies only when this type of lighting is not being used.

• Assuming Nanite supports every form of deformation. Morph Targets are not supported, and the use of World Position Offset is limited.

• Treating the SSD recommendation as a requirement or ignoring data streaming altogether. The documentation recommends SSDs for runtime storage and advises measuring performance.

For a more controlled start, compare import times, image quality, and performance on a few representative assets before rolling Nanite out across the project.