SaveSmart Easy

#AssetStore #unity #unity3d #new #asset #gamedev #indiedev #GameContentShopper

Publisher

WEWE Studio

Please Note

This entry is from Friday February 6, 2026. The price of the asset may have changed since then.
Please visit our homepage for recent offers and sales. Official and private Unity Asset Store™ sales usually last about 14 days.

Overview

SaveSmart Easy is a schema-first save system for Unity.


Define your save data in the editor, generate typed C# accessors, and save game data without string keys, boilerplate, or manual serialization. SaveSmart Easy includes a built-in Save File Editor (Play Mode Supported) that lets you inspect and modify save data directly as raw JSON.


Designed for indie, VR, and mobile games that need a clean, reliable local save solution.


Documentation


🟩 What is SaveSmart Easy?


// Loads from memory

using SaveSmartEasy;

int coins = SaveSmart.SaveData.Coins;

Color themeColor = SaveSmart.SaveData.ThemeColor;

int[] levelScores = SaveSmart.SaveData.LevelScores;

List<int> scoreList = SaveSmart.SaveData.ScoreList;


// Saves to disk immediately

using SaveSmartEasy;

SaveSmart.SaveData.Coins += 100;

SaveSmart.SaveData.ThemeColor = Color.red;

SaveSmart.SaveData.LevelScores = new int[] { 10, 20, 30 };

SaveSmart.SaveData.ScoreList.Add(100);


That’s it. Typed, cached, and automatically stored as JSON.


// Key-based get/set also works

string username = SaveSmart.GetString("Username");


SaveSmart Easy is a lightweight, schema-first save manager for Unity.


Instead of scattering string keys across your codebase, you define your save schema once in an editor tool. SaveSmart Easy then generates typed C# accessors, so you can read and write save data using normal properties with full IntelliSense support.


No manual serialization. No typo-prone keys. No fragile glue code.


🟩 Core Design Philosophy


Schema first, code second

  • Define all save fields in one place.
  • Generate strongly typed accessors automatically.
  • Use simple property assignments to save data.
  • Keep gameplay code clean and safe from string-based errors.

This approach scales better than PlayerPrefs and stays far simpler than full custom serialization systems.


🟩 Key Features


🟥 Schema-First Workflow

  • Centralized Definition: Define all save fields in a dedicated editor window to keep your data organized.
  • Robust Editor Tools: The schema editor supports full Undo/Redo, reordering, and field comments for a developer-friendly experience.
  • Automatic Code Generation: Generate typed C# accessors instantly, eliminating boilerplate and manual serialization.

🟥 Type Safety & IntelliSense

  • No More Typos: Replace fragile string keys like PlayerPrefs.SetInt("HihgScore") with strongly-typed properties.
  • Full Autocomplete: Access your data via SaveSmart.SaveData.YourVariableName with full IntelliSense support and compile-time safety.
  • Hybrid API: While property-based access is recommended, traditional key-based APIs (e.g., GetInt, SetString) remain available for dynamic use cases.

🟥 Designed for Performance and Simplicity

  • In-Memory Caching: Save data is loaded once and cached per slot, ensuring subsequent reads are instant and never block your gameplay.
  • Immediate Persistence: Each write updates both the memory cache and the disk automatically, ensuring data safety without requiring manual save calls.
  • Optimized for Indie & VR: Designed specifically to provide a clean, reliable, and lightweight storage solution for mobile and VR platforms.

🟥 Flexible Storage & Security

  • Multiple Save Slots: Easily manage multiple saves (e.g., save1.json, save2.json) with simple APIs to switch or clear slots.
  • Readable JSON: Files are stored as standard JSON under Application.persistentDataPath for easy debugging and inspection.
  • Optional Encryption: Includes built-in AES-based encryption to deter casual save editing and protect player progress. This is intended as basic protection, not security-grade encryption.
  • Cloud Ready: Use built-in APIs to read or write Raw JSON, making it simple to sync local data with backends or cloud providers.

🟩 In-Editor Save File Editor (Play Mode Supported)


This tool works even while the game is running (Play Mode), making it ideal for rapid testing and debugging without restarting the game.

  • Quickly switch between existing save slots (SaveData1.json, SaveData2.json, etc.).Save Slot Selection
  • Re-read the file from disk to reflect changes written by the game at runtime.Reload From Disk
  • JSON is automatically formatted and ordered based on your schema for readability.Direct JSON Editing
    Edit save values directly in a text editor.
  • The running game sees the updated values instantly.Safe Save & Hot Reload
    JSON is validated before saving.
    Changes are written to disk and the in-memory cache is updated immediately.
  • Open the save folder directly in the system file manager for inspection or backup.Reveal in File Explorer

Typical Use Cases

  • Test different save states during gameplay (e.g. set CurrentStage = 5).
  • Debug progression, unlocks, or checkpoints without replaying content.
  • Inspect or repair corrupted or partial save files.
  • Verify cloud sync or encryption behavior by inspecting decrypted JSON.

🟩 Supported Data Types


  • Primitive Types: Int, Long, Float, Double, Bool, String.
  • Unity Types: Vector2, Vector3, Color, Color32, Quaternion, Rect.
  • Standard Types: DateTime.
  • Array Variants: Supports all types above (e.g., IntArray, Vector3Array, Color32Array, etc.).
  • List Variants: Produces List<T> properties for all types above (e.g., IntList, QuaternionList, DateTimeList, etc.).
  • Custom Objects: For complex data structures, use a String field to store JSON strings via JsonUtility or other JSON libraries.

🟩 Typical Use Cases


Well suited for:

  • Game settings
  • Player progress and checkpoints
  • Unlocks and achievements
  • Single-player or local save systems
  • Indie, VR, and mobile games

Not intended for:

  • Massive live-service architectures
  • Per-frame telemetry logging
  • Server-authoritative MMO save pipelines

🟩 Performance Notes


  • Reads are served from memory after the first load.
  • Each write persists immediately to disk.
  • Avoid writing every frame or inside tight loops.

This design favors data safety and simplicity over ultra-high-frequency write scenarios.


🟩 Why Resources?


The schema config asset is saved and loaded from a Resources folder by design, ensuring predictable availability across all platforms.

  • Used only for loading the schema
  • Loaded once and cached
  • No Addressables required
  • No runtime asset modification

The config is a ScriptableObject, stored as a .asset file and persisted with your project.




🟩 Unity Version

  • Unity 2020.3 or later (LTS recommended)

X