Modding guide

How to save your mod's data

11 min readASA DevKit as of November 2026 (UE 5.8.1); ASE where noted

Sooner or later your mod holds data that must outlive a restart: a structure's settings, a counter for the whole server, a player's progress. ARK saves a lot by itself, but none of your own variables until you ask. This page shows what survives on its own, where each kind of data belongs, and what cryopods and transfers do to it. Most of it is one tick box. Testing it properly takes an hour.

  • You'll learn: which data survives a restart, how to save your own, and what cryopods and transfers keep
  • Time: ten minutes per variable; an hour to set up persistence testing
  • Level: intermediate (you've made a structure, buff or singleton)
  • You'll need: a registered mod, and the DevKit started from its .bat file for persistence tests

What survives a restart on its own

The server writes the world into its save file. On restart it rebuilds the saved actors and loads their saved values.

Saved for you:

  • Placed structures, creatures and player characters, with their native saved fields.
  • Inventories, the items in them, and each item's custom item data.
  • Your singleton, because it's a SaveGameActor.
  • Player profiles: level, engrams and persistent buffs.

Not saved:

  • Your Blueprint variables, until you mark them SaveGame.
  • Blueprint variables on items. Modders find SaveGame doesn't keep them.
  • Most buffs, because Prevent Saving is on by default.
  • References to actors and players, timers, and class default object (CDO) edits.
  • Anything that only exists on a client.

A plain Actor child that your mod spawns isn't saved; that's why singletons must be SaveGameActor children. I haven't tested every actor type, so test yours with a restart.

Where each kind of data belongs

Your data Put it here Survives a wipe
Settings or state of one structure or creature SaveGame variables on that actor no
A value for the whole world SaveGame variables on your singleton no
One player's progress a persistent buff with a persistent data object, or the player's custom cloud data no
One item's data custom item data on the item no
Data that must outlive a wipe or be read on another map a SaveGame object saved to a slot yes
A setting the server owner chooses the ini (singleton page) yes

The process

  1. Tick SaveGame on the variable. That's all the world save needs; there's no save node to call.

    Show me how
    • Select the variable → Details → expand Advanced → tick SaveGame.
    • This works on structures, creatures, characters and SaveGameActors. A struct variable saves all its members.
    • Don't also tick Config Variable. One modder found a config variable reset to its default on every restart.
    • Items are different: their Blueprint variables aren't saved. Use custom item data (How to make an item).
    • Once players have saves, treat the variable's name and type as fixed. Unreal saves each value with its name and type and skips any that no longer match, so a renamed variable loads as its default. To change one, add a new variable, copy the old value into it on load, and keep the old one until servers have saved again.
  2. Set it on the server. Only the server's copy is saved. A value a client changes is gone when they log out.

    Show me how
    • A widget or multi-use entry runs on the client. Send the change to the server through something the player owns, then replicate it back (Works in PIE, not on a server).
    • Mark it Replicated or RepNotify too if clients show it. SaveGame and replication are separate tick boxes.
  3. Don't overwrite it on load. Begin Play runs after a restart too. A Set there replaces the value you just loaded.

    Show me how
    • On a singleton or other actor, check Loaded From Save Game (bLoadedFromSaveGame). Only set starting values when it's false.
    • Or give the variable a "never set" default, such as −1, and only fill it when it still holds that.
    • Structures and characters have BPPostLoadedFromSaveGame, which fires after a load. It needs its switch, Use BPPost Loaded From Save Game (bUseBPPostLoadedFromSaveGame), and sits in the class's sparse data, so find it in Class Defaults.
    • Restart what isn't data: timers, effects, binds. Run that setup on load as well as on placement or spawn.
    • Don't re-add what the save already brought back. A saved buff returns by itself; adding it again on load gives two. Check for it first.
  4. Save IDs, not references. A reference to an actor or player is empty after a restart.

    Show me how
    To find again Save this
    A player's account their unique net ID, as text
    A survivor their linked player ID; a new survivor gets a new one
    A structure your own ID, saved on the structure; modders report structure IDs change on restart
    A creature its dino ID
    An actor placed in your map a tag or name you set on it; its path changes if it moves to another map cell

    Then look the actor up again after the restart. For your own ID, a random number saved the first time works.

  5. Save per-player data on the player. A persistent buff keeps its data object in the player's profile, through death and transfers.

    Show me how
    • Make a buff with Is Buff Persistent (bIsBuffPersistent) on and Prevent Saving off.
    • Make a child of PrimalBuffPersistentData, give it your variables, and set it as the buff's Buff Persistent Data Class. Blueprint variables on the buff itself aren't kept (How to make a buff).
    • The player's profile holds these objects. That's why they follow the player and not the world.
    • The other route is the player controller's custom cloud data: SetCustomCloudData, GetCustomCloudData, HasCustomCloudData and RemoveCustomCloudData. It takes the custom item data struct and runs on the server. Modders report it's tied to the player's account and needs a cluster ID set on the server; I haven't tested it.
  6. For data outside the world save, use a SaveGame object. It writes its own file, so it outlives a wipe.

    Show me how
    • Make a Blueprint child of SaveGame and give it variables. A struct is tidy. An object with no variables saves nothing.
    • Save: Create Save Game Object → set its variables → Save Game to Slot with a slot name.
    • Load: Does Save Game Exist → Load Game from Slot → cast to your class.
    • The file lands on the machine that saves it. On a server, that's the server's disk, one per map. On a client, it's that player's PC: fine for UI preferences, not for anything that matters.
    • The file goes in ShooterGame\Saved\SaveGames\, in the DevKit's folder or the server's. A slot name with a path, such as MyMod/Players/<ID>, makes subfolders there (Wildcard Workshop #8, ASE).
    • For per-player files on a server, put the player's unique net ID in the slot name.
    • Wildcard Workshop #8 keys each structure's entry by its structure ID. Modders now report those IDs change on restart, so key it on your own ID instead (step 4's table).
    • Load the slot once, when your singleton starts. Keep the object in a variable, change that object, and save it when something important changes or on a timer. Don't load and save on every change.
    • Add an integer such as DataVersion. Raise it when you change what you save, and upgrade older data when you load it.
    • A SaveGame object can't replicate. Copy its values onto your replicated singleton.
  7. Test a restart in the DevKit. The kit doesn't save its world by default. Turn persistence on first.

    Show me how
    • Add -ForceSave -ForceLoad to the editor line in RunEditorSDK.bat, in the DevKit's root folder. Start the kit from that file from now on, not from the launcher.
    • On your test map, open World Settings and tick Play Persistent Player (bPlayPersistentPlayer).
    • Play, run cheat SaveWorld, stop, and play again.
    • Tribes aren't kept between kit sessions, even with persistence on.
    • If PIE starts crashing on load, the save is corrupt. Delete your map's save in <DevKit>\Projects\ShooterGame\Saved\SavedArks and SavedArksLocal.

Cryopods, uploads and transfers

A cryopod stores a creature inside an item. An upload sends a creature, item or survivor to ARK data for another map. Each one keeps less than a restart does.

  • Cryopod: Your creature class keeps its SaveGame variables. Every buff is dropped, even persistent ones, and the creation time resets.
  • Creature upload: I expect it to behave like a cryopod, but I haven't confirmed your variables survive it.
  • Survivor transfer: Persistent buffs and their data go with the player. Everything kept on the old map stays.
  • Item upload: The item goes. I haven't confirmed its custom item data does.
  • Any of these to a server without your mod: Only vanilla data arrives.

What to do about it:

  • Re-add buffs on release. Default buffs come back when a creature leaves a cryopod. For others, bind the game mode's On Post Un Cryo Dino in your singleton.
  • Keep creature data on your own creature class. You can't add SaveGame variables to vanilla creatures. That's why modders lean on workarounds for vanilla creatures, and why many ask for a per-creature data system.
  • Use real-world time for anything that travels. Network time is the server's own replicated game clock: it keeps counting across restarts on one server, but every server has its own, so it doesn't carry between servers. For a timestamp on a creature, item or survivor that can transfer, store Get Real World Utc Time In Seconds, as a double. Cryopods and mating cooldowns do the same. Network time is still right for timers that should only count while that server runs.
  • Use the hooks. Creatures have BP_OnCryo, BPCanCryo and BPPreServerUploadDino. Buffs have BPPreServerUpload, and items have BPPreventUpload. The last three need their switches turned on: bUseBPCanCryo, bUseBPPreServerUpload and bUseBPPreventUpload. Buff Prevents Cryo on a buff blocks cryopodding.
  • There's no download event for survivors. Modders write a mark into a persistent buff before upload, then check for it when the character spawns.
  • Clusters: world data, singleton values and SaveGame slot files stay on their map. Only player profiles and ARK data move.

Warning

Never let a client decide what gets saved. Check every value the server receives from a widget or command before you store it (lessons §5).

How the pieces connect

This asset Field or call Points at
Your variable SaveGame tick box the world save
Your buff BuffPersistentDataClass your PrimalBuffPersistentData child
Your SaveGame object Save Game to Slot a file on the saving machine
Your test map Play Persistent Player persistence in PIE

The settings that matter

What you're looking for Where
Save a variable Details → Advanced → SaveGame
Know you were loaded Loaded From Save Game; BPPostLoadedFromSaveGame with its switch
Keep a buff Prevent Saving off; Is Buff Persistent; Buff Persistent Data Class
Block cryo or upload bUseBPCanCryo, bPreventUploading, Buff Prevents Cryo

Common mistakes

My variable resets after a restart

Check these in order. SaveGame isn't ticked; a client set it; Begin Play sets it again (step 3); or the actor isn't saved at all. In the DevKit, persistence must be on (step 7).

It saves on a server but not in the DevKit

The kit doesn't save by default. Add the two switches to the .bat and tick Play Persistent Player.

My buff and its data are gone after a restart

Prevent Saving is on by default for buffs. Turn it off, and keep data in a persistent data object (How to make a buff).

My creature lost its buff after a cryopod

Cryopods drop every buff. Re-add it on release, or keep the value in a SaveGame variable on your creature class.

My saved reference is empty after a restart

References don't survive. Save an ID and look the actor up again (step 4).

My SaveGame object saves nothing

It has no variables, or you saved a different object from the one you set. Create, set, then save that same object.

Clients read zeros from my SaveGame object

It only exists where it was saved. Copy its values onto a replicated singleton.

Players lose their progress when they move to another map

The data lived in the world or a server's slot file. Move it to a persistent buff, and make sure the other map runs your mod.

Check it worked

  1. In the DevKit with persistence on: set the value, save, stop, play again. It's back.
  2. On a local dedicated server: the same, with a full restart.
  3. A client sees the loaded value, and a client's change survives because the server made it.
  4. Cryopod and release your creature, then kill and transfer a player. Check what came back.

Watch

Go deeper

Sources

  • Unreal Fest 2026 talks (UE 5.8, the kit's version; auto captions): keeping saved names and types, loading once and saving on change, versioning saved data, placed actors' paths and not re-adding restored state (The Player Was Here, 2026-07-23). The talk's examples are C++ and GAS; the Blueprint and buff versions here are my own mapping.
  • DevKit files, read offline on 2026-11-06 (UE 5.8.1): From the game module's reflection data: UPrimalActor.bPreventSaving and bLoadedFromSaveGame; APrimalStructure and APrimalCharacter BPPostLoadedFromSaveGame with bUseBPPostLoadedFromSaveGame (sparse); APrimalBuff bIsBuffPersistent, BuffPersistentDataClass, bAllowBuffStasis, bBuffPreventsCryo, BPPreServerUpload, bUseBPPreServerUpload; UPrimalBuffPersistentData; UPrimalPlayerData.MyPersistentBuffDatas (SaveGame); AShooterPlayerController SetCustomCloudData, GetCustomCloudData, HasCustomCloudData, RemoveCustomCloudData; APrimalDinoCharacter BP_OnCryo, BPCanCryo, bUseBPCanCryo, BPPreServerUploadDino, BPPreventUploading, bPreventUploading; UPrimalItem BPPreventUpload, bUseBPPreventUpload and SaveGame-flagged CustomItemDatas; the game mode's OnPostUnCryoDino dispatcher; APrimalWorldSettings.bPlayPersistentPlayer; the engine's USaveGame, CreateSaveGameObject, SaveGameToSlot, LoadGameFromSlot and DoesSaveGameExist.
  • My other pages: lessons §3 and §8 (-ForceSave -ForceLoad; bIsBuffPersistent not saving variables; BPPostLoadedFromSaveGame); tutorials §5 (custom item data; SaveGame on structures and creatures, not items); How to make a buff (bPreventSaving on by default).
  • What modders report: SaveGame variables on singletons and structures (March and September 2024); a client's change not saving (2024); references and structure IDs after a restart (August 2025); empty SaveGame objects and slot saves (2024); unique net ID and linked player ID (September 2024, January 2025); config variables resetting (November 2025); persistence in the kit (November 2023 to March 2026); buffs lost in cryopods (April 2024); variables surviving cryo and creation time resetting (January 2026); persistent buffs as transfer marks (February 2026); custom cloud data (June 2024, October 2026); the per-creature data request (December 2025).
  • Videos under Watch are creators' tutorials, not checked against the kit. ZenRowe's is ASE-era.
  • Community knowledge from the ARK Modding Community Discord (discussions from November 2023 to October 2026), found with Overseer. Threads (they open for server members): singleton variables save (March 2024), a singleton array that won't save (July 2024), structure IDs and references (August 2025), per-structure settings (September 2024), SaveGame objects need variables (October 2024), SaveGame data can't replicate (May 2024), persistence in the DevKit (November 2023), buffs and cryopods (April 2024), variables through cryo (January 2026), marking a transfer (February 2026), custom cloud data (June 2024).
  • Clocks (corrected November 2026 after a reader's review), from the Discord: network time is per-server game time (September 2025), UTC survives transfers; cryopods and mating use it (September 2026), Get Real World Utc Time In Seconds (March 2024).
Where this page's information comes from

Applies to: ASA DevKit as of November 2026 (UE 5.8.1); ASE where noted

the DevKit's own classes, the community Discord and creators' videos (see Sources)

Esc

↑ ↓ move↵ openCtrl ↵ new tab