Why is my Nanite mesh invisible or not rendering in Unreal Engine 5?

The most common cause is that Nanite was not enabled on the static mesh asset. Open the mesh in the Static Mesh Editor, go to Details, and check the Enable Nanite Support checkbox. Other causes include using unsupported mesh types (skeletal meshes, meshes with vertex animation), materials using the Masked blend mode or World Position Offset, or the mesh falling below Nanite's minimum screen-space size threshold.

Which mesh types does Nanite support in UE5?

Nanite supports opaque static meshes and as of UE 5.4, meshes using Masked blend mode with limited support. Skeletal meshes, meshes with morph targets, meshes using vertex animation via World Position Offset, and meshes with per-vertex colors used for animation are not supported. Instanced Static Mesh components and Hierarchical Instanced Static Meshes (HISM/foliage) are supported.

How do I set up a fallback mesh for Nanite on unsupported hardware?

Nanite automatically generates a fallback mesh when you enable Nanite on a static mesh. You can control the fallback triangle percentage and trim relative error in the Static Mesh Editor under Nanite Settings. The fallback mesh is used on hardware that does not support Nanite (such as older GPUs or mobile platforms) and can also be configured via the Fallback Relative Error property to balance quality against memory usage.

Fix: Unreal Nanite Mesh Not Rendering

Quick answer: The most common cause is that Nanite was not enabled on the static mesh asset. Open the mesh in the Static Mesh Editor, go to Details, and check the Enable Nanite Support checkbox.

Here is how to fix Unreal Nanite mesh not rendering. You imported a high-poly static mesh, dropped it into your level, and it simply does not appear. Or it renders in the editor but vanishes at runtime. Or it shows up as a grey blob with no detail. Nanite is Unreal Engine 5's virtualized geometry system and it is transformative when it works — but when a mesh silently refuses to render through the Nanite pipeline, the debugging experience can be genuinely confusing. Here is what is actually going wrong and how to fix it.

The Symptom

You have placed a static mesh actor in your level. In the viewport, the mesh either does not appear at all, appears as a low-quality proxy shape, or renders correctly in the editor but becomes invisible when you hit Play. There are no error messages in the Output Log. The actor is visible in the World Outliner, its transform is correct, and selecting it shows the expected bounding box in the viewport — but the actual triangles are not drawn.

In some cases the mesh renders at close range but disappears when the camera moves away. In other cases it is the opposite: the mesh is invisible up close but pops into existence at a distance. You might also notice that the mesh renders correctly if you disable Nanite on it, which confirms the issue is specifically with the Nanite rendering path rather than with the mesh data itself or its placement in the scene.

If you open the Nanite Visualization view mode (under Viewport Options > View Mode > Nanite Visualization > Triangles), the mesh may show as a solid color indicating it is not being rendered by Nanite at all, while surrounding Nanite meshes display the characteristic colored triangle overlay. This is the clearest diagnostic signal that something in the Nanite configuration is wrong for this specific mesh.

What Causes This

1. Nanite is not enabled on the mesh asset. This is the most common cause and the most frequently overlooked. Importing a mesh into UE5 does not automatically enable Nanite on it. You must explicitly opt in per mesh, either at import time via the import dialog or after import in the Static Mesh Editor. If Nanite is not enabled, the mesh renders through the traditional static mesh pipeline. If the traditional rendering path is also not set up correctly (for example, if LODs were not generated and the mesh is extremely high-poly), the mesh may fail to render efficiently or may be culled by the engine's polygon budget.

2. Unsupported mesh type. Nanite only supports static meshes. Skeletal meshes, meshes driven by vertex animation, and meshes with morph targets cannot use Nanite. If you accidentally assigned a Nanite-enabled material to a skeletal mesh component, or if you are trying to use Nanite on a mesh that has a World Position Offset (WPO) material driving significant vertex displacement, the Nanite path will not render it. In UE 5.4 and later, limited WPO support was added for Nanite, but it requires explicit opt-in and has restrictions on displacement magnitude.

