Building a rock field, you want to keep the cracks you see up close. Put the same rock far away, though, and those cracks are nearly invisible. Drawing the same detail at every distance is wasteful.
Nanite is the mechanism that automatically adjusts a model's geometry to the detail the screen needs. It makes high-detail rocks and buildings easier to use and reduces the work of authoring simplified models for distance.
In this article we enable it on one rock and observe the mechanism, then compare appearance and cost on a small rock field. We check "is it drawing with Nanite" and "did the game get lighter" in that order.
What You'll Learn
- What mesh, LOD, and cluster mean, and what Nanite does
- How to enable Nanite on a single asset
- Observing the detail of what gets drawn in visualization modes
- A hands-on comparing cost on the same rock field to judge where to use it
Nanite chooses the detail it draws
A mesh is the collection of faces representing a model's shape. In UE they are basically drawn as triangles. A model with many triangles that can express fine shapes is called high-poly .
A rock built with cracks and chips modeled in geometry uses far more triangles than a roughly round one. From a distance, though, the difference disappears.
Changing detail to match how it is seen is the idea of LOD (Level of Detail) . The traditional method prepares meshes at high, medium, and low detail and switches based on how large it appears on screen. Those levels are sometimes generated automatically.
Nanite divides a mesh into clusters, small groups of triangles , and picks the detail per group. Fine where the rock fills the screen, coarse where it appears small in the distance. The unit of adjustment is different from swapping a whole model between a few LOD levels.
The basis is how much shape difference can be expressed in a pixel , the small point that composes the screen. Normal display is tuned so the change is hard to notice, but that is not a guarantee that "no model ever shows a shape change".
Worth remembering: the triangle count the original mesh holds and the triangle count drawn in a given scene are not the same . Nanite streams detail data as needed, so SSD storage is recommended.
Nanite is not a feature that automatically carves detail into a simple model. If the original rock is smooth, enabling Nanite does not add cracks.
Enable it on one rock first
We use a Static Mesh : an asset for shapes like rocks and buildings that do not use skeletal animation. Despite the name "Static", you can still move and rotate the placed object.
Prepare one rock with a bumpy surface. Any model you have works. If you are starting from importing assets, see the Fab article. Choose a rock using an Opaque material here.
On Windows, this assumes a Nanite-capable GPU and driver, plus settings using DirectX 12 and Shader Model 6. Older projects may differ, so check the Windows and Rendering entries in "Project Settings". Shader Model indicates the generation of rendering features available on the GPU.
Open the asset and enable it
- Duplicate the rock Static Mesh in the Content Browser and name the practice copy
SM_Rock_NaniteTest. - Double-click that asset to open the Static Mesh Editor.
- Turn on "Enable Nanite Support" under "Nanite Settings" in the Details panel.
- Apply with "Apply Changes", and save once processing finishes.
- Drag that asset into a practice level and place one.
First confirm the rock displays with its original color and shape. Later we switch to visualization modes and confirm Nanite is in use.
What you change is the source mesh asset, not the rock Actor placed in the level. Every rock referencing that asset uses the setting. Using a duplicated practice asset keeps the change from spreading to other levels using the original rock.
Other ways to enable it
Once one works, you can also enable at import or in bulk.
| When | What to do |
|---|---|
| Importing something new | Turn on "Build Nanite" in the import settings |
| Changing many existing assets at once | Select in the Content Browser, right-click → "Nanite" → "Enable" |
| Changing one while watching its settings | Static Mesh Editor's "Enable Nanite Support" → apply and save |
Enabling takes time to prepare data. Before rolling it out across many assets, confirm this one kind displays correctly.
Which meshes to try first
The first candidates are rocks, statues, and building ornaments with fine detail . They show detail up close and simplify at distance, which makes Nanite's role easy to observe. Scenes with many copies of the same rock are candidates too.
Boxes with few triangles to begin with, or a sky sphere that covers the sky with a simple shape, may have little work to cut. Filling the screen does not make something unsuitable, and being unique does not make it pointless. An intricate statue that fills the screen and a wall made of a few faces start from very different workloads.
Rocks and walls hiding things behind them is called occlusion . Nanite also removes hidden geometry from drawing. Scenes with many overlapping layers of fine leaves, though, are harder to cull.
Confirm "can it be enabled", then pick one kind and compare. Working in that order means you never have to change every asset up front.
Translucency and swaying leaves are separate matters
Even when the geometry is supported, how the surface is drawn changes the conditions. A material's Blend Mode decides whether the surface is opaque, cut out, or see-through.
| How it is drawn | Example | With Nanite |
|---|---|---|
| Opaque | Rocks, statues, walls | What this exercise uses |
| Masked | A card with only leaf shapes kept | Supported. Check the cost of stacking many gappy faces though |
| Translucent | See-through glass | This Blend Mode is unsupported. Build translucent parts without Nanite |
Masked is not "half see-through"; it separates the part that is drawn from the part cut away and not drawn . For a leaf model, whether it is a Masked card or has the leaf outline built in geometry changes the processing required.
With unsupported materials, the default material may be substituted and a warning printed to the Output Log. Do not assume "if it disappeared it must be translucency"; check the warnings and settings. For a building with windows, the walls can be Nanite and the glass a separate non-Nanite mesh.
World Position Offset , which sways leaves in the wind, moves the points at face corners (vertices) to change the shape. It has its own support range and cost considerations. Confirm with a non-swaying rock first and check each feature's documentation when extending to foliage and characters.
Hands-On: comparing looks and cost on a rock field
Build a small rock field while keeping the cracks. Using SM_Rock_NaniteTest , work in the order confirm rendering on one → increase the count and compare cost .
1. First, see whether it is drawn with Nanite
In the level viewport, open the view mode menu that normally reads "Lit". Choose "Nanite Visualization" → "Mask".
Green means Nanite, red means non-Nanite. If the rock turns green, the enabled asset is being drawn by Nanite. It is fine for the floor to stay red; you do not need to change the floor at the same time.
Next switch to "Triangles" and move the camera closer to and further from the rock. This view shows the drawn triangles instead of the usual color and material.
| View | What to look at |
|---|---|
| Mask | Whether the target rock is drawn by Nanite |
| Triangles | How the rock's surface subdivision changes as you move the camera |
| Clusters | How triangles are grouped into units |
Up close the cracks subdivide finely; further away, detail unnecessary for that view is dropped. Fewer triangles across the rock does not mean triangles get bigger on screen. The rock itself also appears smaller, so do not judge success as simply "bigger mesh cells at a distance".
Finally return to "Lit" and move the camera the same way. Compare how noticeable, in normal display, the subdivision changes were in the visualization. Use the rock's silhouette and its larger cracks as landmarks.
The diagrams illustrate what the views show. Actual colors and fine subdivision vary by model and UE version.
2. Increase the same rock gradually
- Select the rock and duplicate it with
Ctrl + W, then move it. - Place about 10 total along both sides of a path.
- If performance allows, raise it to 20-50 and pick a spot where near and far rocks are visible together.
You increase level placements; you do not duplicate the asset each time. Keeping a rock field referencing the same single mesh means you toggle Nanite in one place.
3. Match your comparison conditions
Return to "Lit" and finish with the visualization views before measuring. Keep the camera still and match viewport size, resolution, quality settings, and rock count. Wait until shader compilation and initial loading settle.
Run stat unit from the console input field at the bottom of the editor and processing times appear. The unit ms (millisecond) is one thousandth of a second.
| Row | The time it represents |
|---|---|
| Frame | Time for one game frame |
| GPU | Time the GPU spent drawing |
| Draw | Time on the CPU-side thread that advances rendering work |
| Game | Time on the thread that advances game work |
A thread is a flow of execution handling work. Here it is enough to distinguish that Draw is also a CPU-side value, not the GPU's drawing time . These run in parallel, so Frame is not the sum of them all.
4. Compare on and off for the same asset
Record the values from your own environment in the table below. Numbers fluctuate a little, so observe from the same position for a few seconds and note an approximate range.
| Setting | Frame | GPU | Draw | Game | Rock silhouette and cracks |
|---|---|---|---|---|---|
| Nanite on | Record | Record | Record | Record | Record |
| Nanite off | Record | Record | Record | Record | Record |
- Record the Nanite-on state.
- Turn off "Enable Nanite Support" in the Static Mesh Editor, apply, and save.
- Return to the level and record under the same conditions.
- Turn it back on, apply and save, and confirm the trend returns.
If the off state is too heavy, reduce the rock count and re-measure both at the same count. There is no need to place a huge number from the start.
If the source asset has traditional rendering LODs, those are used when off. Precision of the drawn geometry changes with settings, so record appearance as well as speed.
5. Judge from the numbers and the appearance together
If Frame gets shorter and the shape you need survives, that is a good improvement for this rock field. But even with Draw alone getting shorter, overall Frame may not change if other work such as Game is long.
The part limiting overall speed like that is called a bottleneck . Judge "did Nanite take effect" from Mask, and "did the game get lighter" mainly from Frame. Turning green is not by itself proof of a speedup.
If the difference is small, record it rather than declaring failure. The original shape may be simple, or materials, lighting, or game logic may be the main cost. Detailed isolation is covered in the performance measurement article. Confirm your final adoption decision on the devices players will use, with the game actually running.
When it does not work
| Symptom | Where to check |
|---|---|
| I cannot find the Nanite settings | Whether you opened the Static Mesh asset rather than the Actor in the level |
| The rock does not turn green in Mask | The target asset, applying and saving after enabling, a Nanite-capable environment |
| Color or material looks wrong | The material's Blend Mode, warnings in the Output Log |
| The triangle change is hard to see | Whether the original mesh is detailed enough, and whether you compared near and far in Triangles |
| The numbers fluctuate wildly | Whether the camera or resolution changed, whether compilation or loading is still running |
| Draw dropped but smoothness did not change | Compare Frame, GPU, and Game too. An FPS cap can hide the difference |
Bonus: work that remains outside rendering
Collision may use a different shape
A Fallback Mesh is the substitute mesh for processing that does not use Nanite's detailed geometry directly. It is used for non-Nanite rendering and, depending on settings, for face-based collision (Complex Collision).
So the fine cracks you see and the collision shape do not necessarily match. For a rock a character stands on, check for floating or catching while walking. See also choosing between Simple and Complex.
Note that the console's r.Nanite 0 normally switches to drawing the Fallback Mesh. That is not necessarily the same condition as comparing the original high-detail mesh drawn without Nanite. We toggled the asset-side setting precisely to avoid that difference.
Keep checking materials and data size
What Nanite mainly optimizes is drawing geometry. It does not lighten heavy materials, complex lighting calculations, and game logic all at once. Think about surface processing separately, with Material Basics.
Data size is not a fixed multiplier either. Check it in your project including Nanite compression, the original geometry, the Fallback Mesh, and textures. Handling high-detail models more easily does not mean assets can grow without limit.
Foliage and characters are the next step
Skeletal Meshes that animate characters with bones, and foliage-oriented features, have support ranges that vary by UE version. Do not apply what worked on a rock directly to hair, cloth, and wind-swayed forests; check each feature's documentation and measure before expanding.
Once comfortable, "Nanite Visualization" → "Overdraw" helps find places where geometry overlaps and is processed repeatedly. Overdraw is duplicated drawing work at the same screen location. Dense foliage and faces stacked at nearly the same position make good subjects to observe next.
Summary
Nanite chooses the geometric detail the screen needs, making high-detail meshes easier to use. It does not draw every triangle of the original model in every scene.
Start by enabling it on one opaque rock and confirm coverage with Mask, subdivision with Triangles, and appearance with Lit. Then compare Frame, GPU, Draw, and Game on the same rock field, and you connect understanding the mechanism with deciding whether to adopt it in your game.
Reference: Nanite overview, Nanite visualization and Fallback Mesh, Stat Commands