Save System in UE5

What You Will Build

You will build a small Save and Load system that can store the player position and restore it later. The system uses Unreal Engine’s built-in SaveGame workflow, so there are no plugins and no C++ required.

The final system includes:

• A custom SaveGame Blueprint
• A Transform variable to store player position and rotation
• Keyboard input for saving
• Keyboard input for loading
• A save slot name
• A check to confirm whether save data exists
• Automatic loading when the game starts
• Basic debug output for missing save files

Why SaveGame Blueprints Matter

Unreal Engine has a built-in SaveGame class designed specifically for storing data between play sessions. A normal Blueprint actor only exists while the level is running. If you close the game, that actor data is gone unless you write it into a save file.

A SaveGame Blueprint acts like a data container. You put variables inside it, fill those variables during gameplay, and then write the SaveGame object to a slot on disk.

Later, you can load that same slot, cast it back to your SaveGame class, read the stored variables, and apply them back to the game.

The simple version looks like this:

Save:
Create SaveGame Object
Store player data inside it
Save Game to Slot

Load:
Check if save exists
Load Game from Slot
Cast to your SaveGame class
Read saved data
Apply it back to the player

Step 1: Create the SaveGame Blueprint

Open the Content Drawer and create a new Blueprint class.

Right-click → Blueprint Class → SaveGame

Name it:

BP_MySave

Open BP_MySave. This Blueprint will store the data we want to save.

Create a new variable:

Variable Name: PlayerTransform
Variable Type: Transform

Compile and save the Blueprint.

The Transform type is useful here because it contains the player’s world position and rotation in one clean variable. For this beginner save system, we do not need separate variables for X, Y, Z, pitch, yaw, and roll. A single Transform is enough.

What a Transform Stores

A Transform in Unreal Engine stores three pieces of information:

• Location: where the actor is in the world
• Rotation: which direction the actor is facing
• Scale: how large the actor is

For this tutorial, the most important part is location. But saving the full transform is still useful because it also restores the facing direction of the character.

In a real checkpoint system, you may later decide to save only location and rotation. But for a simple Blueprint tutorial, saving the full transform keeps the system easy to understand.

Step 2: Open the Character Blueprint

Open the Blueprint that controls your player character. In the Third Person Template, this is usually:

BP_ThirdPersonCharacter

This is where we will create the save and load input logic.

For testing, we will use:

H key = Save
J key = Load

You can later replace these with Enhanced Input actions, menu buttons, checkpoint triggers, or auto-save events. Keyboard input is only used here because it is fast for testing.

Step 3: Add the Save Input

Inside the Event Graph of BP_ThirdPersonCharacter, add an H key event.

H Key Pressed

This event will trigger the save logic.

Good practice: add a comment around this section and label it clearly.

Save Player Position

Clean comments matter. Even in small tutorials, readable Blueprints help you avoid confusion later when the graph grows.

Step 4: Create the Save Game Object

From the H key execution pin, create a SaveGame object.

Create Save Game Object
Class = BP_MySave

This creates a new instance of your SaveGame Blueprint in memory. It is not saved to disk yet. At this stage, it is just an object we can fill with data.

Promote the return value to a variable if you want to store it temporarily.

Variable Name: SaveObject
Type: BP_MySave Object Reference

This makes the graph easier to read because you can reuse the same reference in the save flow.

Step 5: Store the Player Transform

Now get the current transform of the player character.

Get Actor Transform

Then set the PlayerTransform variable inside the SaveObject.

SaveObject → Set PlayerTransform
Value = Get Actor Transform

This is the core of the save system. You are taking the current player location and rotation, then storing it inside the SaveGame object.

At this point, the save data exists only in memory. Next, we need to write it into a save slot.

Step 6: Save the Data to a Slot

Add the Save Game to Slot node.

Save Game to Slot

Configure it like this:

Save Game Object = SaveObject
Slot Name = MySave
User Index = 0

The Slot Name is important. Unreal uses this name to identify the saved file. When you load the game later, you must use the exact same slot name.

For this tutorial, use:

MySave

If you accidentally save to one slot name and load from another, the load logic will not find the file.

Save Logic Recap

The save flow should look like this:

H Key Pressed
  Create Save Game Object BP_MySave
  Get Actor Transform
  Set PlayerTransform on SaveObject
  Save Game to Slot
    Slot Name = MySave
    User Index = 0

This saves the current player transform to disk.

Step 7: Add the Load Input

Now add the J key event inside BP_ThirdPersonCharacter.

J Key Pressed

Add a comment around this section:

Load Player Position