3. Material blend mode incompatibility. Nanite was originally designed for fully opaque geometry only. Materials using the Masked blend mode (for alpha-tested cutouts like foliage) were not supported in early UE5 versions. While UE 5.1 and later added Nanite support for masked materials, this support must be enabled in Project Settings and the materials must be configured correctly. Translucent materials are entirely unsupported by Nanite and will cause the mesh to be invisible through the Nanite path.

4. Minimum screen-space pixel threshold. Nanite uses a screen-space error metric to determine how many triangles to render. If a mesh is extremely far from the camera or very small in world space, it may fall below Nanite's minimum pixel coverage threshold and be culled entirely. This manifests as meshes that disappear at distance even though they should still be visible. The Nanite Fallback mesh should handle this case, but if the fallback is misconfigured or has zero triangles, the mesh simply vanishes.

The Fix

Step 1: Enable Nanite on the static mesh asset. Open the static mesh in the Static Mesh Editor. In the Details panel, look for Nanite Settings and check Enable Nanite Support. Save the asset and wait for the Nanite data to build. You can also enable Nanite on multiple meshes at once through the Content Browser by selecting them, right-clicking, and choosing Nanite > Enable.

// Programmatically enable Nanite on a static mesh in C++
#include "Engine/StaticMesh.h"
#include "NaniteBuilder.h"

void AMyEditorUtility::EnableNaniteOnMesh(UStaticMesh* Mesh)
{
    if (!Mesh)
    {
        UE_LOG(LogTemp, Error, TEXT("Mesh is null, cannot enable Nanite"));
        return;
    }

    // Check if Nanite is already enabled
    if (Mesh->NaniteSettings.bEnabled)
    {
        UE_LOG(LogTemp, Warning,
            TEXT("Nanite already enabled on %s"),
            *Mesh->GetName());
        return;
    }

    // Enable Nanite
    Mesh->NaniteSettings.bEnabled = true;

    // Configure fallback settings
    // FallbackPercentTriangles controls the LOD used on non-Nanite hardware
    Mesh->NaniteSettings.FallbackPercentTriangles = 1.0f;
    Mesh->NaniteSettings.FallbackRelativeError = 0.0f;

    // Rebuild the mesh to generate Nanite data
    Mesh->Build(false);
    Mesh->PostEditChange();
    Mesh->MarkPackageDirty();

    UE_LOG(LogTemp, Log,
        TEXT("Nanite enabled on %s, fallback at %.0f%% triangles"),
        *Mesh->GetName(),
        Mesh->NaniteSettings.FallbackPercentTriangles * 100.0f);
}

For bulk operations across an entire project, you can iterate over all static mesh assets in the Content Browser programmatically. This is particularly useful when migrating a large project from UE4 to UE5 and you want to enable Nanite on all eligible meshes.

// Batch-enable Nanite on all static meshes in a directory
#include "AssetRegistry/AssetRegistryModule.h"
#include "Engine/StaticMesh.h"

void AMyEditorUtility::BatchEnableNanite(const FString& DirectoryPath)
{
    FAssetRegistryModule& AssetRegistry =
        FModuleManager::LoadModuleChecked<FAssetRegistryModule>(
            "AssetRegistry"
        );

    TArray<FAssetData> MeshAssets;
    AssetRegistry.Get().GetAssetsByPath(
        FName(*DirectoryPath), MeshAssets, true
    );

    int32 EnabledCount = 0;

    for (const FAssetData& AssetData : MeshAssets)
    {
        if (AssetData.AssetClassPath.GetAssetName() != "StaticMesh")
        {
            continue;
        }

        UStaticMesh* Mesh = Cast<UStaticMesh>(AssetData.GetAsset());
        if (Mesh && !Mesh->NaniteSettings.bEnabled)
        {
            Mesh->NaniteSettings.bEnabled = true;
            Mesh->NaniteSettings.FallbackPercentTriangles = 1.0f;
            Mesh->Build(false);
            Mesh->PostEditChange();
            Mesh->MarkPackageDirty();
            EnabledCount++;
        }
    }

    UE_LOG(LogTemp, Log,
        TEXT("Nanite enabled on %d meshes in %s"),
        EnabledCount, *DirectoryPath);
}

