SaveVault Core — Documentation

Plugin available on Fab as free Asset:SaveVault Core Plugin demo :Demo

Introduction

SaveVault Core is a free, open-source Unreal Engine plugin (UE 4.26–5.7) that replaces the engine's built-in save system with a more robust foundation. It provides typed save game objects, binary file headers with integrity checking, multi-slot profile management, and a clean Blueprint API — all with zero configuration required to get started.

It is MIT licensed and distributed on GitHub and the Fab marketplace at no cost.

---

Functionality Overview

What SaveVault Core Does

• Multi-profile save management — create and manage any number of independent save slots with arbitrary names. Player profiles, named slots, numbered slots, and auto-save slots coexist without any special configuration.
• Typed serialization — save data is defined by subclassing USVSaveGame and adding UPROPERTY(SaveGame) fields. The plugin serializes the full UObject polymorphically, preserving the exact subclass type across save/load cycles.
• Binary save files with integrity checking — every save file begins with a 32-byte header containing a magic number (SVLT), save version, UTC timestamp, payload size, and a CRC32 checksum. Corrupt or truncated files are detected and rejected before deserialization begins.
• Header-only metadata reads — GetSlotInfo and ListAllSlots read only the 32-byte header without loading the full UObject, making slot enumeration fast regardless of payload size.
• Version tracking — a SaveVersion field is stamped on every write using the value configured in Project Settings. This gives you the foundation to detect stale saves and handle schema changes at load time (automatic migration is a SaveVault Pro feature).
• Blueprint-first API — all operations are exposed as BlueprintCallable nodes. A companion USVBlueprintLibrary provides compact one-node access to the subsystem and UI-ready formatting helpers.

What SaveVault Core Does Not Do

The following capabilities are part of SaveVault Pro (paid tier) and are not included in the free version:

• Encryption (XOR and AES-128)
• Automatic version migration chains
• Asynchronous save/load operations (async IO with thread-pool workers)
• Auto-save subsystem (interval + level-transition triggers)
• Cloud save backend interface (Steam, EOS)
• Multiplayer save coordination (server-authoritative RPCs)
• Save diff editor tool

---

Architecture and Implementation

Module Structure

SaveVault Core consists of two modules:

Module	Type	Purpose
SaveVault	Runtime	Core save system — always loaded
SaveVaultTests	Developer	Automation tests — excluded from Shipping builds

Key Classes

USVSaveGame — The base save data class. Projects subclass this and add their own UPROPERTY(SaveGame) fields. The subsystem uses FObjectAndNameAsStringProxyArchive to serialize the full subclass polymorphically, preserving the UClass identity so the correct type is reconstructed on load.

USVSaveGameSubsystem — A UGameInstanceSubsystem that owns all save/load/delete/list operations. It has no external dependencies: no encryption, no migration chain, no cloud backend. A TMap<FString, FSVSlotInfo> slot cache is maintained and updated by every operation, so repeated GetSlotInfo calls avoid redundant disk reads.

FSVSaveHeader — A 32-byte binary header prepended to every save file. Serialized via a custom FArchive operator<< that writes fields in a documented byte order (see section 4.6 of plan.md). The CRC32 of the payload is stored here and verified on every load before deserialization begins.

SVSerializationUtil (internal) — A private namespace with SerializeObjectToBytes and DeserializeObjectFromBytes. These wrap FMemoryWriter/FMemoryReader with FObjectAndNameAsStringProxyArchive and set ArIsSaveGame = true so only UPROPERTY(SaveGame) fields are included.

USVSettings — A UDeveloperSettings subclass that appears under Project Settings → Plugins → Save Vault. Holds SlotPrefix, DefaultUserIndex, and CurrentSaveVersion. Accessed via USVSettings::Get() (a thin wrapper over GetDefault<USVSettings>()).

USVBlueprintLibrary — Static Blueprint helpers: GetSaveVaultSubsystem (world-context shortcut), MakeSaveVersionString (formats FSVSlotInfo into a UI label), and IsSaveFileEncrypted (reads header EncryptMode — always false in Core, but correctly reads Pro-written files for interoperability).

Save File Format

[Offset]  [Size]  [Field]
0         4       Magic: 0x53564C54 ('SVLT')
4         4       HeaderVersion: 1
8         4       SaveVersion (from USVSettings::CurrentSaveVersion at write time)
12        8       Timestamp: UTC Unix int64
20        4       PayloadSize: byte count of serialized UObject
24        4       PayloadCRC: CRC32 of payload bytes
28        1       EncryptMode: 0 = None (always 0 in Core)
29        3       Padding (zeroes)
32+       N       Serialized UObject payload (FObjectAndNameAsStringProxyArchive)

