API Reference

public static async Task SaveAsync(string slot, CancellationToken ct = default)

await SaveManager.SaveAsync("slot1");
 
// With cancellation
var cts = new CancellationTokenSource();
await SaveManager.SaveAsync("slot1", cts.Token);

public static void SaveSync(string slot)

void OnApplicationQuit()
{
    SaveManager.SaveSync("autosave");
}

public static async Task<bool> LoadAsync(string slot, CancellationToken ct = default)

bool success = await SaveManager.LoadAsync("slot1");
if (success)
{
    Debug.Log("Game loaded");
}
else
{
    Debug.Log("No save file found");
}

public static bool HasSlot(string slot)

if (SaveManager.HasSlot("slot1"))
{
    await SaveManager.LoadAsync("slot1");
}
else
{
    StartNewGame();
}

public static void DeleteSlot(string slot)

SaveManager.DeleteSlot("slot1");

public static string GetSlotPath(string slot)

string path = SaveManager.GetSlotPath("slot1");
Debug.Log($"Save file: {path}");
// Output: "C:/Users/Name/AppData/LocalLow/Company/Game/slot1.tsf"

public static SaveMetadata? PeekMeta(string slot)

SaveMetadata? meta = SaveManager.PeekMeta("slot1");
if (meta.HasValue)
{
    Debug.Log($"Version: {meta.Value.version}");
    Debug.Log($"Timestamp: {meta.Value.timestamp}");
    Debug.Log($"Scenes: {string.Join(", ", meta.Value.scenes)}");
}

public static void Configure(SaveManagerConfig config)

var config = SaveManagerConfig.CreateDefault();
config.EncryptionEnabled = true;
config.EncryptionKey = "my-secure-key";
SaveManager.Configure(config);

public static PerfCounters LastPerfCounters { get; }

await SaveManager.SaveAsync("slot1");
Debug.Log(SaveManager.LastPerfCounters.ToString());
// "Capture=5ms, Serialize=12ms, IO=8ms, Total=25ms, Bytes=52481"

public static SaveManagerConfig Config { get; }

SaveManagerConfig config = SaveManager.Config;
Debug.Log($"Encryption: {config.EncryptionEnabled}");
Debug.Log($"Extension: {config.FileExtension}");

public static event Action BeforeSave;

void OnEnable()
{
    SaveManager.BeforeSave += OnBeforeSave;
}
 
void OnDisable()
{
    SaveManager.BeforeSave -= OnBeforeSave;
}
 
void OnBeforeSave()
{
    Debug.Log("Game is saving...");
}

public static event Action AfterLoad;

void OnEnable()
{
    SaveManager.AfterLoad += OnAfterLoad;
}
 
void OnDisable()
{
    SaveManager.AfterLoad -= OnAfterLoad;
}
 
void OnAfterLoad()
{
    Debug.Log("Game loaded!");
    RefreshUI();
}

public bool EncryptionEnabled { get; set; }

public string EncryptionKey { get; set; }

public string StorageBasePath { get; set; }

public string FileExtension { get; set; }

public static SaveManagerConfig CreateDefault()

var config = SaveManagerConfig.CreateDefault();
config.EncryptionEnabled = true;
config.EncryptionKey = "my-key";
SaveManager.Configure(config);

public IStorage CreateStorage()

public static TinySaveSettings defaultSettings { get; }

TinySaveSettings.defaultSettings.encryptionEnabled = true;
TinySaveSettings.defaultSettings.encryptionKey = "my-key";

public bool encryptionEnabled { get; set; }

public string encryptionKey { get; set; }

public string storageBasePath { get; set; }

public SaveManagerConfig ToConfig()

var settings = TinySaveSettings.defaultSettings;
settings.encryptionEnabled = true;
settings.encryptionKey = "my-key";
 
var config = settings.ToConfig();
SaveManager.Configure(config);

public static void ReloadFromPrefs()

public string ID { get; set; }

SaveID saveId = GetComponent<SaveID>();
Debug.Log($"This object's ID: {saveId.ID}");

public bool AutoSaveEnabled { get; set; }

public bool saveActive { get; set; }

public bool saveDestroyed { get; set; }

public bool saveHideFlags { get; set; }

public bool saveName { get; set; }

public bool saveTag { get; set; }

public bool saveLayer { get; set; }

public List<Component> componentsToSave { get; set; }

public void AddComponentToSave(Component component)

var autoSave = GetComponent<TinySaveAutoSave>();
autoSave.AddComponentToSave(GetComponent<Rigidbody>());

public void RemoveComponentToSave(Component component)

public bool IsComponentSelected(Component component)

public ReadOnlyCollection<Component> GetSelectedComponents()

public void ClearSelectedComponents()