This input will check whether save data exists, load it, and apply the saved transform to the player.

Step 8: Check if Save Game Exists

Before loading, always check if the save file exists.

Does Save Game Exist
Slot Name = MySave
User Index = 0

Connect the return value into a Branch node.

True = Load save
False = Print no save message

This prevents errors and gives you clean feedback if the player tries to load before saving.

On the False output, add:

Print String: No Save Exists

Step 9: Load the Save Game from Slot

From the True output of the Branch, load the save file.

Load Game from Slot
Slot Name = MySave
User Index = 0

This returns a generic SaveGame object. Unreal does not automatically know that it is your BP_MySave class, so you need to cast it.

Cast To BP_MySave

After the cast succeeds, you can access PlayerTransform.

Step 10: Apply the Saved Transform

From the casted BP_MySave object, get the PlayerTransform variable.

Get PlayerTransform

Then apply it to the player character.

Set Actor Transform
New Transform = PlayerTransform

Now when you press J, the player should move back to the saved position.

This is the visible proof that the save system works.

Load Logic Recap

The load flow should look like this:

J Key Pressed
  Does Save Game Exist
    Slot Name = MySave

  Branch
    False:
      Print String "No Save Exists"

    True:
      Load Game from Slot
      Cast To BP_MySave
      Get PlayerTransform
      Set Actor Transform

This safely checks for a save file before trying to load it.

Step 11: Test Manual Save and Load

Now test the system in the level.

1. Press Play.
2. Move the player to a location.
3. Press H to save.
4. Move somewhere else.
5. Press J to load.

If everything is correct, the player should return to the saved position.

If you press J before saving, you should see the debug message:

No Save Exists

Step 12: Auto Load on BeginPlay

Manual loading is useful for testing, but many games load save data automatically when the level starts.

To do this, use Event BeginPlay inside BP_ThirdPersonCharacter.

Event BeginPlay
  Does Save Game Exist
  If true:
    Load Game from Slot
    Cast To BP_MySave
    Set Actor Transform

This means that when the level begins, Unreal checks whether a save exists. If it does, the character moves to the saved transform automatically.

If no save exists, the character stays at the normal spawn point.

Why Use Does Save Game Exist?

This node is important because loading a missing save file is a bad workflow. If there is no save slot yet, your load logic has nothing to read.

The correct approach is:

Check first.
Load only if it exists.
Show a message or use default values if it does not exist.

This makes the system more stable and easier to debug.

Slot Names Explained

The Slot Name is the identifier for your save file.

MySave

In this tutorial, we use one slot. That is enough for a simple project.

In a bigger game, you may use multiple save slots:

SaveSlot_01
SaveSlot_02
SaveSlot_03

Or you may generate slot names based on the player profile:

Player_001_Save
Player_002_Save

The important rule is simple: the slot name used for saving must match the slot name used for loading.

User Index Explained

Most beginner tutorials use User Index 0. That is fine for single-player testing and simple save systems.

User Index is mostly useful when dealing with multiple local users or platform-specific user profiles. For a basic Unreal Engine save system, keep it at:

0

Common Problem: Load Does Nothing

If pressing J does nothing, check these points:

• Did you press H first to create a save?
• Is the Slot Name exactly the same in Save and Load?
• Did Does Save Game Exist return true?
• Did Load Game from Slot connect to Cast To BP_MySave?
• Are you calling Set Actor Transform on the player character?

Most beginner issues come from mismatched slot names or forgetting to cast the loaded SaveGame object.

Common Problem: Player Loads in the Wrong Place

If the player loads in the wrong place, confirm that you are saving the correct actor.

If your save logic is inside BP_ThirdPersonCharacter, then Get Actor Transform should refer to the player character. If you place the save logic somewhere else, like Level Blueprint, you must make sure you are getting the correct player reference.

In Level Blueprint, you would usually need:

Get Player Character
Cast To BP_ThirdPersonCharacter
Get Actor Transform

But in the character Blueprint itself, Get Actor Transform already refers to self.

Common Problem: Auto Load Fights the Spawn System

Sometimes auto-loading on BeginPlay can conflict with other systems that also move the player at startup. For example, checkpoints, level streaming, teleporters, or spawn managers.

If that happens, you may need a small delay before loading:

Event BeginPlay
  Delay 0.1
  Load Save

Do not overuse delays, but for simple beginner projects, a short delay can help when another system is still initializing.

What This System Does Not Save Yet

This tutorial saves only the player transform. That is enough to learn the foundation, but it is not a complete full-game save system.

It does not save:

