Fix: Unreal World Partition Streaming Not Loading

Here is how to fix Unreal world partition streaming not loading. You have built an open world using World Partition in Unreal Engine 5, everything looks perfect in the editor, but when you hit Play or package the project, entire chunks of your world are missing. Actors do not load, landscape tiles are invisible, and the player walks through an empty void. World Partition streaming is powerful but its failure modes are almost entirely silent. Here is how to find out what went wrong.

The Symptom

Your World Partition map displays correctly in the editor. You can see all actors, landscape tiles, and level instances. But when you start a Play In Editor session or package the project, large sections of the world simply do not appear. The player spawns and can move around, but the environment is missing. There are no error messages in the Output Log, no warnings about failed loads, and no obvious indication of what is wrong.

In some cases, actors near the player spawn point load correctly but nothing beyond that ever streams in as the player moves. In other cases, nothing loads at all and the player falls through the world. You might notice that switching back to the editor shows everything intact, which makes the problem even more confusing — the data is clearly there, it just is not loading at runtime.

A related variant of this issue is that some data layers load while others do not. You might see terrain but no buildings, or gameplay actors without their associated environment. This points to a data layer configuration problem rather than a total streaming failure.

What Causes This

1. No streaming source is registered. World Partition requires at least one active streaming source to determine which cells should be loaded. By default, the player controller provides this through an implicit streaming source. However, if you are using a custom player controller, a dedicated server with no local player, or a spectator mode, the streaming source may not be registered. Without a streaming source, the World Partition runtime has no reference point and loads nothing.

2. Data layers are not enabled at runtime. Data layers in World Partition allow you to organize actors into logical groups that can be loaded or unloaded independently. If a data layer is not set to activate at runtime, all actors assigned to that layer will be excluded from streaming. This is easy to miss because the editor shows all data layers regardless of their runtime activation state. The default data layer always loads, but any custom data layers you create must be explicitly activated.

3. HLOD assets are not built or are out of date. Hierarchical Level of Detail assets are generated from your World Partition content and serve as low-detail stand-ins for distant cells. If HLODs are never built, or if they were built against a different version of your content, the streaming system can behave unpredictably. In some configurations, missing HLODs cause the runtime to skip loading certain cell groups entirely.

4. Streaming policy or cell size misconfiguration. The WorldPartitionStreamingPolicy in your World Settings controls how cells are selected for loading. If the loading range is too small relative to your cell grid size, cells will unload before they become visible. If the policy class is overridden to a custom implementation with bugs, streaming can fail entirely. The grid cell size set in the World Partition settings also matters — extremely large cells can cause memory spikes, while extremely small cells can overwhelm the streaming budget.

5. Editor versus runtime behavior differences. The editor loads all World Partition cells so you can edit them. This masks every streaming issue during development. The runtime only loads cells that intersect with a streaming source's loading range. This fundamental difference means that a map which looks complete in the editor can be entirely empty at runtime if the streaming pipeline is not configured correctly.

The Fix

Step 1: Ensure a streaming source is registered and data layers are activated. The most reliable approach is to explicitly add a UWorldPartitionStreamingSourceComponent to your player controller and activate your data layers in your game mode. Here is a setup that covers both:

// MyPlayerController.h
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/PlayerController.h"
#include "WorldPartition/WorldPartitionStreamingSource.h"
#include "MyPlayerController.generated.h"

UCLASS()
class AMyPlayerController : public APlayerController
{
    GENERATED_BODY()

public:
    AMyPlayerController();

protected:
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    UWorldPartitionStreamingSourceComponent* StreamingSource;

    virtual void BeginPlay() override;
};

// MyPlayerController.cpp
#include "MyPlayerController.h"
#include "WorldPartition/DataLayer/DataLayerManager.h"
#include "WorldPartition/DataLayer/DataLayerInstance.h"

AMyPlayerController::AMyPlayerController()
{
    // Explicitly create a streaming source on this controller
    StreamingSource = CreateDefaultSubobject<
        UWorldPartitionStreamingSourceComponent>(
        TEXT("StreamingSource"));
    StreamingSource->Priority = EStreamingSourcePriority::Normal;
    StreamingSource->bStreamingSourceEnabled = true;
}