public enum SaveTiming
{
    None,               // Manual save only
    OnApplicationQuit,  // Save when quitting
    OnApplicationPause  // Save when pausing (mobile)
}

public enum LoadTiming
{
    None,  // Manual load only
    Awake, // Load in Awake()
    Start  // Load in Start()
}

public SaveTiming whenToSave { get; set; }

public LoadTiming whenToLoad { get; set; }

public string saveSlot { get; set; }

public static TinySaveManager Instance { get; }

public async Task PerformSaveAsync()

await TinySaveManager.Instance.PerformSaveAsync();

public async Task PerformLoadAsync()

public long GetId(UnityEngine.Object obj)

public UnityEngine.Object GetObject(long id)

public bool HasReference(UnityEngine.Object obj)

public long Add(UnityEngine.Object obj)

var refManager = FindFirstObjectByType<TinySaveReferenceManager>();
Light light = FindFirstObjectByType<Light>();
long lightId = refManager.Add(light);

public void ClearReferences()

public int GetReferenceCount()

[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
public class SaveFieldAttribute : Attribute
{
    public string KeyOverride { get; }
 
    public SaveFieldAttribute(string keyOverride = null)
}

[SaveField]
public int health;
 
[SaveField("oldPlayerName")] // Support renamed fields
public string playerName;

public interface ISaveCallbacks
{
    void OnBeforeSave();
    void OnAfterLoad();
}

public class Player : MonoBehaviour, ISaveCallbacks
{
    [SaveField] private Vector3 savedPosition;
 
    public void OnBeforeSave()
    {
        savedPosition = transform.position;
    }
 
    public void OnAfterLoad()
    {
        transform.position = savedPosition;
    }
}

public interface ISaveCustom
{
    object CaptureState();
    void RestoreState(object state);
}

public class CustomData : MonoBehaviour, ISaveCustom
{
    public object CaptureState()
    {
        return new Dictionary<string, object>
        {
            { "key", "value" }
        };
    }
 
    public void RestoreState(object state)
    {
        var dict = state as Dictionary<string, object>;
        // Restore data
    }
}

public interface ISaveMigration
{
    int FromVersion { get; }
    int ToVersion { get; }
    bool TryMigrate(ref SaveFile file);
}

public class Migration_1_to_2 : ISaveMigration
{
    public int FromVersion => 1;
    public int ToVersion => 2;
 
    public bool TryMigrate(ref SaveFile file)
    {
        // Transform old data to new format
        return true;
    }
}

public struct SaveFile
{
    public SaveMetadata meta;
    public List<EntityRecord> entities;
    public List<AssetRecord> assets;
}

public struct SaveMetadata
{
    public string version;      // Game version
    public long timestamp;      // Unix timestamp
    public string build;        // Build identifier
    public List<string> scenes; // Scene names
    public bool compressed;     // Is compressed
    public int formatVersion;   // Save format version
}

public struct EntityRecord
{
    public string id;              // SaveID
    public string scene;           // Scene name
    public string prefab;          // Prefab path
    public bool active;            // GameObject.activeSelf
    public string name;            // GameObject.name
    public string tag;             // GameObject.tag
    public int layer;              // GameObject.layer
    public HideFlags hideFlags;    // GameObject.hideFlags
    public List<ComponentRecord> components;
}

public struct ComponentRecord
{
    public string type;                       // Component type name
    public Dictionary<string, object> fields; // Field data
}

public struct AssetRecord
{
    public string guid;                       // Asset GUID
    public string type;                       // Asset type name
    public Dictionary<string, object> fields; // Field data
}

public class PerfCounters
{
    public long CaptureMs { get; }
    public long SerializeMs { get; }
    public long IoMs { get; }
    public long ResolveMs { get; }
    public long TotalMs { get; }
    public long BytesWritten { get; }
}

await SaveManager.SaveAsync("slot1");
PerfCounters perf = SaveManager.LastPerfCounters;
 
Debug.Log($"Capture: {perf.CaptureMs}ms");
Debug.Log($"Serialize: {perf.SerializeMs}ms");
Debug.Log($"IO: {perf.IoMs}ms");
Debug.Log($"Total: {perf.TotalMs}ms");
Debug.Log($"Size: {perf.BytesWritten} bytes");

public interface IStorage
{
    Task WriteTextAtomicAsync(string path, string content, CancellationToken ct = default);
    void WriteTextAtomic(string path, string content);
    Task<string> ReadTextAsync(string path, CancellationToken ct = default);
    string ReadText(string path);
    bool Exists(string path);
    void Delete(string path);
    string GetFullPath(string relativePath);
}

public interface IEncryption
{
    string Encrypt(string plaintext);
    string Decrypt(string ciphertext);
}

public const int CurrentFormatVersion = 1;

public static SaveFile Migrate(SaveFile file)