• Health
• Inventory
• Ammo
• Quest progress
• Enemy states
• Destroyed objects
• Level name
• Unlocked doors
• Player stats
• Game settings

But the same pattern can be expanded. You add more variables to BP_MySave, set them before saving, and read them after loading.

How to Expand This Save System

After saving the player transform, the next logical step is saving more player data.

Example variables you can add to BP_MySave:

PlayerTransform : Transform
PlayerHealth : Float
PlayerCoins : Integer
CurrentLevelName : Name
InventoryItems : Array
CheckpointID : Integer

Then, inside your save logic, set each variable before calling Save Game to Slot.

Inside your load logic, read each variable and apply it back to the correct system.

Better Architecture for Larger Projects

For a small tutorial, placing save logic inside the character Blueprint is acceptable. It is fast and beginner-friendly.

For a larger game, you may want to move save and load logic into one of these:

• Game Instance
• Player Controller
• Game Mode
• A dedicated Save Manager Blueprint
• A C++ save subsystem

A Save Manager is cleaner because it keeps save logic in one place instead of spreading it across multiple actors.

A more scalable architecture looks like this:

Player presses Save
  Save Manager collects data
  Save Manager writes SaveGame object

Player loads game
  Save Manager reads SaveGame object
  Save Manager applies data to player, world, and systems

Manual Save vs Auto Save

This tutorial uses manual save with H and manual load with J, plus auto-load on BeginPlay.

In a real game, you might use different save triggers:

• Save when the player reaches a checkpoint
• Save when the player sleeps or rests
• Save after completing a quest
• Save when changing levels
• Save from a pause menu button
• Auto-save every few minutes

The underlying SaveGame logic remains similar. Only the trigger changes.

Best Practices

• Use a clear SaveGame Blueprint name, such as BP_MySave or BP_PlayerSaveGame.
• Keep slot names consistent between saving and loading.
• Always check Does Save Game Exist before loading.
• Use Print String while testing to confirm save and load events happen.
• Start with simple data before building a complex system.
• Move save logic into a manager later if the project grows.
• Do not store temporary runtime-only data unless you really need it after loading.
• Be careful when loading transforms in levels with moving platforms or streaming areas.

Complete Blueprint Summary

Here is the full system in simple form.

Save Input

H Key Pressed
  Create Save Game Object BP_MySave
  Set PlayerTransform = Get Actor Transform
  Save Game to Slot
    Slot Name = MySave
    User Index = 0

Load Input

J Key Pressed
  Does Save Game Exist
    Slot Name = MySave
    User Index = 0

  If true:
    Load Game from Slot
    Cast To BP_MySave
    Get PlayerTransform
    Set Actor Transform

  If false:
    Print String "No Save Exists"

Auto Load

Event BeginPlay
  Does Save Game Exist
  If true:
    Load Game from Slot
    Cast To BP_MySave
    Set Actor Transform

Conclusion

You now have a working Save and Load system in Unreal Engine 5 using Blueprints. The setup creates a SaveGame Blueprint, stores the player transform, saves it to a slot, loads it back with keyboard input, and restores the saved position automatically when the level starts.

This is not a full RPG save system yet, but it is the correct foundation. Once you understand this workflow, expanding it is straightforward. Add more variables to the SaveGame Blueprint, fill them during save, and apply them during load.

This small system teaches the core pattern behind almost every save system in Unreal Engine:

Store data
Write it to a slot
Load it later
Apply it back to the game

Watch the full tutorial: How to Make a Save System in Unreal Engine 5

More Unreal Engine tutorials: rambod.net

Subscribe for more: Rambod YouTube Channel

Frequently Asked Questions

Can this save system work in any Unreal Engine project?

Yes. This method works in Blueprint projects and C++ projects because it uses Unreal Engine’s built-in SaveGame system.

Does this save system save the whole level?

No. It only saves the variables you manually store in the SaveGame object. In this tutorial, that is the player transform.

Can I save inventory with this system?

Yes. Add inventory variables to your SaveGame Blueprint, then write your inventory data into those variables before saving.

Why do we use a Transform variable?

Transform stores location, rotation, and scale. It is an easy way to save and restore the player’s position and direction.

Why does loading fail?

Most likely, no save exists yet, the slot name is different, or the loaded SaveGame object was not cast to the correct BP_MySave class.

Should save logic stay inside the character Blueprint?

For beginner tutorials, yes. For larger projects, move the logic into a Save Manager, Game Instance, or Player Controller to keep the architecture cleaner.

Can I auto-save instead of pressing H?

Yes. You can trigger the same save logic from checkpoints, timers, level transitions, menu buttons, or quest completion events.