Nanite

On this page 7

Nanite is the virtualized micropolygon geometry system of Unreal Engine 5 that renders meshes with millions of triangles by streaming and drawing only the detail that is visible on screen. Among modern game engines, it changed how artists treat polygon budgets: instead of authoring several hand-made levels of detail (LODs), a team imports a high-resolution source asset and lets the engine select per-cluster detail at runtime.

In gaming, Nanite matters because geometric complexity used to scale with draw calls, memory and manual optimization work. Nanite decouples scene complexity from rendering cost, so frame time depends mostly on screen resolution and visible pixels rather than on the raw triangle count of the level. It works alongside Lumen for lighting and Virtual Shadow Maps for shadows, but it is a separate system with its own rules and limits.

How Nanite builds and renders geometry

Nanite works by preprocessing each mesh into a hierarchy of triangle clusters and then choosing, every frame on the GPU, the coarsest clusters that still look correct. During import, the engine splits the mesh into clusters of roughly 128 triangles, groups neighboring clusters, simplifies each group, and repeats the process until a single coarse root remains. The result is a directed acyclic graph of cluster groups rather than a simple chain of discrete LOD meshes.

At runtime, a GPU-driven culling pass walks this graph and picks clusters whose simplification error projects to less than about one pixel on screen. Because neighboring cluster groups share locked boundary edges during simplification, adjacent regions can sit at different detail levels without visible cracks. Visible clusters then pass through frustum culling and a two-pass hierarchical depth occlusion test, so hidden geometry is rejected before rasterization.

Rasterization itself is split. Small triangles that cover only a few pixels go to a software rasterizer written in compute shaders, which is faster than fixed-function hardware for micropolygons. Larger triangles go to the hardware rasterizer. Both write into a visibility buffer that stores triangle and instance identifiers per pixel, and materials are evaluated afterward in a deferred material pass. This keeps shading cost tied to pixels rather than triangles.

The table below summarizes the main stages and what each one contributes to performance.

StageWhen it runsWhat it does
Cluster buildingAsset import or buildSplits the mesh into small triangle clusters and simplifies groups
Compression and pagingAsset buildPacks cluster data into compact pages for disk and memory
LOD selectionEvery frame on the GPUPicks clusters whose error stays below about one pixel
Occlusion cullingEvery frame on the GPURejects instances and clusters hidden behind closer depth
RasterizationEvery frameSoftware path for tiny triangles, hardware path for large ones
Material passAfter rasterizationShades visible pixels from the visibility buffer
Main stages of the Nanite pipeline

Streaming, memory and data size

Nanite treats geometry like virtual texturing treats texels: only the pages needed for the current view are resident in GPU memory. A fixed-size streaming pool holds cluster pages, and the engine requests finer pages as the camera approaches a surface and evicts pages that are no longer needed. This is why a level can contain billions of source triangles while the frame draws only a few million.

On disk, Nanite meshes are stored in a compressed format that is often comparable to or smaller than a traditional mesh with a full LOD chain, although the exact ratio depends on topology, vertex attributes and UV seams. Meshes with many UV seams and hard normals compress less efficiently, because split vertices break cluster continuity. Each Nanite mesh also keeps a fallback mesh, a low-polygon proxy used for collision, some ray-tracing paths and platforms that cannot run Nanite.

Nanite compared with traditional LOD workflows

The key difference between Nanite and classic LODs is granularity: traditional LODs swap a whole mesh at distance thresholds, while Nanite adjusts detail continuously across individual regions of one mesh. The comparison below shows where each approach stands in a modern rendering pipeline.

AspectManual LOD meshesNanite
Detail switchingWhole mesh at set distancesPer cluster, continuous
Artist effortSeveral LODs authored or generatedOne high-resolution source
Visible poppingCommon at LOD transitionsLargely eliminated
Draw call costGrows with object countBatched by GPU-driven rendering
Small triangle efficiencyPoor on hardware rasterizerHandled by software rasterizer
Platform reachWorks almost everywhereNeeds modern GPUs and APIs
Nanite versus manual LOD meshes