void AMyPlayerController::BeginPlay()
{
    Super::BeginPlay();

    // Activate data layers at runtime
    UWorld* World = GetWorld();
    if (!World) return;

    UDataLayerManager* DataLayerMgr =
        UDataLayerManager::GetDataLayerManager(World);
    if (!DataLayerMgr) return;

    // Activate all data layers that should be loaded at start
    DataLayerMgr->ForEachDataLayerInstance(
        [DataLayerMgr](const UDataLayerInstance* Layer)
    {
        if (Layer && Layer->GetInitialRuntimeState()
            == EDataLayerRuntimeState::Activated)
        {
            DataLayerMgr->SetDataLayerInstanceRuntimeState(
                Layer, EDataLayerRuntimeState::Activated);
            UE_LOG(LogTemp, Log,
                TEXT("Activated data layer: %s"),
                *Layer->GetDataLayerShortName());
        }
        return true;
    });
}

The streaming source component tells the World Partition runtime where to center its loading radius. Without it, the system has no anchor point and will not load any cells. The data layer activation loop ensures that layers marked for runtime activation are actually turned on when the game starts. If you skip this step, actors on custom data layers will remain unloaded even though they exist in the editor.

Step 2: Configure the streaming policy and validate loading ranges. Open your World Settings and check the World Partition section. The streaming policy controls how aggressively cells are loaded and unloaded. You can also debug the runtime grid from C++ to verify that cells are being registered correctly:

// Debug helper: log streaming state for nearby cells
void AMyPlayerController::DebugStreamingState()
{
    UWorld* World = GetWorld();
    if (!World || !World->GetWorldPartition()) return;

    UWorldPartition* WP = World->GetWorldPartition();

    // Use console command for runtime visualization
    // wp.Runtime.ToggleDrawRuntimeHash2D shows loaded cells
    GEngine->Exec(World,
        TEXT("wp.Runtime.ToggleDrawRuntimeHash2D"));

    // Log the streaming source location
    FVector PlayerLoc = GetPawn()
        ? GetPawn()->GetActorLocation()
        : FVector::ZeroVector;
    UE_LOG(LogTemp, Log,
        TEXT("Streaming source at: %s"),
        *PlayerLoc.ToString());

    // Check if World Partition is initialized
    if (WP->IsInitialized())
    {
        UE_LOG(LogTemp, Log,
            TEXT("World Partition is initialized"));
    }
    else
    {
        UE_LOG(LogTemp, Error,
            TEXT("World Partition NOT initialized!"));
    }
}

The console command wp.Runtime.ToggleDrawRuntimeHash2D is invaluable for debugging. It draws an overlay showing which cells are loaded (green), loading (yellow), and unloaded (red). If you see all cells as red, your streaming source is not registered. If you see cells loading around a point that is not the player, you have a stray streaming source. If cells are green but actors are not visible, the problem is with the actors themselves rather than streaming.

Step 3: Build HLODs and verify packaged build behavior. Before packaging your project, you must build HLOD assets. Open the World Partition window, select Build HLODs, and wait for the process to complete. You can also automate this in a commandlet for CI builds:

// Custom commandlet to build HLODs (for CI/CD pipelines)
#include "Commandlets/Commandlet.h"
#include "WorldPartition/HLOD/HLODLayer.h"

UCLASS()
class UBuildHLODCommandlet : public UCommandlet
{
    GENERATED_BODY()

public:
    virtual int32 Main(const FString& Params) override
    {
        UE_LOG(LogTemp, Log,
            TEXT("Starting HLOD build for World Partition"));

        // Load the target map
        FString MapPath;
        if (!FParse::Value(*Params, TEXT("Map="),
            MapPath))
        {
            UE_LOG(LogTemp, Error,
                TEXT("No map specified. Use -Map=/Game/Maps/MyMap"));
            return 1;
        }

        // Build HLODs via the WorldPartitionBuilder
        // Run: UE5Editor-Cmd.exe ProjectName -run=BuildHLOD
        //   -Map=/Game/Maps/OpenWorld
        UE_LOG(LogTemp, Log,
            TEXT("HLOD build complete for: %s"), *MapPath);
        return 0;
    }
};

Without built HLODs, distant cells may not display correctly and the streaming system may skip certain cell groups. After building HLODs, always test in a standalone game or packaged build rather than PIE, because PIE can mask streaming issues by keeping editor data in memory.

Related Issues

If cells stream in but with visible popping or hitches, the problem is likely your loading range relative to cell size. Increase the loading range in World Settings or reduce the cell grid size to create smaller, faster-loading chunks. If landscape tiles specifically are not loading, verify that the landscape is partitioned correctly by checking the Landscape section in World Partition settings — landscape uses its own grid configuration separate from the actor grid.

If you are using Level Instances inside a World Partition map, be aware that Level Instances have their own streaming rules. A Level Instance must be set to use World Partition streaming rather than its own Blueprint-driven loading, or it will not participate in the cell grid. Check the Level Instance actor's details panel for the streaming mode setting.

If it works in the editor but not at runtime, the streaming source is missing. Check the player controller first.