Level Transitions in UE5: Carrying Score to the Next Screen with Open Level

You collected coins worth 30 points in the stage. Move to the results screen, though, and the score is back to 0. Switching screens does not automatically carry numbers over.

Reopening a level in UE cleans up what was running in the previous one. So you need to decide where to leave values before moving and where to read them afterwards .

This article uses Open Level and GameInstance to build a title → stage → results loop. We switch with keys first and add a fade once the score carries over. Before wiring it into buttons and coins, let's test the level-linking part small.

What You'll Learn

• The two ways of specifying Open Level's destination
• Why numbers live in GameInstance, and how to read and write them
• Initializing at the title and reading at the results screen
• Fading, and verifying transitions after packaging

Open Level opens the next level

A level transition moves from the current level to another. To move from a title level to a stage level, specify the stage as Open Level's destination.

In other engines : this is Unity's SceneManager.LoadScene and Godot's change_scene_to_file() .

Open Level's white output is not a "the next level finished loading" notification. Do not treat logic wired after it as running at the destination.

Put saving and cleanup before Open Level and destination setup in the destination's BeginPlay. Save the score you want on the results screen first and call the results display on the results side. BeginPlay is the entry when that level's play begins.

The moment Open Level is called, the current level begins tearing down. The Level Blueprint or Actor holding this graph ends with it , so a Delay or fade placed after it will not run to completion. Do what you need before Open Level.

Specify by name or choose from a list

Open Level comes in two forms. This article uses by Object Reference since the destinations are fixed.

Node	How you specify the destination	What to watch for
Open Level (by Name)	Type a name such as L_Stage01 into Level Name	Typos. Also confirm the destination is in the build
Open Level (by Object Reference)	Choose the level asset from the Level list	Confirm what you chose. Also confirm build inclusion

A reference points at "which asset to use". Choosing directly reduces mistakes like writing L_Stage1 for L_Stage01 . Use by Name when you want to switch by name, but a reference alone does not decide package inclusion.

Leave the other inputs at "Absolute" on and "Options" empty at first. Absolute decides whether to inherit previous travel options, and Options is extra information passed on transition. Our score goes into the GameInstance described next.

What gets rebuilt and what survives

A normal Open Level cannot carry Actors from the previous level into the next. Actors are the things running in a level, such as the player and coins.

Where the data lives	After a normal Open Level
Actors such as coins and the player	The previous instances end. Rebuild what the next level needs
Level Blueprint variables	Previous values are not carried over
GameMode / GameState / PlayerState	Rebuilt. Hand values to another home to keep them
Numbers and strings in GameInstance	Persist while the same game is running
Save files written to disk	Persist after the game exits

GameInstance is the container used from game launch to exit. It stays the same across level reloads, which suits our score.

In other engines : this is a management object with DontDestroyOnLoad in Unity and Godot's Autoload (singleton) . You do not have to prevent duplicate creation as in Unity, but it only works once registered in Project Settings , like Godot's Autoload.

Note that storing an Actor reference in GameInstance does not keep that Actor alive . Rather than remembering the coin itself, keep data such as "30 points" or "item kinds and counts".

UI Widgets are not containers for carrying the previous level's state either. Their lifetime depends on how you hold them, so removing unneeded Widgets with Remove from Parent before a transition and creating the UI you need at the destination keeps things tidy.

We cover a normal Open Level in a single-player game. Networked Seamless Travel and Level Streaming, which adds parts of a level to the same world, differ in what survives and in procedure.

Create a place for score in GameInstance

First prepare a GameInstance for your game.

1. Open "Blueprint Class → All Classes" in the Content Browser and create one with GameInstance as the parent.
2. Name it BP_GameInstance and add an Integer variable TotalScore . Integer handles whole numbers.
3. Compile, set the default to 0 , and save.
4. Set BP_GameInstance in "Project Settings → Maps & Modes → Game Instance Class".

Creating and registering are separate tasks. Forget step 4 and the game uses the default GameInstance, leaving your TotalScore unreadable.

To fetch it during play, use Get Game Instance and connect its Return Value to Cast To BP_GameInstance 's Object. A Cast confirms the fetched target is your class. On success, "As BP Game Instance" names the target holding TotalScore.

Even with a GameInstance present, the Cast fails if a different class is registered . Do not assume it succeeds just because you created one.

Quitting the game or stopping editor Play ends that container too. Keeping values for the next launch needs saving and loading. For a deeper look at where things live, go to the GameInstance article.

Hands-On: link three levels with a score

We use the Third Person template. Instead of buttons and coins at first, Enter starts, K adds 10 points, and G goes to results . Add three times, move to results, and SCORE: 30 means success.

1. Prepare three levels

Save the template level where the player moves under new names with "File → Save Current Level As" and create these three under Content/Maps . Carry over the floor, Player Start, and Third Person GameMode settings.

Level	Its role here
L_Title	Resets the score to 0 and starts
L_Stage01	Adds to the score
L_Result	Displays the carried score and returns to the title

