UE Level Streaming Guide

Learn how to divide a large world into sublevels that load and unload based on player proximity, reducing memory usage and improving frame rates.

Desired outcome

Enable seamless streaming of large worlds by dividing them into sublevels that are loaded and unloaded at runtime based on player proximity. This reduces memory usage, improves frame rates, and keeps only the necessary geometry active.

Prerequisites

Unreal Engine 4.27 or later (UE5 Early Access also supported).
A project with World Composition enabled (Edit → Project Settings → Engine → World Composition).
Sublevels created in the Levels panel (right‑click → Add Level → Create New Level).
Basic familiarity with Blueprint visual scripting or C++.
Player start placed in a persistent level that will remain always loaded.

Procedure

\nEnable World Composition\n
1. Open Edit → Project Settings.
2. Navigate to Engine → World Composition and check Enable World Composition.
3. Restart the editor if prompted.
\n
\nCreate and configure sublevels\n
1. In the Levels panel, right‑click the persistent level and choose Add Level → Create New Level for each streaming region.
2. Select each new level, open its Details panel, and set Streaming Method to either Level Streaming Volume or Blueprint (choose one method consistently for simplicity).
3. If using Level Streaming Volume, place a Level Streaming Volume actor in the level and adjust its bounds to cover the intended streaming area.
\n
\nSet up player‑proximity triggers\n
1. Open the persistent level (or a dedicated Blueprint) and add a Box Collision component where you want the trigger to exist (e.g., around the player start).
2. Set the collision to generate overlap events (Collision → Generate Overlap Events enabled).
3. In the Blueprint graph, add:
4. For each node, set the Level Name to the exact name of the sublevel you created (case‑sensitive).
5. Optionally enable Make Visible After Load and Should Be Loaded on the nodes to control visibility.
\n

\nAlternative C++ approach\n

If you prefer C++, implement the same logic in your APlayerController or a custom AActor:

void AMyStreamingActor::BeginOverlap(UPrimitiveComponent* OverlappedComp, AActor* OtherActor,\n    UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)\n{\n    UGameplayStatics::LoadStreamLevel(this, FName(TEXT(\"Sublevel_01\")), true, true, FLatentActionInfo());\n}\n\nvoid AMyStreamingActor::EndOverlap(UPrimitiveComponent* OverlappedComp, AActor* OtherActor,\n    UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)\n{\n    UGameplayStatics::UnloadStreamLevel(this, FName(TEXT(\"Sublevel_01\")), FLatentActionInfo());\n}\n

Replace Sublevel_01 with your level’s name.

\nSet persistent gameplay objects\n
Ensure that the player controller, game mode, HUD, and any objects that must survive streaming are placed in the persistent level, not inside any streamed sublevel.
\n

Expected checks

While playing in the editor, open the World Outliner and watch the eye icon next to each sublevel: it should appear when the player enters its volume and disappear when exiting.
Use the console command stat streaming to see memory allocated for streaming levels; values should drop when levels are unloaded.
Run show collision to verify that only the currently loaded sublevels have collision rendered.
Check the Output Log for any warnings like Warning: Failed to load stream level; if present, verify that the level’s package is cooked and referenced in DefaultEngine.ini under [Streaming].

Recovery options

If a sublevel fails to load or unload correctly:

Manually toggle its visibility in the World Outliner to force a reload.
Restart the play session; the persistent level will reset all streaming states.
Review the Blueprint or C++ overlap logic for missing references or incorrect level names.

Limitations and practical verification

Streaming volumes only work with simple axis‑aligned boxes or shapes; complex geometry may require multiple volumes or Blueprint‑based distance checks.
Actors with hard references (e.g., direct variable pointers) to objects in a streamed level will cause those objects to persist after unload, leading to memory leaks. Use weak pointers or event‑based communication to avoid this.
To confirm that memory usage actually drops, run memreport -full before entering a volume and after exiting; compare the Total allocated memory values. A successful stream should show a noticeable reduction proportional to the size of the unloaded level(s).

By following these steps you can implement persistent level streaming that adapts to player movement, keeping your world large yet performant. Adjust the size and placement of streaming volumes to match your level design, and always verify with the provided checks before shipping.

Implement Persistent Level Streaming in Unreal Engine Using World Composition