JesusSaves
Save Game Persistence Framework
"There is no other name under heaven given to mankind
by which we must be saved."
A Persistence Framework That Just Works
JesusSaves is a Save Game and Persistence Framework plugin for Unreal Engine 5.7+, built with rapid prototyping in mind. Whether you're making a simple single-player game or an ambitious open-world multiplayer experience, this plugin gives you a solid persistence foundation from day one.
Rapid Prototyping
Start building persistent games quickly, regardless of experience level with Unreal Engine. No complex setup. The plugin is designed to just work out of the box.
In-Memory Architecture
The SaveGame Object persists in memory at all times. Actors stream in and out, loading their data at any point. Level transitions preserve data unless explicitly removed.
Multiplayer Ready
Authority-centric design for most multiplayer and single-player scenarios. Server-side saving with client notification replication — built to scale to ambitious open-world games.
Blueprint & C++ Friendly
Most plugin functionality can be extended and customized in C++ or Blueprint without touching plugin source. Written in C++ with extensive Blueprint exposure.
Serialization API
Serialization functions exposed to Blueprint for direct serialization of any Blueprint or C++ struct to an array of bytes — enabling custom persistence workflows.
Unlimited Profiles & Slots
Flexible profile and save slot system — from single-playthrough games to unlimited profiles with full save history. Constrained only by a 32-bit integer and drive space.
Persistence at the Forefront
Not an Afterthought
Persistence should not be something you incorporate into a nearly-finished game at the end of development. The JesusSaves framework was created with the belief that persistence belongs at the forefront of every gameplay feature — designed in from the start, not bolted on at the end.
In-Memory Game Object
The SaveGame Object persists in memory throughout gameplay. Actors stream in or out, saving and loading their data at any time from that in-memory object. Players can transition to other levels and the data for previous levels remains — unless you explicitly remove it.
Extensible by Design
Advanced users can extend the UJSSaveGame object to store additional data like arrays and maps of structures. The design makes it simple for those who want simplicity, while making it extensible and reusable for those who need more control.
Key Terminology
- Slot / Save Game Slot
- A single save file associated with one save operation.
- Profile / Profile Key
- A collection of save slots associated with a playthrough.
- Save Game Subsystem
- Game instance subsystem coordinating saving/loading. State:
New,Load, orUninitialized.
Up and Running in Minutes
Purchase on Fab
Purchase the JesusSaves plugin from the Fab marketplace. An Epic Games account is required.
Browse on Fab →Install via Epic Launcher
Use the official guidance from Epic Games to install JesusSaves via the Epic Games Launcher. Most users will already know how to do this — reach out on Discord if you have trouble.
Add a SaveGame Component
Add one of the provided Actor SaveGame Components to any actor you want to persist. Mark the properties you want saved:
UPROPERTY(SaveGame, EditAnywhere)
int32 PlayerScore;
UPROPERTY(SaveGame, BlueprintReadWrite)
FString PlayerName;Implement Notifications (Optional)
Implement the IJSSaveGameNotification interface on your actor to receive events for saving and loading. Useful for validating data or triggering actions on load.
Plugin Architecture
Understanding the plugin's main classes, their relationships, and roles will help you get the most out of JesusSaves and design your save system effectively.
Designing Your Save System
JesusSaves accommodates many different save-game designs. Single playthrough with no file management? No problem. Multiple profiles where users choose one for a new game or load? No problem. Unlimited profiles with complete save history? That's possible too — limited only by a 32-bit integer and available drive space.
User Interface
The plugin provides the classes and methods needed to implement your own Save Game user interface. A canonical UI is not part of JesusSaves — video tutorials and sample projects demonstrate how you might build your own interfaces.
Save Game Components
To make any actor persistent — whether APlayerState, AGameMode, APawn, or any Actor-derived class — add one of the provided components and mark the properties you want saved.
Add a Save Game Component to your Actor
Mark UPROPERTY flags with SaveGame
Optionally implement IJSSaveGameNotification
| Component Class | Behavior |
|---|---|
UJSUniqueIdentifierComponent |
Base component for an actor that has a unique ID. Required foundation for save game persistence. |
UJSSaveGameComponentBase |
Abstract base component for an actor that persists across saves. Does not actually save any properties — subclass for custom behavior. |
UJSSaveGameComponent |
Saves actor properties marked with the SaveGame flag. Can be configured to do the same for other components of the actor. |
UJSLevelActorSaveGameComponent |
Adds an actor's position, controller control rotation, visibility, and collision enabled flags as saved properties. |
UJSPhysicsActorSaveGameComponent |
Adds linear and angular velocity as saved properties. Use alongside level component for full physics state persistence. |
Implement IJSSaveGameNotification on your actor to receive SaveGame and LoadGame events. Useful for validating data prior to save or triggering actions on load (e.g. applying loaded inventory to a UI).
Troubleshooting
If Unreal Engine crashes and you suspect the plugin, retrieve crash logs from:
{YourProject}/Saved/Crashes/{CrashFolderName}/Share these logs on Discord when requesting support.
Cause: BeginPlay can fire before a Pawn is possessed, so the player owner is unknown when BeginPlay occurs.
Resolution: Set the LoadGameDelay property to a small value such as 0.003 (3 milliseconds), so LoadGame fires after the pawn is possessed.