Step 2: Verify material compatibility. Open each material assigned to the mesh and check its Blend Mode. For Nanite, the material must use Opaque blend mode for guaranteed compatibility. If you need alpha-tested materials (such as for vegetation), ensure your project has masked material support enabled for Nanite and that the material is configured correctly.

// Check and fix material compatibility for Nanite rendering
#include "Materials/MaterialInterface.h"
#include "Materials/Material.h"
#include "Components/StaticMeshComponent.h"

void AMyActor::ValidateNaniteMaterials()
{
    UStaticMeshComponent* MeshComp = FindComponentByClass<UStaticMeshComponent>();
    if (!MeshComp) return;

    int32 NumMaterials = MeshComp->GetNumMaterials();

    for (int32 i = 0; i < NumMaterials; i++)
    {
        UMaterialInterface* MatInterface = MeshComp->GetMaterial(i);
        if (!MatInterface) continue;

        UMaterial* BaseMaterial = MatInterface->GetMaterial();
        if (!BaseMaterial) continue;

        EBlendMode BlendMode = BaseMaterial->GetBlendMode();

        if (BlendMode == BLEND_Translucent || BlendMode == BLEND_Additive
            || BlendMode == BLEND_Modulate)
        {
            UE_LOG(LogTemp, Error,
                TEXT("Material slot %d (%s) uses blend mode %d "
                "which is NOT compatible with Nanite"),
                i, *MatInterface->GetName(), (int32)BlendMode);
        }
        else if (BlendMode == BLEND_Masked)
        {
            UE_LOG(LogTemp, Warning,
                TEXT("Material slot %d (%s) uses Masked blend - "
                "ensure Nanite masked support is enabled in Project Settings"),
                i, *MatInterface->GetName());
        }
        else
        {
            UE_LOG(LogTemp, Log,
                TEXT("Material slot %d (%s) is Opaque - Nanite compatible"),
                i, *MatInterface->GetName());
        }
    }
}

Step 3: Use the Nanite visualization modes to confirm rendering. Unreal provides built-in visualization modes that show you exactly what Nanite is and is not rendering. Switch to the Nanite Triangles view to see a color-coded overlay of Nanite-rendered geometry. Any mesh that appears as a solid flat color without the triangle overlay is not being rendered by Nanite. You can also check the Nanite statistics via console commands to see how many triangles Nanite is processing per frame.

// Console commands for Nanite debugging and visualization
// Show Nanite triangle count and cluster statistics
stat Nanite

// Visualize which meshes are rendered via Nanite
r.Nanite.Visualize.Overview 1

// Force Nanite fallback meshes to render instead (for comparison)
r.Nanite.ForceDisable 1

// Reset back to Nanite rendering
r.Nanite.ForceDisable 0

// Show Nanite mesh streaming statistics
r.Nanite.Streaming.Debug 1

If the visualization confirms that Nanite is not active on a specific mesh, double-check the asset. Open the Static Mesh Editor, look at the bottom of the viewport where it shows triangle counts — there should be a separate Nanite triangle count listed. If that count is zero or the Nanite section is absent, the Nanite data was never built for this mesh. Re-enable Nanite, save, and allow the build to complete.

Related Issues

If your Nanite meshes render but look incorrect — with lighting artifacts, flickering GI, or light leaking through surfaces — the issue is likely with Lumen's interaction with Nanite distance fields rather than with Nanite itself. See our guide on fixing Lumen lighting flickering and artifacts for those cases. If Nanite meshes render in the editor but not in packaged builds, verify that the target platform supports Nanite (it requires SM6/D3D12 on PC, and is not available on mobile or older consoles) and that the Nanite data is included in the cooked content.

For performance issues where Nanite meshes render but cause frame rate drops, the problem is usually excessive overdraw from overlapping Nanite instances or an unreasonably high number of Nanite clusters in view. Use stat Nanite to monitor cluster counts and consider reducing geometric density in areas where thousands of Nanite instances overlap. If you are using Nanite for foliage, keep in mind that each leaf card still costs a cluster even at distance, and dense forests can quickly exceed reasonable cluster budgets.

Open the mesh, check the Nanite checkbox, save. It is almost always that simple.