The same scenery is fine. A controllable player appears in each level. The names are similar, so confirm which level you have open before editing. Set Play options to "Number of Players: 1" and "Net Mode: Play Standalone".

Open each level's "Blueprints → Open Level Blueprint" and Print Strings of L_Title , L_Stage01 , and L_Result from BeginPlay make destinations easy to tell apart. Turn on screen and log output with Duration 10.0 (see using logs).

2. First build a loop that only switches

Place keyboard events in each Level Blueprint and wire Pressed's white output to Open Level. Choose the destination in the by Object Reference Level field.

Level being wired	Key	Destination
L_Title	Enter	L_Stage01
L_Stage01	G	L_Result
L_Result	Enter	L_Title

Compile, save, and Play from L_Title. Click the game window so it receives input, then press Enter, G, and Enter. Level names appearing in order in the Output Log means the loop works. We prepare the return path from results here too.

3. Reset the score to 0 at the title

Stop Play and add GameInstance-fetching logic to L_Title's BeginPlay.

1. Wire BeginPlay's white exec to Cast To BP_GameInstance .
2. Connect Get Game Instance 's Return Value to the Cast's Object.
3. Drag from the Cast's "As BP Game Instance" and place Set TotalScore , connecting the Cast result to the Set's Target.
4. Wire the Cast's success white output to the Set with TotalScore's input value 0 . Continue to the level-name Print String after it.

Set puts a value into a specified target's variable. Here it zeroes the fetched GameInstance's TotalScore, not the Level Blueprint's own.

Putting this initialization on the results side would erase the score you wanted to display. Resetting to 0 at the title, where a new run starts, makes retries clear.

4. Build the logic that adds 10 points

Open BP_GameInstance and create a function AddTen from the + on "My Blueprint → Functions". A function is a named block of logic callable from elsewhere. We add no inputs or outputs; it just adds 10.

1. Drag TotalScore into the graph, choose "Get", and read the current value.
2. Connect it to an integer + node with 10 on the other input.
3. Drag TotalScore again, this time choosing "Set", and connect the addition's result to the Set's numeric input.
4. Wire the function's start node AddTen to the Set's white exec input.

This graph is inside the GameInstance, so Get and Set read and write Self's TotalScore. Compile and save.

Then return to L_Stage01's Level Blueprint and call K's Pressed → Cast To BP_GameInstance → Add Ten. Connect Get Game Instance's Return Value to the Cast's Object and the Cast's "As BP Game Instance" to Add Ten's Target.

Get Game Instance only fetches a target, so it has no white exec pins. White wires carry order and blue wires carry the target. Pass Get Game Instance into the Cast's Object and the successful result into Add Ten's Target.

5. Read it on the results screen

From L_Result's BeginPlay, fetch the target with Get Game Instance and a Cast the same way. This time do not change TotalScore; read it with a Get.

1. Place Get TotalScore from the Cast's "As BP Game Instance".
2. Create To String (Integer) from its output to turn the integer into text.
3. Place an Append node joining strings, with SCORE: in A and the converted text in B.
4. Connect Append's Return Value to Print String's In String. Wire white exec from the Cast's success side to Print String.

Set Print String's Duration to 10 seconds with screen and log output on. Replacing the original level-name Print String with this results display is fine. Keep the Enter wiring returning to the title.

The "on-screen display" here is a debug Print String. A production results screen passes the same value to UMG Text.

6. Vary the number of additions and confirm

After compiling and saving everything, Play from L_Title again. Pressing the editor's stop button also ends the GameInstance, so always move to results with the in-game G key.

Action	Results screen display
Enter → K three times → G	SCORE: 30
Enter → K twice → G	SCORE: 20
Enter → G without pressing K	SCORE: 0
Return to the title with Enter and loop again	It does not add to the previous score; it starts from 0

Finally, temporarily disconnect L_Title's Set TotalScore = 0 and have BeginPlay call only the level-name Print String. Loop again without stopping Play and the previous score persists. Persistence itself is GameInstance's doing; when to reset to 0 is yours to decide. Restore the initialization wiring afterwards.

Fade before transitioning

With the score carrying over, add a fade just before moving from the stage to results. It softens an abrupt cut.

Stage side: wait for the fade, then Open Level

In L_Stage01, change the wire going straight from G to Open Level into this order.

G's Pressed → Do Once → Start Camera Fade → Delay → Open Level

Do Once passes execution through only the first time. Leave "Start Closed" off and Reset unconnected. It prevents mashing G during the fade from restarting the same transition.

Connect Get Player Camera Manager 's Return Value to Start Camera Fade's Target with Player Index 0 , our single player. The Player Camera Manager manages that player's camera view.

Start Camera Fade setting	Value
From Alpha	0.0
To Alpha	1.0
Duration	0.5
Color	Black
Should Fade Audio	On
Hold when Finished	On

Alpha is the color's opacity. 0 shows the original view and 1 covers it with the specified color. Here it goes black over 0.5 seconds. Should Fade Audio lowers volume with it, and Hold when Finished keeps the black afterwards.

