Rooibos Save System

Most Unreal Engine projects eventually reach a point where they need to remember something about the player's journey. The Rooibos Save System approaches that need with a simple rule: any Actor that implements the save interface gets saved. The rest of the plugin is structured through giving that rule enough room to work in small games and large pipelines alike. A showcase video walks through the features, and the developer runs a Discord server for documentation, support, and updates.

Progress That Travels Across Maps

For games with more than 1 Level, the save system has to understand that a player's progress is not tied to a single map. The Rooibos Save System tracks progress across different maps, so a slot saved in 1 Level can load in the next without losing world state. It also includes support for Level Streaming and World Partition, where the game world is broken up into chunks that load and unload as the player moves. In those setups, not every Actor exists at the same time, so the save logic has to account for what is currently in memory. The plugin does that by saving the Actors that implement its interface, rather than requiring a central list of every object in the project.

Loading before BeginPlay is another piece of that puzzle. When a Level starts, the plugin can have the saved data ready before the initial BeginPlay calls go out. That gives Actors access to their restored state at the earliest point in the Level lifecycle, which is often where you need it to avoid 1-frame corrections or reinitialized variables. This becomes especially relevant in streamed worlds, where Actors may be spawned dynamically and need their saved state before gameplay logic starts referencing them.

Any Actor That Implements the Interface

The Actor list is intentionally open-ended. The plugin saves any Actor you wish, including:

• GameMode
• PlayerController
• Pawns
• GameInstance
• Level Blueprint

That covers the Actors that hold most of a game's runtime state. The GameMode knows the rules of the current match, the PlayerController holds input and camera state, Pawns carry movement and health, and the GameInstance exists across Level loads. Level Blueprints get included too, which is a common place for Level-specific variables that are easy to forget when you only save player data.

Because the system is proven in existing projects, the interface-based approach has already been used beyond that handful of categories. Custom gameplay Actors can implement the interface and appear in a save without the framework needing to know about them ahead of time. This keeps the save pipeline open for things like AI directors, spawn managers, or any other Actor that lives outside the default Level setup.

Minimal Setup, with Room for an Existing Pipeline

The plugin is designed to be an out-of-the-box time saver for new projects, but it does not force a single way of working. The setup is minimal, and the customizability stretches in several directions. You can use the default SaveGame class or supply your own, which matters when a project already has a save format or a save manager in place. The Application Programming Interface (API) is accessible from C++ and Blueprints, so programmers and designers can interact with the same system without duplicating logic.

Save and load operations happen asynchronously, so the game does not stall while data is written to disk or pulled back. Callbacks are included for User Interface (UI), which lets a loading screen or save menu react when an operation completes. Those callbacks also make it possible to show save indicators or error messages without polling the state manually. The plugin also has an option for automatically saving and loading when exiting or entering PIE (Play In Editor). That is a practical Editor shortcut: instead of manually starting from a cleared state every time you run the Level, you can pick up where the last play session left off.

The flexibility extends to the broader pipeline. Teams that already have a save pipeline can slot the plugin in as the low-level save/load handler while keeping their own SaveGame class. Teams that are starting fresh can use the default path and add their own rules later without reworking the core.

Versioning, Thumbnails, and Detailed Logs

A save file needs to survive updates to the game itself. The Rooibos Save System stores metadata alongside saves, and it includes versioning so a save from an older build can be recognized when the game has been updated. Thumbnails are supported as well, which is useful for load screens that show a picture of the slot. Combined, these features turn a save file into something players can identify at a glance while the plugin still handles the internal differences between versions.

For debugging, the plugin provides detailed logging. When a save or load does not behave as expected, the logs can show which Actors were processed and what data was written. That kind of visibility makes it easier to track down issues inside the save pipeline. The developer also offers support through the Discord server, so there is a place to ask questions while integrating the system. The showcase video serves as a visual overview of the feature set, which helps when you want to see how everything fits together before opening the Editor.

The Practical Fit of the Rooibos Save System

The Rooibos Save System earns its place in 2 kinds of projects: the new project that wants save/load working quickly without building a framework from scratch, and the established project that needs to fold saving into an existing pipeline. The minimal setup covers the 1st case. The option to use your own SaveGame class, the C++ and Blueprint access, and the asynchronous callbacks cover the 2nd.

Projects structured through Level Streaming or World Partition are the most natural audience, because those architecture points are explicitly part of the feature set. The same holds for projects where progress spans multiple maps. Any Actor that implements the save interface gets saved, so the plugin is more than a data serializer; it is a way to keep the whole Level's state consistent across load and save cycles. Loading before BeginPlay, versioning, and detailed logging round out a package that is both approachable for solo developers and deep enough for a larger team.

If you are working on an Unreal Engine project that needs to remember where the player was, what the world looked like, and which Actors were alive, the Rooibos Save System gives you a framework that is both quick to start with and flexible enough to grow into. The plugin's focus on the actor-level save interface means you spend less time wiring up a save manager and more time designing the game around the moments that should persist.

Related Resources Worth Checking

• Easy Multi Save
• Rooibos Outlines
• Chunk Downloader Nodes
• Auto Settings
• SHADERSOURCE - Landscape Material Tool