Skip to content

Open Level

At a glance

Lives in: Blueprint API / Game - Target: Gameplay Statics - Returns: no value and no success/failure branch - Changes: starts travel to another map; the current world and its actors are torn down for normal non-streaming travel - Can fail by: bad map name/reference, missing cooked map, wrong travel options, or expecting old-world actors to survive - Official docs: Open Level by Name and Open Level by Object Reference

The one-minute version

  • Open Level loads another map as the active world. It is the beginner "go to the next level" node, not a streaming-level visibility toggle.
  • The current map's actors, GameMode, GameState, pawns, most widgets, timers, and level-script state are normally destroyed or replaced as part of travel.
  • Game Instance survives the map change. Use it for runtime handoff values such as selected character, current slot, or coins for this run.
  • Save-to-disk data is a separate job. Copy values into a SaveGame object and save that object before travel if the data must survive quitting the game.
  • By Name takes a map package name you type. By Object Reference takes a level asset reference, which avoids typo-driven failures and makes the dependency easier to see.
  • The node has no "Completed" or "Failed" output. If travel does not happen, look at the Output Log and check the map reference, packaging settings, and Options string.

What it actually does

Open Level is a Blueprint wrapper around the engine's map-travel path. At beginner altitude, the relationship is:

pseudocode of the engine behavior - not engine source

OpenLevel(WorldContext, LevelNameOrReference, Absolute, Options):
    World = find the current world from the Blueprint context
    Destination = resolve the level name or soft object reference
    TravelURL = build the destination URL and options
    ask the engine to travel to that URL
    // execution has no success return value

If travel succeeds, you do not keep playing in the same world. Unreal moves to the destination map and builds a new world for it. That new world gets its own map actors and its own framework setup:

Current map
-> Open Level
-> old world begins ending
-> destination map loads
-> new GameMode / PlayerController setup / Pawn spawn path runs
-> new map BeginPlay paths run

The exact travel path has more engine hooks than that, especially for multiplayer and seamless travel. The important beginner rule is: Open Level is not a teleport inside the same map. It replaces the loaded world.

By Name vs by Object Reference

Unreal exposes two Blueprint versions:

Variant Level pin Best use Main risk
Open Level by Name Name Small projects, simple map names, menu buttons where you deliberately type the map package name. Typos and renamed maps are just data mistakes until you test the path.
Open Level by Object Reference Soft object reference to a World asset When you can pick the map asset in the editor and want the dependency to be visible. The reference still has to point at a real playable map that is included in the build.

For a first project, prefer Object Reference when the node is available in the place you are working. Use by Name when you are choosing from saved names, command-line style travel, or data that is intentionally stored as text/name.

Do not pass a display title such as "Forest Level" unless that is actually the map package name. Use the asset/map name that the engine can resolve.

The pins that matter

Level Name / Level

This is the destination map.

For by Name, pass the map's package name, commonly the map asset name. For by Object Reference, pick the map asset. In packaged builds, the destination must be cooked and available; a reference or name that works in the editor can still fail in a build if the map was excluded from packaging.

Absolute

Absolute controls what happens to travel URL options:

Value Beginner meaning
true Start the destination URL clean; previous travel options are reset.
false Carry existing options forward and add/override with the Options pin.

Most first-project menu or level-door calls use Absolute = true. Carrying options forward is useful when you intentionally keep URL options through travel, but accidental carryover can make a later map start with stale options.

Options

Options is a travel URL options string. It is not a place to put arbitrary Blueprint objects. It is for text options that the travel path and gameplay setup can parse, such as flags or key/value values your project knows how to read.

Common beginner rule: leave it blank until you have a specific reason. If you do use it, treat it as compact text data:

?Checkpoint=StartGate?Difficulty=Hard

Game code can parse options from the travel URL during map setup. Blueprint beginners usually get cleaner results by putting runtime handoff data in Game Instance, then reading it after the new map starts.

What survives Open Level?

Thing Survives normal Open Level? Beginner note
Game Instance Yes Runtime handoff and manager data for the running game.
Game Instance Subsystems Yes Same broad lifetime as Game Instance.
SaveGame file on disk Yes Only if you explicitly saved values before travel.
GameMode / GameState No The destination map gets its own setup.
Placed actors in the old map No Doors, pickups, enemies, cameras, and managers belonged to the old world.
Spawned actors in the old map No Projectiles, pickups, and runtime enemies are world actors too.
Player pawn / character Usually no The destination GameMode normally spawns or selects a new pawn.
Most widgets Do not rely on it Recreate player UI from the controller/HUD path in the new map.
Actor references stored somewhere persistent The variable may remain; the actor does not Rebuild references from the new world and guard stale ones.

