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.
Unity Save Edit refers to techniques and tools for modifying, inspecting, and managing saved game data produced by Unity-based projects. It covers common save formats, safe editing practices, debugging tips, and workflows for both developers and power users who want to repair, migrate, or tweak save files without breaking game state or triggering anti-tamper systems.
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.
Hook A polished, user-friendly Unity Save Editor that lets players and developers explore, visualize, and safely modify game save data in real time — without breaking immersion or corrupting progress.
Concept Overview SaveScape is a cross-platform editor built for Unity games that standardizes diverse save formats into a live, human-readable workspace. It connects to running builds or standalone save files, parses common Unity serialization formats (PlayerPrefs, BinaryFormatter, ScriptableObject-based saves, JSON, YAML, ProtoBuf, Addressables-backed serialized blobs), and presents data as an editable, versioned scene of player state, inventory, world flags, and timed events.
Key user stories
Core Features
Developer Integration
Monetization & Distribution
UX examples (short)
Security & Ethics
Takeaway SaveScape turns opaque Unity save formats into a safe, powerful toolkit for players, modders, QA, and developers — speeding debugging, enabling creative experimentation, and reducing support friction while protecting game integrity.
Understanding Unity Save Editing: A Guide for Players and Developers
Whether you're a player looking to skip a grind or a developer debugging a complex progression system, unity save edit techniques are essential knowledge. In Unity-based games, "save editing" refers to the process of locating, reading, and modifying the persistent data files that the game writes to your storage. Where Are Unity Save Files Located?
Before you can edit a save, you must find it. Unity developers typically use a standard path called Application.persistentDataPath. The actual location on your drive depends on your operating system:
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 Common Save Formats and How to Edit Them
The ease of editing a Unity save file depends entirely on the serialization method chosen by the developer. 1. JSON and XML (Human-Readable)
Most modern Unity games use JSON (JavaScript Object Notation) or XML because they are easy for developers to implement using tools like JsonUtility.
How to Edit: These are plain text files. You can open them with any standard text editor like Notepad++ or VS Code.
What to Look For: Look for clear keys like "player_gold": 100 or "current_level": 5 and change the numerical values. 2. PlayerPrefs (Registry/Plist) unity save edit
Unity's built-in PlayerPrefs system is often used for simple settings like volume or high scores.
Windows: These are stored in the Windows Registry under HKEY_CURRENT_USER\Software\[CompanyName]\[ProductName]. You can edit them using regedit.
macOS: These are stored in .plist files, which can be edited with Xcode or specialized plist editors.
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
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.
Technical Overview: Unity Save Systems and Editor Modification
The concept of "Unity Save Edit" encompasses two primary technical domains: the architecture of in-game save systems and the manipulation of editor-side data
. This paper explores the mechanisms for persisting state in Unity and the methodologies for modifying that data during and after development. 1. Core Persistence Mechanisms
Unity provides several native approaches for saving data, each suited for different levels of complexity. PlayerPrefs
: The simplest method, storing basic data types (integers, floats, strings) in the system registry or a preferences file. It is best suited for non-sensitive data like volume settings or screen resolution. JSON Serialization
: A common practice involves converting C# data objects into JSON format using Unity’s JsonUtility
. This allows developers to save complex data structures to a local text file. Binary Formatting : For more secure or large-scale data, developers use BinaryFormatter or newer alternatives like the Platform Toolkit
, which uses a commit mechanism to ensure data integrity through snapshots. 2. Editor-Side Save and Edit Functions
Managing changes within the Unity Editor is a separate workflow from in-game data persistence. Manual Saving
: Users must explicitly save scenes (Ctrl+S) to commit changes to the project files. Saving a scene also triggers a project-wide save. Prefab Editing : Changes made in Prefab Editing Mode can be set to
, ensuring that updates to asset templates are committed immediately. Play Mode Persistence
: By default, Unity discards changes made to the scene while in "Play Mode." However, specific packages like Cinemachine
offer "Save During Play" features to retain camera adjustments made during runtime. 3. Post-Build Modification (Save Editing)
Once a game is compiled and distributed, "save editing" refers to the manipulation of save files by users. File De-serialization To effectively edit or build a "save edit"
: If a game uses JSON or XML, users can often edit save files with a standard text editor. If the game uses binary encryption, third-party hex editors or community-made "save editors" are required. Decompilation Limitations
: It is important to note that the Unity Editor cannot be used to decompile or edit a finished, built game file. Editing a built game typically requires memory manipulation tools (like Cheat Engine) or specialized modding frameworks. 4. Best Practices for Developers
To build a robust save system that is easy to manage (and edit) during development, developers should: Use a Data Model
: Separate game data from the logic scripts to make serialization straightforward. Implement Versioning
: Include a version number in save files to prevent crashes when the game's data structure changes during updates. Encrypted vs. Human-Readable
: Decide early if save files should be accessible to players (JSON) for easy modding or protected (Binary/Encrypted) for competitive integrity.
To help you with your Unity project, I've organized content for three main "save/edit" scenarios: Saving game data (player progress), Editing saves (for testing), and Saving editor changes (Play Mode persistence). 1. Building a Custom Save System
If you are developing a game and need a system to save player progress, follow this standard pattern using Unity's JsonUtility.
Step 1: Define Your DataCreate a plain C# class marked [System.Serializable].
[System.Serializable] public class PlayerData public int level; public float health; public float[] position; // Vector3 isn't directly serializable Use code with caution. Copied to clipboard
Step 2: Save to DiskUse Application.persistentDataPath to ensure your files work on all platforms.
string json = JsonUtility.ToJson(data); File.WriteAllText(Application.persistentDataPath + "/save.json", json); Use code with caution. Copied to clipboard Step 3: Load the Data
string path = Application.persistentDataPath + "/save.json"; if (File.Exists(path)) string json = File.ReadAllText(path); PlayerData data = JsonUtility.FromJson Use code with caution. Copied to clipboard 2. Tools for Editing Save Files
If you need to quickly modify save files for testing or "cheating" during development:
In-Editor Editors: You can build a custom editor window using UI Toolkit to view and modify save data directly within Unity.
Third-Party Assets: Tools like Easy Save are popular for handling complex data (like dictionaries or nested objects) without manual coding.
Manual JSON Edits: If your save is in JSON format, you can find the file at C:\Users\ on Windows and edit it with any text editor. 3. "Saving" Play Mode Changes
Unity famously discards most changes made to the Hierarchy while in Play Mode. Here is how to keep them:
Component Copy/Paste: Right-click a component in Play Mode → Copy Component. Exit Play Mode → Right-click the same component → Paste Component Values.
Transform Specifics: Use the specific "Copy Position" or "Copy Rotation" options if you only need spatial adjustments.
Prefab Creation: Drag a modified GameObject from the Hierarchy into your Project window during Play Mode to create a new Prefab that includes all your live changes. Comparison of Storage Methods
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.
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.
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. Overview Unity Save Edit refers to techniques and
"schemaVersion": 3, "player": "id": "player-001", "name": "Ava", "level": 12, "position": "x": 34.5, "y": 2.0, "z": -10.0 , "inventory": [ "itemId": "potion_small", "qty": 5 , "itemId": "sword_iron", "durability": 82 ], "checksum": "ab12cd34..."
| Game | Save Method | Edit Difficulty | Notes |
|------|-------------|----------------|-------|
| Among Us | Binary (PlayerPrefs on PC) | Easy | Unlock hats, pets via registry edits. |
| RimWorld | XML (.rws) | Very Easy | Fully human-readable. Edits are trivial. |
| Subnautica | JSON (.json) | Easy | Edit resources, coordinates, blueprints. |
| Hollow Knight | Binary + Checksum | Hard | Community editor required. |
| Outer Wilds | Binary (.sav) + Unknown encoding | Medium | Can be edited with hex editor and known offsets. |
| Genshin Impact | Server-side + encrypted local cache | Impossible (legit) | Do not attempt; you will be banned. |