Nanite does not remove the need for good asset hygiene. Excessive vertex attributes, unnecessary material slots and broken topology still cost memory and build time. It also does not replace texture streaming, because surface detail from normal maps and textures remains a separate budget.

Supported content and platform requirements

Nanite supports opaque static meshes first and foremost, and its coverage has expanded with each Unreal Engine 5 release. Later versions added masked materials, World Position Offset for animated foliage, spline meshes, experimental Nanite tessellation with displacement, and experimental support for skeletal meshes. The exact feature set depends on the engine version, so teams should verify support in the version they ship with.

Hardware requirements are significant. Nanite needs DirectX 12 with Shader Model 6 or an equivalent Vulkan or Metal path, and it runs on current consoles such as PlayStation 5 and Xbox Series X and S. Older GPUs and many mobile devices fall back to the proxy mesh, which means a project that targets broad hardware must still check how its fallback geometry looks.

The table below lists common content types and how well they suit Nanite.

Content typeSuitabilityReason
Rock, terrain props, architectureExcellentDense, opaque, rigid geometry
Photogrammetry scansExcellentVery high triangle counts are the target use
Foliage with masked leavesGood with careOverdraw and masked shading add cost
Translucent glass or waterNot supportedVisibility buffer stores one opaque surface per pixel
Characters with deformationLimitedSkeletal support is newer and version dependent
Tiny decorative clutterMixedMany instances can still stress culling
Content suitability for Nanite

Performance pitfalls and common mistakes

The most frequent Nanite problem is overdraw from stacked geometry, where many thin or overlapping surfaces, such as dense grass or layered debris, defeat occlusion culling. Another is assuming that Nanite makes geometry free: memory, build times and shading cost still grow, and Virtual Shadow Maps must re-render pages when Nanite geometry with World Position Offset moves. Profiling with the engine’s Nanite visualization modes, such as overdraw and cluster views, is the reliable way to find these costs.

SymptomLikely causeFix
High GPU time in foliage areasOverdraw from layered masked cardsUse modeled geometry or reduce layers
Shadow cost spikesAnimated World Position Offset invalidates shadow pagesLimit animation distance or disable it on far meshes
Blurry or low-detail surfacesStreaming pool too smallIncrease pool size or reduce source density
Large package sizeMany UV seams and attributesClean topology and remove unused channels
Bad look on older hardwareCoarse fallback meshRaise fallback triangle percentage
Typical symptoms and fixes
  • Do not enable Nanite on translucent or heavily deforming meshes without checking support first.
  • Do not judge performance in the editor viewport alone; profile packaged builds on target hardware.
  • Do not drop texture budgets because geometry got denser, since materials remain a separate cost.

In simple terms

Nanite is a way for Unreal Engine 5 to draw extremely detailed 3D objects without slowing the game down. Imagine a map that shows street names only when you lean in close. When you step back, it shows only highways. Nanite does the same with shapes. It shows fine detail up close and simpler shapes far away. It also works piece by piece, not object by object.

As a result, artists can use movie-quality models directly in a game. The computer spends effort only on the detail a player can actually see.

A practical example

A small studio builds a canyon level for an exploration game using photogrammetry scans of real rocks. Each scanned cliff contains about two million triangles, and the level uses roughly three hundred instances. With traditional LODs, the team would need to generate and tune four LODs per asset and still accept visible popping as players climb.

With Nanite enabled, the artists import the scans directly. On a current console at 1440p, the frame draws only a few million triangles because most cliff detail is either distant or hidden. Profiling reveals one problem: layered grass cards at the canyon floor cause heavy overdraw. Replacing them with fewer modeled grass clumps brings the scene to a stable 60 frames per second target, and the team saves weeks of manual LOD work.