【Unreal Engine】Introduction to Nanite: Virtualized Geometry for High-Poly Meshes in Real Time

Overview

Tested with: UE 5.4+

"I want to bring ZBrush high-poly models and photogrammetry scan data into my game, but creating LODs takes forever..." — In traditional game development, asset quality always required compromise due to polygon count and draw call constraints.

UE5's Nanite is a virtualized geometry system that fundamentally eliminates these constraints. Even meshes with billions of polygons are efficiently rendered through automatic LOD, on-demand streaming, and a proprietary rendering pass. Artists can bring film-quality assets directly into games without worrying about technical limitations.

How Nanite Works

Nanite is fundamentally different from the traditional approach of "switching LOD meshes based on distance." It generates optimal detail in real time at pixel scale from a single high-fidelity mesh, eliminating visual popping from LOD transitions.

Here's the processing pipeline:

1. Import-time data processing: Decomposes the mesh into hierarchical clusters and builds multiple detail levels
2. Render-time optimization: Determines the optimal LOD for each cluster in real time based on camera distance and on-screen pixel size. Off-screen portions are not rendered
3. On-demand streaming: Loads only the necessary mesh data from storage on demand. To minimize memory usage, SSD is strongly recommended (HDDs create streaming bottlenecks that cause LOD transition delays and pop-in)
4. Proprietary rendering pass: Bypasses traditional draw calls with a proprietary pass, drastically reducing CPU draw call overhead

Key Benefits

• Render billions of polygons while maintaining performance
• Freedom from polygon count, draw call, and mesh memory constraints
• High-fidelity detail through real geometry instead of normal maps
• No manual LOD setup — LOD transitions are seamless with no quality loss

How to Enable Nanite

Nanite can be enabled in three ways. Choose based on your project's situation.

Enable at Import

When importing new meshes, check Build Nanite in the import options. For new projects, it's efficient to keep this setting enabled from the start.

Tip: In projects using Lumen / Virtual Shadow Maps where lightmaps aren't needed, disabling "Generate Lightmap UVs" reduces import time and data size. Lightmap UV generation alone can take considerable time for high-fidelity geometry.

Batch Enable on Existing Assets

For multiple Static Meshes already in the project, select them in the Content Browser > right-click > Nanite > Enable for batch activation. Convenient when introducing Nanite mid-project.

Enable on Individual Meshes

To enable on specific meshes only, go to the Static Mesh Editor's Details panel > Nanite Settings > toggle Enable Nanite Support on.

Mesh Criteria for Nanite

Nanite is safe to enable on almost all meshes, but the benefit varies. Use these criteria as a guide.

Recommended (High Benefit)	Low Benefit Cases
Meshes with many triangles	Meshes that appear very large on screen
Meshes with triangles that become small on screen	Single-instance meshes in the scene
Meshes with many instances	Meshes that rarely occlude other objects
Major occluder meshes
Meshes casting shadows with Virtual Shadow Maps

For example, a sky sphere appears very large on screen, rarely occludes other objects, and typically has only one instance in the scene — so Nanite provides little benefit. However, such exceptions are rare. If Nanite supports the mesh, enabling it has minimal performance downside, so when in doubt, enable it.

Performance Monitoring

Here are several methods to measure and verify Nanite performance.

stat Nanite Command

Execute the following in the console to display Nanite statistics as an overlay.

stat Nanite

This shows an overview of triangle counts and instance counts during rendering. For more detailed GPU profiling, use stat GPU to check processing times for Nanite VisBuffer (visibility/culling) and Nanite BasePass (material rendering).

Visualization Modes

From the viewport's View Mode > Nanite Visualization, you can visually inspect Nanite behavior.

• Triangles: Heatmap display of triangle density during rendering. Easily spot high-cost areas
• Clusters: View cluster subdivision state. Understand LOD switching behavior
• Overdraw: Overdraw visualization (purple = low = good, orange = high = problem)

Additional modes include Overview, Instances, and Material Complexity.

C++ Runtime Nanite Status Check

To check a mesh's Nanite enabled state at runtime, use the IsNaniteEnabled() method.

UStaticMeshComponent* MeshComp = FindComponentByClass<UStaticMeshComponent>();
if (MeshComp && MeshComp->GetStaticMesh())
{
    bool bNaniteEnabled = MeshComp->GetStaticMesh()->IsNaniteEnabled();
    UE_LOG(LogTemp, Log, TEXT("Nanite enabled: %s"),
        bNaniteEnabled ? TEXT("Yes") : TEXT("No"));
}

Supported Features and Integration

Nanite integrates seamlessly with other major UE5 features.

• Static Mesh: Works with Lumen GI/Reflections and Virtual Shadow Maps (VSM). VSM efficiently generates shadow caches from Nanite meshes, maintaining high-quality shadows even with numerous dynamic lights. However, VSM performance may degrade when Nanite's Fallback Mesh is used (certain materials)
• Skeletal Mesh (experimental in UE 5.4, stabilized in 5.5): Single draw call rendering with animation LOD support. Morph targets and cloth simulation have limitations
• Landscape: High-fidelity terrain at high performance. Also improves Virtual Shadow Maps performance
• Foliage: Renders massive vegetation down to individual leaves. Watch for fallback costs when using Masked materials heavily on grass and plants
• Geometry Collection: Efficiently renders destruction fragments with Nanite

Limitations and Optimization Tips

Nanite solves geometry complexity but has several limitations. Understanding these before application helps avoid issues.

• Translucent materials: Not supported. Meshes using transparent materials cannot use Nanite
• Masked materials: Supported, but requires hardware fallback with higher performance cost compared to Opaque. Use caution with large amounts of foliage
• World Position Offset: Complex WPO may conflict with Nanite's geometry optimization
• Material complexity: Nanite solves the geometry side, but material shader cost is a separate issue. Heavy materials still impact frame rate. Additionally, the material ID count per mesh is limited to 64
• Disk space: Enabling Nanite can increase mesh disk usage by 2-3x. Factor this into asset management planning for large projects
• Output resolution: Nanite processes at pixel scale, so higher resolutions increase processing load
• Shared DDC: In team development, sharing the Derived Data Cache reduces Nanite mesh processing time across the entire team

Summary

• Nanite is a virtualized geometry system that efficiently renders billions of polygons through automatic LOD and on-demand streaming
• Three ways to enable: at import, batch, or individually
• Monitor performance with stat Nanite and visualization modes
• Translucent materials are not supported; Masked materials incur extra cost
• Skeletal Mesh support is experimental in UE 5.4, stabilized in 5.5. SSD environments are recommended

Further Reading

• Nanite Virtualized Geometry - UE5 Official Documentation