Start Camera Fade begins the fade and continues immediately to the next node. So set Delay to 0.6 seconds, slightly longer than the 0.5-second fade. Wire its Completed to Open Level specifying L_Result. Delay holds the logic after it, not the whole game.

The diagram shows from Start Camera Fade onward. Connect Do Once's Completed to the white exec input at the left.

Results side: fade back in

Insert a Start Camera Fade between L_Result's BeginPlay and the GameInstance Cast. Pass this level's Get Player Camera Manager (Index 0) to Target.

Set From Alpha 1.0 , To Alpha 0.0 , Duration 0.5 , Color black, Should Fade Audio on, and Hold when Finished off. Continue from its white output into the score fetching and display you already built.

Now pressing G darkens the screen before the level changes and brightens again on the results side. The longer the load, the longer the darkness. A fade does not shorten loading, so revisit the loading side if the wait bothers you.

A camera fade does not cover normal UMG display. To darken the title and HUD too, use a Widget with a full-screen black Image. Our Print Strings are not fade-verification UI either, so watch the camera view's change rather than the text.

Why a loading Widget freezes

A Widget groups UI such as text and buttons. When you want an animated icon during loading, simply lining up Create Widget → Add to Viewport → Open Level does not necessarily keep it animating.

Normal level loading includes synchronous processing that makes the game wait until it finishes . During that, logic driving a normal Widget stops too, so it may enter loading before it is drawn, or freeze while displayed.

Inserting a Delay before Open Level buys time to display the Widget first. That alone does not make it animate during loading, though. For short transitions, finishing a fade first is a good starting point.

If you need an animated loading screen, consider dedicated mechanisms such as MoviePlayer, or a structure that keeps the current world running during loading. "Insert a light loading level and Open Level again from there" simply produces the same wait on the next load.

Confirm the loop still works after packaging

A map that opens in the editor cannot be reached if it is not in the shipped game. Packaging converts the needed assets for the target platform and gathers them into a distributable form.

1. Find "List of maps to include in a packaged build" under "Project Settings → Packaging".
2. Register L_Title, L_Stage01, and L_Result.
3. Set "Maps & Modes → Game Default Map" to L_Title.
4. In the packaged game, loop title → stage → results → title.

The conversion that includes assets in the game is called Cook . Custom build pipelines may use different map lists or exclusions, so confirm with the actual build in the end. Use a Development build while verifying with Print String, and move results display into UMG for a Shipping build (see the packaging article).

Bonus: building transitions into a game

When it does not work

Symptom	Where to check
The GameInstance Cast fails	Maps & Modes' Game Instance Class. A Print String from Cast Failed confirms it
The score is always 0	Whether AddTen was called, whether the results side initializes, whether you stopped Play midway
The score persists into the next loop despite initializing	Whether the GameInstance fetched in L_Title is passed to Set TotalScore's Target
The fade cuts off midway	Whether Delay is shorter than the Fade's Duration, whether Hold when Finished is on
It stays black and never advances	The destination specification and inclusion, load errors in the Output Log, the results-side fade in
Keys do not move you	Whether you are in the open level's graph, whether input reaches the game window, whether white exec is wired
Keys work only at the destination	Whether that level's GameMode differs. Without inheriting the template's GameMode, the input receiver changes
You appear below the floor or in an odd place	Whether the destination has a Player Start. Without one you spawn at the origin and can fall off the floor

Replace keys with buttons and goals

Once the loop works, replace the title's Enter with a button's OnClicked, the stage's K with picking up a coin, and G with touching a goal. The entry points change but "add points → move to results → read the saved value" stays the same. Building coins and goals is covered in the coin-collecting game.

Once transitions are called from several places, gather them into one piece of logic including the mash guard. A Level Blueprint is specific to its level, so shared logic belongs somewhere like a GameMode (see Level Blueprint versus Blueprint Class).

The difference between Open Level and Level Streaming

Open Level replaces the world. Level Streaming adds parts of a level into the same world and removes what is unneeded.

Open Level suits switching from title to the main game, while walking seamlessly into an adjacent room suits Level Streaming. Unloading a streamed part also ends the Actors belonging to it, so not everything survives (see the Level Streaming article).

Restarting the same stage from the beginning can use Open Level too. GameInstance's score persists, though, so decide retry initialization separately. To return to a resume point without reloading the stage, checkpoints and respawn fits better.

Summary

When moving levels with Open Level, leave numbers such as score in GameInstance and read them at the destination. Also decide when to reset them to 0, matching your game's loop.

Confirm switching, carrying over, and retrying with keys first. Add a fade and UI, and once the loop still works in a packaged build, you have the foundation linking your whole game.

Further Reading

• Epic: Open Level (by Object Reference)
• Epic: Open Level (by Name)
• Epic: GameInstance
• Epic: Start Camera Fade
• Epic: Project settings and Packaging
• Epic: MoviePlayer