Files are written to {ProjectDir}/Saved/SaveGames/{SlotPrefix}{SlotName}.sav.

UE Version Compatibility

SVVersionMacros.h defines SV_ENGINE_VERSION as ENGINE_MAJOR_VERSION * 100 + ENGINE_MINOR_VERSION (e.g. UE 5.3 → 503). This integer is used for #if guards around APIs that differ between UE4 and UE5. The Core plugin avoids such guards wherever possible; they become relevant primarily in Pro's async and migration code.

---

How to Use

See usagefree.md for the complete usage guide with code examples. The short version:

1. Subclass USVSaveGame and add your data fields tagged UPROPERTY(SaveGame).
2. Call SaveToSlotSync on the USVSaveGameSubsystem with a slot name and your save object.
3. Call LoadFromSlotSync with the slot name and your subclass; cast the result.
4. Use ListAllSlots to build a save-select UI; use DeleteSlot to remove entries.
5. Use MakeSaveVersionString from USVBlueprintLibrary to format metadata for display.

---

Contributing

Contributions are welcome. The plugin is MIT licensed; all changes are accepted under the same license.

How to Contribute

1. Fork the repository on GitHub.
2. Create a branch named for your change (fix/crc-edge-case, feature/slot-tags).
3. Run the automation tests before submitting (Window → Developer Tools → Automation → SaveVault). New functionality should come with a corresponding test in SVSerializationTests.cpp.
4. Open a Pull Request with a description of what changed and why.

Contribution Guidelines

• Keep changes scoped to SaveVault Core functionality (no encryption, async IO, or migration chain — those belong to SaveVault Pro).
• Do not modify the 32-byte binary header format without a corresponding HeaderVersion increment and a documented migration path — existing save files must remain loadable.
• All public API changes must be Blueprint-accessible (UFUNCTION(BlueprintCallable) or BlueprintPure).
• Match the existing code style: no generated comments, no trailing summaries, no over-documentation of obvious behavior.

Reporting Issues

Open an issue on GitHub with:

• Unreal Engine version
• Operating system
• A minimal reproduction (slot name, save class definition, and the exact operation that fails)
• The relevant log output from LogSaveVault

---

SaveVault Pro

SaveVault Core gives you a solid, production-ready foundation. SaveVault Pro extends it with the features that serious games need at scale.

Why Pro Matters

Encryption — Raw save files on disk are readable and editable by players. Without encryption, any determined player can modify their save data to bypass progression gates, unlock items, or corrupt multiplayer-affecting state. SaveVault Pro adds XOR (fast, lightweight) and AES-128 (secure, industry-standard) encryption, configurable per project from Project Settings. The CRC check already in Core catches accidental corruption; encryption prevents deliberate tampering.

Async IO — SaveToSlotSync and LoadFromSlotSync block the game thread while writing or reading. For small saves this is imperceptible, but as save data grows (inventory systems, world state, thousands of UObject properties), sync IO causes frame hitches. SaveVault Pro moves file IO to a thread pool worker: serialization stays on the game thread (required for UObject access), the write is dispatched to a worker, and the OnSaveComplete delegate fires back on the game thread when done. Your game never stalls.

Version Migration — When your save data schema changes between releases, players' existing saves become incompatible. SaveVault Pro's FSVMigrationChain lets you register step functions that transform old save objects to the current schema automatically on load. Each step targets a specific FromVersion and is executed in order. Players keep their progress across updates.

Auto-Save — SaveVault Pro includes USVAutoSaveSubsystem, a separate game instance subsystem that handles interval-based saves (every N seconds) and level-transition saves automatically. No game code changes required — just configure the slot name and target save object.

Cloud Save — The ISVCloudBackend interface lets you plug in any cloud storage provider (Steam Cloud, EOS, custom backend). SaveVault Pro ships with Steam and EOS reference implementations. The strategy is cloud-first on load with local fallback, and write-both on save.

Multiplayer — USVNetworkSaveComponent provides server-authoritative save coordination via reliable RPCs. Clients request saves; the server validates and performs the operation; results are broadcast back. Save data never travels over the network — only slot names and result codes do.

SaveVault Pro is available as a paid listing on Fab. Purchasing Pro funds continued development of both tiers.