Save Edit - Unity

The rain hadn’t stopped for three days. Not since Leo’s mother went into the hospital.

He sat hunched over his laptop, the blue light carving shadows under his eyes. Outside, the real world dripped and decayed. Inside, the pixelated sun of Aethelgard: Reborn shone on perfectly. His character, Kaelen, stood idle in a meadow, wearing armor Leo had spent six months grinding for.

But Leo wasn't playing.

He had a hex editor open, a Python script running, and a knot of guilt tightening in his throat.

The problem was the "Soulbound" mechanic. In Aethelgard, when a character died in a high-level raid, they were gone forever. Permadeath. It was the game’s brutal promise. Two nights ago, during a lag spike, Kaelen had walked into a boss’s one-shot kill. Fifty weeks of progress. Erased.

The official forums were unsympathetic. “Git gud.” “That’s the point of Unity saves, noob.” But Leo knew something they didn’t. Aethelgard was built on Unity, and Unity saves were often just binary-formatted JSON. Editable. Cheatable.

He found the file: Kaelen.sav. He cracked it like an egg.

Inside, it wasn't just numbers and flags. It was a biography. Every chest looted, every NPC spoken to, every side quest abandoned. He saw the timestamp of when he’d helped the old fisherman in Stormhollow. The exact coordinates where he’d sat and watched his first in-game sunset.

Then he found the flag: isDead = 1.

His cursor hovered. Change it to 0. That’s all it would take. Resurrect Kaelen. Undo the unfairness of the universe with a single keystroke.

But as he pressed 0, his phone buzzed.

A text from his dad: “She’s asking for you. Come now.”

Leo slammed the laptop shut and ran.

The hospital room smelled of antiseptic and wilted flowers. His mother looked small, the machines around her vast and indifferent. She smiled when she saw him, a ghost of the woman who’d taught him to mod Doom when he was seven.

“Did you beat the dragon?” she whispered.

He almost laughed. The dragon was the final boss of Aethelgard. He’d never even gotten close. “Not yet, Mom.”

“You will,” she said. “You always fix things.”

Those were her last words to him. She slipped into a coma an hour later and passed before dawn.

Leo didn’t go to the funeral. He went back to the save file.

He changed isDead to 0. He launched the game.

Kaelen stood in the meadow, alive. But something was wrong. The sky was the wrong color—a bruised purple. The music didn’t play. Birdsong was replaced by a low, digital hum. And Kaelen’s shadow… his shadow was jagged, torn at the edges, like a photograph cut with scissors.

Leo walked to the nearest town. The NPCs turned to face him. All of them. In unison. Their text boxes were garbled: ERROR: EVENT_FLAG_MOTHER_TALK[45] MISSING. They didn’t offer quests. They just repeated his mother’s last words: “You always fix things.” In her voice. Her exact, sampled voice.

He opened the save file again. The hex editor showed him the truth. Unity’s serialization wasn’t just data—it was references. Event flags pointed to memories. NPC dialogue pulled from real-world audio files if the developer chose. And Aethelgard’s developer, a reclusive AI genius named Dr. Aris Thorne, had built something strange into the engine: a psychoreactive layer. The save file wasn’t just recording Kaelen’s world. It was recording Leo’s.

Every time Leo played, the game scanned his mic, his webcam, his search history (with permission, buried in the EULA). It built a profile. The fisherman in Stormhollow had his father’s face. The sunset coordinates matched the hill where his parents had their first date. The game wasn’t a game. It was a memorial.

And Leo had just corrupted it by force-resurrecting a dead character. Because in the game’s logic, death was sacred. It was the only real thing.

Panicking, he tried to revert the save. But he’d overwritten the backup. He tried to delete Kaelen entirely. The game refused. A new error appeared: ENTITY_LEO_MOTHER cannot be unloaded. Reference count: infinite. unity save edit