This is why a coin counter stored only on the Character resets, and why a door reference stored in Game Instance becomes useless after leaving that map.

The pattern everyone actually uses

For a level exit that carries run data:

Player overlaps exit trigger
-> Get Game Instance
-> Cast To BP_MyGameInstance
-> Set CoinsThisRun = CurrentCoins
-> Set SpawnEntranceId = "CaveDoor"
-> Open Level by Object Reference (Level = L_Cave)

Then in the destination map:

PlayerController BeginPlay
-> Get Game Instance
-> Cast To BP_MyGameInstance
-> Read SpawnEntranceId / CoinsThisRun
-> find the matching PlayerStart or entrance actor in this map
-> initialize current pawn and HUD

If the data must survive quitting:

Before Open Level or from a save menu
-> Create SaveGame object
-> copy plain values into it
-> Save Game to Slot
-> if save returned true, optionally Open Level

Open Level does not copy variables for you. It only starts the travel.

The C++ twin, for the curious (our own example code):

void AExitTrigger::TravelToNextMap(AActor* OtherActor)
{
    if (!IsValid(OtherActor) || NextMapName.IsNone())
    {
        return;
    }

    if (UTrainingGameInstance* GI =
            GetGameInstance<UTrainingGameInstance>())
    {
        GI->LastEntranceId = EntranceIdForNextMap;
    }

    UGameplayStatics::OpenLevel(this, NextMapName, true, TEXT(""));
}

When it fails (and what failure does)

Open Level has no Failed execution pin. Failure usually looks like "nothing changed," "the editor/package logged a travel error," or "the wrong map/setup appeared."

Common causes:

  1. The map name is wrong. The by-Name variant cannot resolve the destination you typed.
  2. The object reference points at the wrong asset or is empty. Pick the actual level/map asset, not a folder, actor Blueprint, or display label.
  3. The map is not included in the packaged build. Test packaged travel, not only Play-in-Editor travel.
  4. You passed stale or malformed Options. Use Absolute = true while debugging unless you intentionally carry previous options.
  5. You expected old actors to survive. The new map loads, but your old character, door, widget, or manager reference is gone or stale.
  6. You put setup in the wrong class. The destination map may use a different GameMode override, pawn class, PlayerController, or HUD.
  7. You used Open Level when you wanted streaming. If the goal is to keep the current world and reveal another area, use level streaming instead.

Use Print String and the Output Log before the call to prove the graph runs, then check the Output Log after a failed travel attempt. If the map opens but the player setup is wrong, debug the destination map's GameMode settings next.

Open Level vs streaming

The shortest split:

Open Level        = leave this world and load another map as the world
Load Stream Level = keep the persistent world and load/unload a sublevel

Use Open Level for:

  • main menu -> gameplay map;
  • level complete -> next level;
  • restart current map;
  • return to title screen;
  • loading a different self-contained map.

Use level streaming for:

  • interiors or exterior chunks that should share one persistent world;
  • loading areas without destroying persistent actors;
  • doors/elevators that hide streaming transitions;
  • open-world or hub layouts that need sublevels.

The quick path is to use Open Level for every transition. The concrete cost is that anything stored only in the current world disappears, so you spend the next debugging session rebuilding state that streaming would have kept.

Lookalikes - which one do I want?

Node or tool Use when Not the same as
Open Level You want another map to become the active world. Streaming a sublevel into the same world.
Load Stream Level A sublevel should load while the persistent level keeps running. Full map travel.
Unload Stream Level A streamed sublevel should leave the current persistent world. Returning to a previous independent map.
Restart Level / Open current map name You want to reset the current map. Preserving current actors.
Game Instance Runtime values must survive travel. Disk save data or level actors.
SaveGame Values must survive quitting and launching later. Automatic world serialization.
Set View Target with Blend The camera should look through another actor. Moving to another map or possessing a pawn.
Teleport / Set Actor Location An actor should move inside the current world. Changing maps.

Going deeper