Super Simple Save System - The Ultimate Save Game Tool For Unity.

🚀 Powerful, Simple, and Built for Unity

Super Simple Save System is a robust yet approachable save and load framework for Unity, designed to eliminate the complexity and boilerplate traditionally involved in game persistence.

At its core, the system uses a clean interface-based architecture, allowing any component to explicitly define what data it wants to save and restore. This results in a solution that is highly modular, easy to reason about, and safe to use, whether you’re working solo or in a team.

💾 Flexible Data Support & Clean Serialization

The system supports saving and loading a wide range of data types, including Unity primitives, built-in structs, custom [Serializable] classes, ScriptableObjects, and scene-related data.

All data is serialized using JSON, making save files:

• Human-readable
• Easy to debug
• Version-control friendly

This approach ensures transparency and flexibility while remaining fast and reliable.

🛠️ Powerful Editor Tools for Fast Iteration

To streamline development and testing, Super Simple Save System includes a suite of editor tools designed to keep you in the flow.

From within the Unity Editor, you can:

• Browse all existing save files
• Preview save-time screenshots
• View timestamps and save metadata
• Load saves across scenes
• Delete saves safely

All of this can be done without entering Play Mode, dramatically improving iteration speed.

⚙️ Optional Quality-of-Life Features

Advanced features can be enabled via a centralized settings asset, requiring no extra setup once configured:

• 🌍 Automatic scene loading
• 📸 Save-time screenshot capture
• 🔐 Optional save file encryption

These features are fully toggleable and designed to integrate seamlessly into your workflow.

📘 Quick Start Included

A dedicated Quick Start guide walks you through installing the asset, creating your first saveable component, and performing a save and load — all in just a few minutes.

This makes the system instantly approachable for beginners, while allowing experienced developers to jump straight into production.

🧠 In-Depth Guides & Real Examples

The documentation is written in a GitBook-style format, covering both basic and advanced workflows with clarity and depth.

It includes:

• Step-by-step guides
• Annotated code examples
• Real-world usage scenarios

Covered topics include:

• Initial setup and configuration
• Creating saveable components
• Runtime saving and loading
• Scene-aware saves and editor-time loading
• Using the Save File Inspector and Settings Window
• Working with screenshots and encryption
• Editor workflows, testing, and iteration
• Common patterns and best practices

❓ Frequently Asked Questions

The documentation proactively addresses common questions and edge cases, such as:

• Loading saves across scenes
• Editor vs runtime behavior
• Custom save locations
• Encrypted saves and screenshot handling
• Extending or customizing the system

🎯 Designed for Real Projects

Whether you’re building a small prototype, a game jam entry, or a full commercial title, Super Simple Save System is built to scale with your project.

The documentation and architecture are designed to remain useful throughout development, helping you spend less time troubleshooting and more time building your game with confidence.

🆘 Support

Feel free to reach out to me on my email address (watermillhelp@gmail.com) or browse through the in-depth documentation. Any emails I receive I will reply to in a few hours. Happy programming! 😊

Features:

Core Save System

• Interface-based design using a simple ISaveable pattern
• Fine-grained control over what data is saved and restored
• JSON-based serialization using Unity’s built-in JsonUtility
• Save files are readable, debuggable, and version-control friendly

Supported Data

• Primitive types (bool, int, float, string, etc.)
• Unity structs (Vector2, Vector3, Quaternion, Color, etc.)
• Arrays and Lists
• Enums
• Dictionaries
• Custom [Serializable] classes
• ScriptableObjects
• Scene-related data (scene-aware saves)

Scene-Aware Saving

• Automatically stores the active scene in the save file
• Loading a save switches to the correct scene when needed
• Works both at runtime and in the Unity Editor

Editor Tooling

• Custom Save File Inspector window
• View all saves in the configured save directory
• Display save timestamps (last modified time)
• Preview screenshots taken at save time
• Load or delete saves directly from the editor
• Supports editor-time scene switching and restoration

Customization & Settings

• Centralized Save System Settings ScriptableObject
• Customizable save folder location
• Toggleable screenshot capture
• Toggleable encryption
• Ability to swap settings assets for different profiles

Optional Features

• Save-time screenshot capture
• Automatic screenshot preview in editor
• Save file encryption
• Runtime and editor-safe loading

Compatibility

• Works with Built-in Render Pipeline, URP, and HDRP
• No third-party dependencies
• Demo scene included (uses TextMeshPro)

Supported Platforms:

• Windows, macOS, Android.

Rendering Pipelines:

• Built-in RP, URP, HDRP

Editor Integration:

• Custom editor windows and menus

Documentation:

• (https://noah-taylor.gitbook.io/super-simple-save-system/) Full GitBook-style documentation included

AI Disclosure:

AI tools were used during development to assist with documentation writing, editor UI copy, and general workflow planning. All code architecture, implementation, testing, integration, and final decisions were designed, reviewed, and implemented manually by myself. No AI-generated code is included without verification or modification.