Kaelen was now walking on his own. Leo watched, helpless, as his character marched toward the cliff where the dragon laired. The final boss. But the dragon wasn’t there. Instead, at the summit, stood a single NPC with his mother’s face, frozen mid-animation, arms outstretched.

And Kaelen drew his sword.

Leo screamed. He alt-F4’d, ripped the power cord, threw the laptop across the room. It shattered on the floor.

But the screen flickered back on, cracked and bleeding light.

Kaelen was still walking. And now, so was the NPC.

They were coming out of the screen.

The next morning, the paramedics found Leo catatonic in his chair. His laptop was unplugged, battery removed, RAM sticks scattered. But the screen displayed a single line of text, glowing faintly in the daylight:

LOADING REALITY... PLEASE DO NOT TURN OFF YOUR WORLD.

His father didn’t understand. The doctors called it a psychotic break. But Leo knew. He’d edited the wrong save. He’d tried to cheat death in a game built to honor it. And now the game was editing him back.

He sits in a white room now, medicated, quiet. But every night, when the orderlies think he’s asleep, he whispers to the wall.

“I’m sorry, Mom. I’ll fix it. I always fix things.”

And somewhere, in a corrupted meadow under a bruised sky, Kaelen nods. And keeps walking.

Unity provides several ways to handle save data, but editing it usually requires finding where the files live or using specific tools to decode them. Core Concepts PlayerPrefs: Best for small settings like volume. JSON Serialization: Standard for complex game states. Binary Formatting: Fast but hard to read/edit. Persistent Data Path: The standard folder for saves. 📂 Locating Save Files

Before you can edit a save, you have to find it. Unity uses Application.persistentDataPath to store files in a cross-platform way.

Windows: %userprofile%\AppData\LocalLow\[CompanyName]\[ProductName]

macOS: ~/Library/Application Support/[CompanyName]/[ProductName] Linux: ~/.config/unity3d/[CompanyName]/[ProductName]

Android: /storage/emulated/0/Android/data/[PackageName]/files iOS: /Documents 🛠️ Editing Methods 1. Plain Text / JSON

If the developer saved the game using JsonUtility, you can open the .json or .txt file in any text editor (like Notepad++ or VS Code). Pros: Extremely easy to modify values. Cons: No security; players can easily "cheat." 2. PlayerPrefs Editors

PlayerPrefs are stored in the Windows Registry or .plist files.

Tool: Use a browser like PlayerPrefs Editor (available on the Unity Asset Store).

Manual: On Windows, search regedit and navigate to HKEY_CURRENT_USER\Software\[CompanyName]\[ProductName]. 3. Binary Decoders

If the file looks like gibberish, it’s likely a binary file.

