Unity UI, save system, and build/export basics

Set up UI buttons on a Canvas, connect them to save and load functions on your player script, and store the data in a file under Application.persistentDataPath. Then test the buttons in Play Mode and verify the saved values still load after restarting the game.

How the save flow works

Saving game data in Unity follows a straightforward pattern. Collect the values you want to store from your player—such as position, level, and health—convert any Unity-specific types (like Vector3) into basic data types, and write them to a file using a custom serializable class. When needed, read this file back, rebuild the player data, and apply it to your player. For very small data like settings or high scores, PlayerPrefs is fine, but for storing actual game progress, use a custom binary file with Application.persistentDataPath to persist data safely between play sessions.

Build the player data class

The first step is to create a separate class that mirrors the player data to be saved. This script is not a component—it only holds data. Level and health are stored as integers, and position as a plain array of floats, not as a Vector3, because Unity-specific types will not serialize.

Visual Studio shows the new PlayerData.cs script alongside the project tree in Solution Explorer. — Brackeys

using System;

[Serializable]
public class PlayerData
{
    public int level;
    public int health;
    public float[] position;

    public PlayerData(Player player)
    {
        level = player.level;
        health = player.health;
        position = new float[3];
        position[0] = player.transform.position.x;
        position[1] = player.transform.position.y;
        position[2] = player.transform.position.z;
    }
}

Create the save system script

Now add a static script to handle writing and reading files, using System.IO and a binary formatter. The save path uses Application.persistentDataPath, ensuring it works everywhere Unity runs. Save and load functions open the file, perform the operation, and close the stream.

The Unity Project window shows the PlayerData script selected while its code is displayed in the Inspector. — Brackeys

using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using UnityEngine;

public static class SaveSystem
{
    public static void SavePlayer(Player player)
    {
        BinaryFormatter formatter = new BinaryFormatter();
        string path = Application.persistentDataPath + "/player.fun";
        FileStream stream = new FileStream(path, FileMode.Create);

        PlayerData data = new PlayerData(player);
        formatter.Serialize(stream, data);
        stream.Close();
    }

    public static PlayerData LoadPlayer()
    {
        string path = Application.persistentDataPath + "/player.fun";
        if (File.Exists(path))
        {
            BinaryFormatter formatter = new BinaryFormatter();
            FileStream stream = new FileStream(path, FileMode.Open);

            PlayerData data = formatter.Deserialize(stream) as PlayerData;
            stream.Close();
            return data;
        }
        else
        {
            Debug.LogError("Save file not found in " + path);
            return null;
        }
    }
}

Wire save and load into the player script

Next, expose public methods in your player script for the Save and Load buttons to call. The save method calls the static save function, and the load method restores the player state from file.

public void SavePlayer()
{
    SaveSystem.SavePlayer(this);
}

public void LoadPlayer()
{
    PlayerData data = SaveSystem.LoadPlayer();
    if (data != null)
    {
        level = data.level;
        health = data.health;
        Vector3 position;
        position.x = data.position[0];
        position.y = data.position[1];
        position.z = data.position[2];
        transform.position = position;
    }
}

Connect buttons in the Unity UI

Attach your Save and Load methods to UI buttons so that they can be triggered in-game. Set up On Click events in the Button component and link to the player object.

The Unity Editor shows the SaveButton selected and the Button component On Click section in the Inspector. — Brackeys

Test the save and load loop

To confirm everything works, change your player values in Play Mode, save, change the values again, then load and check that the values revert to what was saved. Restart Play Mode to verify the data persists between sessions.

The Game view displays a save and load panel with level, health, and position values above Save and Load buttons. — Brackeys

When to use a simpler or larger solution

Also worth knowing

• Automatic file closing: Use a using statement for file streams to ensure files close properly, even if an error occurs.
• Cross-platform paths: When making file paths, use Path.Combine so that your code works across different operating systems.
• Serializing data: Unity types like Vector3 need to be converted to simple data types (like float arrays) before serialization.
• Handling collections: If saving multiple values, a List structure may be easier to work with than an array when splitting and repacking saved data.
• User save choices: You can let players name their save files or select files to load for a more customizable system.
• Scaling with project size: This kind of direct save/load code is ideal for small projects. As things get more complex, a dedicated save system asset can make your workflow easier.

Official reference: Unity manual.

Sources

Screenshots on this page are frames from the videos below, used to illustrate the steps they describe. All rights remain with their creators.

• SAVE & LOAD SYSTEM in Unity — Brackeys, December 2, 2018

Checked against:

• Download Archive — Unity