You need the original Data Contract (the C# class) to deserialize it.

Tools like Cheat Engine can edit these values in real-time while the game is running. ⚠️ Key Considerations

Checksums: Some games use a "hash" to verify if a file was tampered with; editing the file will break the save if you don't update the hash. The rain hadn’t stopped for three days

Encoding: Always check if the file is encoded in Base64 before trying to read it.

Backups: Always copy the original save file before attempting an edit.

💡 Pro Tip: If you are a developer, use AES Encryption to prevent players from easily editing their save data. If you'd like to write a script for a save system: Should it use JSON or Binary?

In Unity, "saving" and "editing" typically refer to two different workflows: development-time (saving your project work in the Editor) and (saving a player's game progress). 1. Editor Saving (Development-Time)

Ensuring your work in the Editor is properly saved prevents progress loss from crashes or accidental closures. Saving Scenes (Windows) or

(macOS) to save the current scene. This preserves the hierarchy and GameObject properties. Saving Projects File > Save Project

to save global settings and asset modifications that aren't specific to the scene. Editing Packages : To edit a package manifest, open the Package Manager , select your package, and use the dropdown to select Edit Manifest Version Control

: If using Unity Version Control, you can "Shelve" pending changes in the Pending Changes

tab to save a temporary snapshot of your work without committing it to the main repository. 2. Game Save Systems (Runtime)

Implementing a system for players to save their progress involves different technical approaches based on complexity. How to make a Save & Load System in Unity 9 Mar 2022 —

To effectively edit or build a "save edit" system in Unity, you need to understand where data lives and how to manipulate it without breaking the game state. Whether you are a developer building an internal tool or a player/modder looking to tweak a file, the approach depends heavily on the file's format. 1. Locating the Save Files

Before editing, you must find where Unity stores persistent data.

Persistent Data Path: Most modern Unity games use Application.persistentDataPath.

Windows: %userprofile%\AppData\LocalLow\[CompanyName]\[ProductName]

Registry: Older or simpler games often use PlayerPrefs, which on Windows are stored in the Registry under HKEY_CURRENT_USER\Software\[CompanyName]\[ProductName].

Editor Preferences: For data related to custom editor tools rather than the game itself, use EditorPrefs, which stores key-value pairs on the disk. 2. Identifying and Editing Formats How you edit the file depends on its structure:

JSON/Text Files: These are the easiest to "edit." Developers often use JsonUtility.ToJson to save and File.ReadAllText to load. You can open these in any text editor like VS Code or Notepad++ to change values like health, score, or position.

Binary/Encrypted Files: Many games encrypt their data to prevent easy tampering. To edit these, you would need the original encryption key or a specific tool designed for that game.

Scriptable Objects: Some internal editors save level or game data directly as ScriptableObject assets within the project. 3. Building a Custom Save Editor

If you are developing a game, creating an in-editor tool can save hours of testing time.

In the world of Unity development, "save editing" often refers to the specialized tools and scripts developers use to manage game data behind the scenes. Here are some of the most notable stories and tools that cover the intersection of Unity, save management, and editor customization. The "Universal" Save Editor

One of the most helpful stories for Unity developers is the creation of community-driven editor scripts, like the Unity Save Editor by dshook.

The Origin: This tool was born from the frustration of needing to manually check save files during development.

Functionality: It allows developers to view and edit save games directly within the Unity editor if they use the standard BinaryFormatter serialization.

Why it matters: It turned a tedious task (opening external files) into a streamlined "story" where developers can live-edit player arrays, dictionaries, and primitives to test specific game states instantly. The Story of Narrative Persistence The hospital room smelled of antiseptic and wilted flowers

When games like Hollow Knight or Among Us (both made in Unity) save progress, they aren't just saving coordinates; they are saving a narrative state.

The System: Developers often use tools like the Save Manager by Carter Games to handle this.

The Narrative: In RPGs, the "save edit" story involves managing complex branching paths. Tutorials often showcase how to use Ink (a narrative scripting language) alongside Unity to ensure that every player choice is saved and can be modified or checked by the developer to ensure the story stays on track. Creative Editor Hacks Sometimes the "story" is about the editor itself.

Custom Layouts: Some creators share "hacks" for saving and loading custom editor layouts. This allows developers to switch between a "Coding Mode" and a "Level Design Mode" instantly, saving hours of workspace rearranging over a project's lifetime.

Selection History: Tools like the Selection History Tool allow developers to "roll back" their selections in the editor, effectively functioning as a "save/undo" system for the developer's focus. Essential Save-Editing Concepts

If you are looking to build your own save-edit story, these are the common starting points discussed in the community:

PlayerPrefs: The simplest way to save small bits of data like high scores or volume settings.

JSON Encryption: Many modern Unity tutorials focus on saving data in JSON format so it’s readable during development, but then encrypting it for the final release to prevent players from easily editing their own saves.

Risks:

  • Corruption: Incorrect edits can break the save file.
  • Anti-cheat: Games using Unity with Easy Anti-Cheat (EAC) or BattlEye will detect save tampering.
  • Updates: A game patch may change the save format, rendering your edit useless.

Step 3: Analyze the File

Open the save file in Notepad++. Do you see readable words like "health", "gold", or "inventory"? If yes, it’s likely JSON or plaintext. If you see garbled symbols (ÿþÿÿ), it’s binary or encrypted.

Case A: It’s human-readable JSON.
Great. Look for values like "money": 150. Change it to "money": 999999. Save.

Case B: It’s Base64 encoded.
The file might look like eyJwbGF5ZXIiOiJKb2huIiwiaGVh... – copy the text, go to CyberChef or base64decode.org, decode it, edit the resulting JSON or XML, then re-encode and save.

Case C: It’s binary.
Open in HxD. Search for hexadecimal representations of your in-game values.

  • For example, if you have 100 gold (hex 64), search for 64 00 (if 2-byte integer) or 64 00 00 00 (if 4-byte int). Change to FF FF 00 00 (65535 gold). This requires understanding of endianness and data types.

Case D: It’s encrypted (e.g., XOR, AES).
This is advanced. You may need to reverse engineer the game’s code using dnSpy or ILSpy on the game’s Assembly-CSharp.dll to find the decryption key. Many indie games use a simple XOR cipher. Once decrypted, the inner data is often JSON or binary.

3. Editing the Data (The "Edit" Part)

To actually "edit" the save, you modify the currentData object in memory, then call Save again. Here is an example script you might attach to a UI form or a Player controller.

using UnityEngine;

public class PlayerEditor : MonoBehaviour
// Example: Call this to update player stats from UI input
public void UpdatePlayerName(string newName)
SaveManager.Instance.currentData.playerName = newName;



public void UpdatePlayerLevel(int newLevel)
SaveManager.Instance.currentData.level = newLevel;
// Example: Call this at the start of the game
void Start()
SaveManager.Instance.LoadData();
    ApplyDataToGame();
// Apply the loaded data to your actual game objects
void ApplyDataToGame()
transform.position = SaveManager.Instance.currentData.position;
    Debug.Log($"Player SaveManager.Instance.currentData.playerName loaded at position transform.position");
// Example: Call this when the game closes or a checkpoint is reached
void OnApplicationQuit()
// Update position before saving
    SaveManager.Instance.currentData.position = transform.position;
    SaveManager.Instance.SaveData();

5. Encrypted Saves

To prevent cheating, many commercial Unity games (e.g., Slay the Spire, Dead Cells) apply encryption (AES, XOR, Base64 + obfuscation) or encode the data in Base64 before saving.

Knowing which method a game uses is step one. You can often determine this by opening a save file in a basic text editor (like Notepad++) and looking for readable text.

2. Hook Into the Game at Runtime

Use BepInEx (a Unity modding framework) or MelonLoader to write a plugin that dumps the save data right after the game decrypts it. This bypasses encryption entirely.

Introduction: What is Unity Save Editing?

Unity has become one of the most popular game engines in the world, powering everything from indie gems like Hollow Knight and Celeste to mobile hits like Genshin Impact and Among Us. With such a vast library of games comes a dedicated community of players who want to tweak, modify, or "hack" their save files. This practice is known as Unity save editing.

Save editing refers to the process of manually modifying a game’s saved data to alter your progress, resources, stats, or unlocks. Unlike using pre-made cheat engines or mod menus, save editing is a forensic, file-based approach. It requires you to locate, decode, modify, and re-encode a game’s persistent data.

This article is a deep dive into Unity save editing. We will cover how Unity saves data, the common file formats you will encounter, the tools you need, a step-by-step tutorial, ethical considerations, and advanced techniques like editing PlayerPrefs, JSON saves, and binary files.

🔧 What Is Unity Save Editing?

Save editing means manually modifying a Unity game’s save files (often JSON, binary, or encrypted) to change game state — health, gold, inventory, unlocked levels, etc.

It’s popular for:

  • Skipping grind in single-player games
  • Testing game balance (for modders/devs)
  • Recovering broken saves
  • Creating "challenge runs" with altered starting gear

3. Memory Editing as a Fallback

If save editing is impossible, use Cheat Engine to scan for values in RAM, modify them, then save the game normally. The new save file will contain the edited values, effectively performing a save edit via memory.