# Project Settings

> Every Project Settings page of Rolly Save: each setting with its config key, its default and what it does.

Product: Rolly Save 1.0.0 | Sheet: reference | Updated: 2026-10-31 | HTML: https://rolly-docs.pages.dev/save/reference/project-settings/

## Plugins > Rolly Save

`[/Script/RollySave.RollySaveProjectSettings]` in `DefaultGame.ini` · `URollySaveProjectSettings`

How Rolly Save saves and loads your game. Each value is checked when the game uses it: one that is not valid falls back to its default, and a setup error says what to fix.

| Setting | Key | Default | Description |
|---|---|---|---|
| File Prefix | `FilePrefix` | rollysave | The start of every save file's name: 1 to 16 lowercase letters and digits that start with a letter. Rolly Save reads, writes and deletes only files of this prefix, so other files in the save folder stay untouched. Set it before release: after a change, players' saves under the old prefix no longer show. |
| Enable Quick Keys | `bEnableQuickKeys` | false | Quick save and quick load with the keys below, in a standalone game or on a listen server's host. The keys also reach your game's own input, and do nothing while a menu takes all input (Set Input Mode UI Only). Rolly Quick Save and Rolly Quick Load nodes work either way. |
| Quick Save Key | `QuickSaveKey` | F5 | Saves to the quick slot. |
| Quick Load Key | `QuickLoadKey` | F9 | Loads the quick slot and opens its map. |
| Autosave Interval | `AutosaveInterval` | 0 | Seconds between autosaves; at least Minimum Interval when above 0. 0: no timer, requests still save. The timer runs in game worlds on the server or in a standalone game, stops while the game is paused and starts again after any save. At least 0. |
| Minimum Interval | `AutosaveMinimumInterval` | 10 | The shortest interval of the autosave timer, Start Autosave's too: a shorter one counts as this. At least 1 second. At least 1. |
| Autosave Slots | `AutosaveSlots` | 3 | Autosaves kept, in autosave_1 and up; each replaces the oldest. From 1 to 99. |
| Minimum Gap | `AutosaveMinimumGap` | 30 | Requests this soon after any save are dropped. At least 0. |
| Autosave After Map Change | `bAutosaveAfterMapChange` | false | Autosave once each map opened by travel begins play. |
| Maps Without Autosave | `AutosaveExcludedMaps` | empty | Such as your title, menu and loading maps. While it lists a map, lifecycle saves count every map it does not list as in play. |
| Autosaves Write To | `AutosaveWriteTo` | Own Slot | Own Slot: the autosave slots. Current Slot: the slot last saved or loaded by name, for one save per playthrough. |
| Checkpoints Write To | `CheckpointWriteTo` | Own Slot | Own Slot: the slot checkpoint. Current Slot: as for autosaves. Retries load from memory either way. |
| Save When Backgrounded | `bSaveWhenBackgrounded` | true | Save when the game goes to the background on a phone or tablet, where the system may end it later without a further warning. Windows, Mac, Linux and the Steam Deck report no such moment. |
| Save When Quitting | `bSaveWhenQuitting` | true | Save when the game quits, by the Quit Game node, the quit command or a closed window, and when the operating system ends the session. Packaged and standalone games only: Play In Editor does not quit. |
| Save When Window Loses Focus | `bSaveWhenFocusLost` | false | Save when the game's window loses focus on a desktop, such as when the player switches to another window. |
| Lifecycle Saves Write To | `LifecycleWriteTo` | Autosave | Where lifecycle saves write. As Autosave never writes over a manual save; games on phones often pick Current Slot or Resume Slot. |
| Lifecycle Saves In | `LifecycleSavesIn` | Game in Play | In which maps lifecycle saves write. Game in Play: only in a map where a game is in play, so a quit from a title map does not write it over the player's saves; while Maps Without Autosave lists maps, every map it does not list is in play. Any Map: in every map not in Maps Without Autosave. |
| Respect Save Blocks | `bLifecycleRespectsBlocks` | false | A save block drops lifecycle saves. Off: they write during a save block too, so a player who quits during a blocked fight cannot undo what happened in it. |
| Minimum Gap | `LifecycleMinimumGap` | 5 | A lifecycle save within this many seconds of the last one is dropped, as when split-screen focus changes on a phone pause the game again and again. Saves of other kinds do not count. From 0 to 600. |
| Background Time Limit | `BackgroundSaveSeconds` | 3 | How long a background save may hold the game before the system suspends it. Android waits 4 seconds; a save cut off goes on writing until the system stops the game, and the previous copy stays loadable. From 0.5 to 4. |
| Quit Time Limit | `QuitSaveSeconds` | 10 | How long quitting waits for the quit save and every save asked for before it. From 1 to 30. |
| Slot Fields Struct | `SlotFieldsStruct` | None | Your fields for slot lists, such as level; Set Slot Game Fields fills them. Keep it small. |
| Slot Screen Requests Need a Mark | `bSlotScreenRequestsNeedMark` | true | A slot screen request counts as handled only when a listener of On Slot Screen Requested calls Mark Slot Screen Request Handled, as Rolly Save's slot screen does; otherwise a Save Point on Automatic saves a checkpoint. Off: any listener counts, one that only logs included. |
| Save Thumbnails | `bSaveThumbnails` | true | Saves of the kinds below hold a picture of the game as the player saw it, without menus or widgets, for slot screens. Never on a dedicated server or a client. |
| Width | `ThumbnailWidth` | 384 | Picture width in pixels; its height follows Aspect. 384 fills the slot screen's detail panel at 1080p. From 64 to 1024. |
| Aspect | `ThumbnailAspect` | 16:9 | The picture's shape, cropped from the centre of the view. |
| Format | `ThumbnailFormat` | JPEG | JPEG is small; PNG is exact and about 5 to 10 times larger. |
| Quality | `ThumbnailQuality` | 85 | JPEG quality; lower is smaller. From 1 to 100. |
| Max Size (KiB) | `MaxThumbnailKiB` | 64 | A larger picture is saved at lower quality, then smaller, and left out when it still does not fit. From 4 to 512. |
| Kinds | `ThumbnailKinds` | Manual, Quick, Autosave, Checkpoint | Saves of these kinds take a picture. Part saves keep the slot's picture; memory slots and rewind points take none. |
| View | `ThumbnailView` | Player View | Player View: the region of the player who saved, player 1's when no player asked. Whole Viewport: every player's region. |
| Max Wait | `MaxThumbnailWait` | 0.25 | How long a save waits for the frame its picture comes from; past it the save is written without a picture. 0 asks for no frame. The game thread never waits, and a store's flush writes waiting saves at once. From 0 to 2. |
| Cache Size | `ThumbnailCacheSize` | 32 | Pictures kept in memory for slot lists, about 330 KB each at the default size. From 4 to 256. |
| Memory Slots | `MaxMemorySlots` | 8 | Each costs about twice its save's size. From 1 to 64. |
| Rewind Points | `RewindPoints` | 5 | Rewind points kept. From 1 to 99. |
| Profile Class | `ProfileClass` | None | Each local player gets one when they join. |
| Save Profiles with Game | `bSaveProfilesWithGame` | true | Off: only Save Rolly Profile saves them. |
| Profile Keys | `ProfileKeySource` | Platform User | Platform User: one profile per signed-in user or controller. Named: players make, name and pick profiles, several per machine. Provider: your Player ID Provider names each player's profile, such as by account. |
| Player ID Provider | `PlayerIdProviderClass` | None | Your Blueprint of Rolly Save Player ID Provider; its Get Profile Key names each local player's profile. Always cooked. |
| Max Named Profiles | `MaxNamedProfiles` | 8 | Create Rolly Profile fails past this many. From 1 to 64. |
| When Profiles Are Full | `ProfilesFull` | Reuse Oldest Unused | What a joining player without a profile of its own gets once Max Named Profiles exist: Reuse Oldest Unused gives it another player's profile and progress; Refuse leaves its profile unloaded, so the game can offer the profiles. |
| New Profile Name | `DefaultProfileName` | Player {Number} | The name of the profile made for a player who has none yet; {Number} is the lowest free number. |
| Run Ledger | `RunLedger` | Profile | Where single-slot runs record their newest save, so an older copy does not load. Profile: the first local player's profile. Shared: one file for every profile and a dedicated server. Off: nothing recorded; older copies load. |
| Export Location | `ExportRoot` | Saved Folder | The project's Saved folder, or the player's Documents. |
| Export Folder | `ExportFolder` | SaveExports | 1 to 64 letters, digits, spaces, _ and -. |
| Export Extension | `ExportExtension` | rollysave | 1 to 16 lowercase letters and digits. |
| Max Import Size (MiB) | `MaxImportSizeMiB` | 64 | Larger files and byte arrays are refused unread. From 1 to 2048. |
| Max JSON Import Size (MiB) | `MaxJsonImportSizeMiB` | 256 | Larger JSON files are refused unread, and Export Rolly Slot to JSON Text makes no longer text. From 1 to 2048. |
| JSON Import in Shipping | `bAllowJsonImportInShipping` | false | Let Shipping and Test builds import JSON. Off: only the editor, Development and Debug builds import it, so players cannot load hand-edited saves through JSON. Export works everywhere. |
| JSON Export Time per Frame | `JsonExportSliceMilliseconds` | 4 | How long a JSON export may read values on the game thread each frame, in milliseconds. Lower keeps frames steadier while a game exports; higher finishes sooner. From 0.5 to 50. |
| New Game+ Keeps Play Time | `bNewGamePlusKeepsPlayTime` | true | On: play time goes on across Start Rolly New Game Plus. Off: each cycle counts its play time from 0. |
| Actor Defaults | `ActorDefaults` |  | What actors that save keep, unless a Save Rule or a Rolly Save component on the actor overrides it. |
| Max Instances per Component | `MaxInstancesPerComponent` | 1048576 | An instanced component with more instances than this saves none of their changes, and the Message Log says so once. Each saved instance holds about 56 bytes while its level is loaded, about 84 once instances were removed or added and keys looked up, so the default bounds one component at about 56 to 84 MiB. A save holds at most 1,048,576 changes of one component, and a Whole List saves each instance as one: a Whole List above that never saves. From 1 to 16777216. |
| Gameplay Tag Variables | `GameplayTagVariables` | empty | Names of Gameplay Tag Container or Gameplay Tag variables that hold an actor's gameplay tags, such as OwnedTags, read on the actor and its components. Save Rules matching by gameplay tag read them beside the Gameplay Tag Asset Interface, which Blueprint actors cannot implement. |
| Remember Levels | `bRememberLevels` | true | Keep each level as the player leaves it by travel, so on return its actors are as they were, without a save; saves hold every level kept so. Off: a level that travel opens starts as designed, and a load opens its own level as saved. Clear Loaded Game, Forget Level and Forget All Levels forget kept levels, and a load replaces them with those its save holds. |
| Remember Streamed Levels | `bRememberStreamedLevels` | true | Keep each streaming level, level instance and World Partition cell as it is when it unloads, so it streams in again as the player left it; saves hold what is kept. Off: an unloaded level is forgotten and streams in as designed, such as the rooms of a roguelike; a load still sets each level the first time it streams in. |
| Keep Assets of Unloaded Levels | `bKeepAssetsOfUnloadedLevels` | true | Keep loaded the meshes, materials and other assets that saved values of unloaded levels name, up to 16,384 packages and 1 GiB, so those values are set before the level's Begin Play when it streams in. Off: their memory is freed, and such values are set after the level's Begin Play, once their assets have loaded. |
| Save Data Layers | `bSaveDataLayers` | true | Save the state of a World Partition map's runtime Data Layers (Unloaded, Loaded or Activated) and set it again with the map's values after a load, so their cells start loading before Begin Play. Layers whose Load Filter is Client Only are never saved. |
| Data Layer States | `DataLayerStates` | Changed Layers | Changed Layers: only layers whose state differs from the one they start in, so an update that changes a layer's start state reaches old saves. All Layers: every runtime layer. |
| Data Layers Not Saved | `DataLayersNotSaved` | empty | Layers your game sets itself, such as a time of day layer; a load leaves their state as it is. |
| Hide Destroyed in HLOD | `bHideDestroyedInHLOD` | true | In a World Partition map, hide placed actors a save holds as destroyed in HLODs built as destructible, after a load and as each HLOD streams in, so a destroyed bridge does not show whole from afar. Only actors of a C++ class that implements Epic's Destructible in HLOD Interface take part: a Blueprint cannot add it. HLODs still show instances removed in play. Runs on the server; clients get the HLOD's state from it. |
| Save Run-Time Levels | `bSaveDynamicLevels` | true | Save the levels your game loads with Load Level Instance under an Optional Level Name Override, with their place, class and visibility, and load them again after a load and when the player returns to the map, so the actors saved in them come back. Levels loaded without a name override are never saved, since their names change each session. Off: load them again yourself after a load; their actors' saved state applies once they stream in. |
| Saved Parameter Collections | `SavedParameterCollections` | empty | Material Parameter Collections whose values each map saves and sets again after a load and when the player returns, such as a wetness value a storm raised. Only values that differ from the collection's defaults save, so a default you change in an update reaches old saves. Each map keeps its own values. |
| Hold Players | `HoldPlayers` | After Loads | After Loads: after each Rolly Save load, each player whose pawn is there is held until the ground under it has loaded, so it cannot fall through a floor that has not streamed in. After Loads and Travel: also after each map change by travel. Off: Rolly Save holds nobody by itself; Hold Rolly Player still works. |
| Hold Method | `HoldMethod` | Stop Movement | Stop Movement: the pawn's movement stops, a root that simulates physics stops simulating, and the controller ignores move input until release. Events Only: nothing stops; bind On Player Held and On Player Released to hold players your own way. |
| Hold Radius | `HoldRadius` | 2000 | In a World Partition map, how far around the pawn the cells must be loaded before release. 0: each grid's own loading range. From 0 to 100000. |
| Hold Until Ground | `bHoldUntilGround` | true | Also wait until a trace straight down from the pawn hits an object of Ground Object Types within Ground Trace Distance. Outside World Partition maps this is the only test, so with it off nobody is held there. |
| Ground Object Types | `GroundObjectTypes` | WorldStatic, WorldDynamic | The trace counts a hit as ground only on these object types; add the type of floors that use a custom object channel. |
| Ground Trace Distance | `GroundTraceDistance` | 10000 | How far below the pawn's location the trace looks for ground. From 100 to 1000000. |
| Max Hold Time | `MaxHoldSeconds` | 15 | A hold that waits for ground ends after this long, with a warning, so no player is stuck, and a load's wait for a player's pawn the Game Mode gives later ends after this long too, so On World Ready can come up to twice this after a load. 0: no limit; the loading overlay then waits as long as the holds. From 0 to 600. |
| Hold Remote Players | `bHoldRemotePlayers` | true | On a listen or dedicated server, Rolly Save's holds also take clients' pawns, each released once its client has loaded the level of the ground below it. Off: only the server's own players are held; Hold Rolly Player still holds any player you name. |
| Reset Clock | `ResetClock` | Play Time | The clock Reset Areas set to After Game Time count on, unless an area picks its own, and the clock Regrow After counts on. Play Time: the game's play time, which pauses stop and saves keep. Game Clock: Game Clock Class, for an in-game calendar. |
| Game Clock Class | `GameClockClass` | None | Your Blueprint of Rolly Save Game Clock. Always cooked. |
| Global Handlers | `GlobalHandlers` | empty | Save Handlers for state your game cannot tick SaveGame on, such as another plugin's weather: each runs once per save and load, on the server or in a standalone game. Always cooked. Rolly Save's engine state handlers, such as Material Parameters, attach to actors and are not offered here. |
| Save Kinds | `SpreadCaptureKinds` | empty | Saves of these kinds capture actors over several frames, within Save Time per Frame, instead of in one frame; players, global objects and the slot's place and play time are taken in the first frame. A value moved between two actors during those frames can save twice or not at all; the capture pauses while a Save Block is on, so add one around such moves. Empty: every save captures in one frame. |
| Save Time per Frame | `SpreadCaptureBudgetMs` | 2 | How long a spread save captures on the game thread each frame. Lower keeps frames steadier; higher finishes sooner. From 0.5 to 33. |
| Max Save Frames | `SpreadCaptureMaxFrames` | 30 | A spread save captures what is left in one frame once it has taken this many, so it always ends. Frames paused by a Save Block do not count. From 2 to 600. |
| Spread After Begin Play Values | `bSpreadAfterBeginPlayApply` | false | After a load that opens its map, set the values of actors whose Apply Timing is After Begin Play over several frames, within Apply Time per Frame, instead of in one frame. A save asked for meanwhile sets the rest in its frame first, autosaves wait for them, and On World Ready fires once they are set. |
| Apply Time per Frame | `SpreadApplyBudgetMs` | 4 | How long spread values are set on the game thread each frame. Lower keeps frames steadier; higher finishes sooner. From 0.5 to 33. |
| Game Data Version | `GameDataVersion` | 1 | The version of your game's saved data, written into every save. Raise it in an update that changes what saves hold, and add a step for the change to the Migrations asset. Saves of a higher version are refused as made by a newer version of the game, so never lower it after release. At least 1. |
| Migrations | `Migrations` | None | The Rolly Save Migrations asset whose steps bring saves of lower Game Data Versions up to date before they load. Always cooked. |
| Check Folder | `OldSavesFolder` |  | Saves from your released builds, one subfolder per version. The Rolly.Save.OldSaves tests and the RollySaveCheckSaves commandlet load each against this build and report what fails or is lost. Keep it outside Content, so nothing cooks it. |
| Check After Saving | `CheckOnSave` | Report and Notify | After you save a map, its actors or a Save Rule, Rolly Save checks what you saved and lists warnings and errors in Message Log > Rolly Save Checks. Report and Notify also shows a notification. Autosaves and cooks are never checked. |
| Check Blueprints on Compile | `bCheckBlueprintsOnCompile` | true | Compiling a Blueprint that Rolly Save saves lists, in Compiler Results, struct members without SaveGame and a Should Cook Property Guids? setting that loses renamed variables. |
| Ignored Folders | `IgnoredCheckFolders` | empty | No check reports maps, actors or assets in these content folders, such as /Game/Developers. |
| Ignored Assets | `IgnoredCheckAssets` | empty | No check reports these maps, Blueprints, structs or Save Rules. The Message Log's Ignore buttons add here. |
| Check Severities | `CheckSeverities` |  | How each check reports. Error fails Data Validation, so a revision control submit and the RollySaveCheckProject commandlet fail too. Off: the check does not run. |
| Command Line Load in Shipping | `bAllowCommandLineLoadInShipping` | false | Let Shipping builds load the slot -RollySaveLoad names when they start. Off: only Development and Debug builds read it, so a shortcut cannot start a shipped game in another save. |
| Game Instance | `bSaveGameInstance` | true | Save the game instance's variables that have SaveGame ticked. Off: neither saved nor loaded. |
| Game Instance Subsystems | `bSaveGameInstanceSubsystems` | true | Save game instance subsystems, such as other plugins', that have SaveGame properties or declare OnRollySavePreSave or OnRollySaveLoaded. Off: neither saved nor loaded. |
| Game Mode | `bSaveGameMode` | true | Save the Game Mode's variables that have SaveGame ticked. Off: neither saved nor loaded. |
| Game State | `bSaveGameState` | true | Save the Game State's variables that have SaveGame ticked. Off: neither saved nor loaded. |
| World Subsystems | `bSaveWorldSubsystems` | true | Save the game world's subsystems that have SaveGame properties or declare OnRollySavePreSave or OnRollySaveLoaded. Off: neither saved nor loaded. |
| Level Blueprints | `bSaveLevelBlueprints` | true | Save the variables with SaveGame ticked of each map's Level Blueprint. Off: neither saved nor loaded. |
| Actors | `bSaveActors` | true | Save actors placed in levels and spawned during play: their variables with SaveGame ticked, what Actor Defaults lists, and which placed actors were destroyed. Off: neither saved nor loaded. |
| Local Players | `bSaveLocalPlayers` | true | Save each local player's controller, pawn and player state, and put the pawn back where it was after a load, in a standalone game or for a listen server's host. Off: neither saved nor loaded. |
| Storage Backend | `StorageBackend` | Platform Save Storage | Where saves are kept. Platform Save Storage, the default, uses the platform's own save system (Saved/SaveGames on desktop and Android, the platform's storage on iOS and consoles). Memory Only keeps nothing after the game closes. A C++ subclass of Rolly Save Backend keeps them anywhere else. |
| Compression | `Compression` | Balanced | How strongly saves are compressed. Balanced suits most games; Fast for large worlds saved often, Smallest for small saves or tight storage, Off for the fastest saves. Every setting loads files written with any other. |
| Saving User | `SavingUser` | First Local Player | Whose storage holds the slots, on platforms that keep each user's saves apart, such as consoles. |
| When the Saving User Changes | `SavingUserChange` | Stop Until Load | What happens when the user who owns the slots changes, such as when another player becomes the first local player. |
| Guest Profiles | `GuestProfiles` | Not Saved | Where the profile of a local player without a platform user, a guest, goes. Every guest would share one profile file otherwise. |
| Prepare Platform Storage | `bPreparePlatformStorage` | true | Let the platform prepare each user's storage as the user is bound, so a console's syncing or conflict dialog shows then, not at the first save. |
| Platform Save Interface | `bUsePlatformSaveInterface` | false | Let the platform show its own save interface while Rolly Save reads and writes, where it has one. Off: Rolly Save's messages only; each save makes several platform calls, and a dialog for each would interrupt play. |
| Answer Platform Save Info | `bAnswerPlatformSaveInfo` | true | Answer the platform's questions about Rolly Save's files (title, place, time, size, icon) for its save-data screens, on platforms that ask. |
| Platform Save Icon | `PlatformSaveIcon` | empty | The icon the platform's save-data screens show for Rolly Save's files, by the name that platform expects. Empty: the platform's own. |
| Platform Max Save Size (MiB) | `PlatformMaxSaveSizeMiB` | 0 | The size the platform's save-data screens reserve for each of Rolly Save's files. 0: each file's own size. From 0 to 4096. |
| Low Storage Warning (MiB) | `LowStorageWarningMiB` | 100 | Warn when the storage has less free space than this after a save (On Low Storage). 0: never. Storage that keeps each user's saves apart, as on consoles, cannot be measured. From 0 to 1048576. |
| Protect Saves | `bProtectSaves` | false | Encrypt saves and sign them with Protection Key, so a save a tool changed and rewrote the checksums of, as a save editor does, is noticed (Changed Saves). A byte changed by hand breaks the checksums, so that copy counts as damaged, with or without protection. It stops casual editing only: the key ships with the game, so anyone who extracts it can still change a save. |
| Protection Key | `ProtectionKey` | empty | The key saves are protected with: 64 hex digits, which Generate Key makes. Keep it once the game ships: saves protected with a key this build does not hold never load. Generate Key moves the key it replaces to Previous Protection Keys. |
| Previous Protection Keys | `PreviousProtectionKeys` | empty | Keys saves were protected with before, at most 16: saves under them load, and their next save uses Protection Key. |
| Protection Key Provider | `ProtectionKeyProviderClass` | None | A C++ subclass of Rolly Save Protection Key Provider whose keys replace the two above, for games that keep their keys in code. |
| Accept Unprotected Saves | `bAcceptUnprotectedSaves` | true | Load saves written without protection, such as those from before Protect Saves was on; their next save protects them. Off: they count as changed. |
| Changed Saves | `ChangedSaves` | Use Other Copy | What a load does with a copy changed outside the game: its checksums hold and its signature does not, as after a save editor's change. The other copy loads, or the changed one. A copy whose checksums broke counts as damaged instead. |

## Plugins > Rolly Save Screens

`[/Script/RollySaveUI.RollySaveUISettings]` in `DefaultGame.ini` · `URollySaveUISettings`

The slot screen, profiles, saving indicator, notices and loading overlay of Rolly Save. Their look and layout are under Rolly Save Core UI.

| Setting | Key | Default | Description |
|---|---|---|---|
| Show Slot Screen | `bShowSlotScreen` | true | Save Points and Request Slot Screen open Rolly Save's slot screen. Off: nothing listens to On Slot Screen Requested, so bind it to open your own menu and call Mark Slot Screen Request Handled in that listener; until a listener does, Save Points on Automatic save a checkpoint. Open Rolly Slot Screen opens it either way. |
| Slot Style | `SlotStyle` | Free Slots | What Save, Load and New Game do; each value's tooltip says how. |
| Number of Slots | `NumberedSlotCount` | 10 | Slots shown, slot_1 and up. From 1 to 99. |
| Max Slots | `MaxSlots` | 0 | The most manual saves (Free Slots), playthroughs or runs a player can have; at the limit New Save, New Playthrough or New Run is unavailable until one is deleted. 0: no limit. From 0 to 999. |
| Grouping | `SlotGrouping` | One List | How Load splits its saves into groups, shown as tabs, a rail or hub tiles. |
| Load Map | `LoadMap` | Open Saved Map | Open Saved Map: a load opens the map the save was made in. Keep Current Map: its values are set in the map that runs. |
| Close After Saving | `bCloseAfterSave` | true | Close the slot screen once a save from it succeeds. |
| Who Can Load | `LoadingPlayers` | Any Player | Which local players may load and start a new game from their slot screen. |
| Fields | `SlotFields` |  | What each row and the detail show of a save. |
| Game Fields | `GameFields` | empty | Members of your Slot Fields Struct to show, each with its words, such as Day {Value}. |
| Row Pictures | `bRowThumbnails` | true | Each row shows its save's picture; the detail always does. |
| Save Time | `SaveTimeStyle` | Relative Day | Relative Day: Today 14:32, Yesterday 21:05, the weekday within a week, then the date. Date and Time: the date and time as the language writes them. |
| Default Sort | `DefaultSort` | Newest first | The order the list opens in. |
| Player Can Sort | `bPlayerCanSort` | true | A sort chip and key change the order for the session. |
| Max Rows | `MaxRows` | 100 | Rows built after sorting; a line says how many saves are not shown. Search finds every save. From 10 to 1000. |
| Search From | `SearchFromSlots` | 20 | Search shows while the list holds this many saves or more. 0: never. From 0 to 1000. |
| Allow Rename | `bAllowRename` | true | Players change the titles of their saves. |
| Allow Delete | `bAllowDelete` | true | Players delete saves, after a question while Confirm Delete is on. |
| Allow Copy | `bAllowCopy` | false | Copy is added to More. |
| Allow Export | `bAllowExport` | false | Export is added to More on Windows, Mac and Linux, writing a file to the export folder of Sharing Saves. |
| Allow Import | `bAllowImport` | false | Load ends with Import a Save, listing the export folder's files, on Windows, Mac and Linux. |
| Abandoned Runs | `AbandonedRuns` | Ask | What Abandon Run does with the run's save. |
| Confirm Overwrite | `bConfirmOverwrite` | true | Ask before a save replaces another, and before a new game takes a slot that holds one. |
| Confirm Delete | `bConfirmDelete` | true | Ask before a save is deleted. |
| Ask Before Loading | `ConfirmLoad` | When Progress Is Unsaved | When Progress Is Unsaved: ask when more than Unsaved After of play would be lost, saying how much. |
| Unsaved After | `UnsavedThreshold` | 60 | Play time since the last save or load past which loading asks. From 0 to 3600. |
| Menu Maps | `MenuMaps` | empty | Maps that are menus, such as your title screen: loading there never asks, and a Save screen there takes no picture. |
| Title Entry | `TitleEntry` | Style Default | Style Default: players type a title in Free Slots; other styles title saves from Titles. |
| Titles | `Titles` |  | How saves without a typed title are named. |
| Max Title Length | `MaxTitleLength` | 40 | Characters a player can type in a title. From 8 to 128. |
| Slots Shown | `SlotsShown` | Auto | Auto: every save with Platform User profile keys, the player's profile's saves with Named or Provider keys. |
| Max Profile Name Length | `MaxProfileNameLength` | 24 | Characters a player can type in a profile's name. From 8 to 64. |
| New Game Map | `NewGameMap` | None | The map New Game opens after On New Game Chosen. Empty: open your start map in that event. |
| Open Options | `NewGameOptions` | empty | Options for opening New Game Map, such as listen. |
| Show Indicator | `bShowSavingIndicator` | true | A Saving sign in a corner from the start of a save until it is written, then Saved. |
| Kinds | `IndicatorKinds` | Manual, Quick, Autosave, Checkpoint, Imported | Saves of these kinds show it; memory slots and rewind points never do. |
| Show for Profiles | `bIndicatorForProfiles` | false | Also show it for saves of a profile alone. |
| Corner | `IndicatorCorner` | Bottom Right | The corner of the saving player's part of the screen, inside the safe area; the loading overlay's Loading sign uses it too. |
| Minimum Time | `IndicatorMinSeconds` | 1 | Saving stays at least this long, so a fast save is still seen. From 0 to 10. |
| Saved Time | `SavedSeconds` | 0.75 | How long Saved shows. 0: none. From 0 to 5. |
| Hide Under Screens | `bHideIndicatorUnderScreens` | true | Hidden while the player has a Rolly screen open, whose own rows show the save. A console's rules for saving icons may ask for it off. |
| Hide When the Platform Shows Its Own | `bHideIndicatorForPlatformUI` | true | Hidden while the platform shows its own saving interface: with Project Settings > Plugins > Rolly Save > Platform Save Interface on, on platforms whose save system has one. |
| Narrate Saved | `bNarrateSaved` | true | Menu narration says Saved when nothing else speaks. |
| Show While Held | `bIndicatorWhileHeld` | true | Show Loading with the spinner in the corner of each local player Rolly Save holds for ground while no loading overlay covers the screen, so a player who cannot move sees why. Needs Show Indicator. |
| Held Delay | `HeldIndicatorDelay` | 0.3 | How long a player's hold waits for ground before its Loading shows, so a short wait shows nothing. 0: at once. From 0 to 5. |
| Saved | `bNoticeSaved` | false | A toast after saves from the slot screen and quick saves. |
| Save Failed | `bNoticeSaveFailed` | true | A warning toast saying why when any save fails, autosaves included. |
| Load Failed | `bNoticeLoadFailed` | true | For loads not started on the slot screen, which shows its own question. |
| Loaded Backup | `bNoticeFromBackup` | true | A warning toast when a load took the backup copy because the newest one was damaged, or changed outside the game with save protection on, which it then says. |
| Deleted | `bNoticeDeleted` | false | A toast after a save is deleted. |
| Low Storage | `bNoticeLowStorage` | true | A warning toast when the storage runs low after a save (Rolly Save's On Low Storage), before saves start to fail for lack of space. |
| Signed Out | `bNoticeSignedOut` | true | A warning toast when the platform user who owns the slots signs out, so saving is paused (On User Signed Out), on platforms that keep users' saves apart. |
| Show Overlay | `bShowLoadingOverlay` | true | Covers the screen from the start of a load until its world is ready, or until its values are set with Wait for World off. |
| Show for Keep Current Map | `bOverlayForKeepCurrentMap` | false | Such loads finish within a frame or two. |
| Wait for World | `bOverlayWaitsForWorld` | true | Keep the overlay up after On Load Finished until On World Ready, while held players wait for the ground and spread values are set, so players never see the world stream in. Off: it hides at On Load Finished. |
| Show Picture | `bOverlayPicture` | true | The loaded save's picture, title and place. |
| Map Load Screen | `MapLoadScreen` | Frozen | What shows while a load opens its map by hard travel: Frozen keeps the overlay as the window's last frame; Movie Player draws a copy of the built-in overlay, its spinner turning, in packaged and standalone games, unless the game set up a loading screen of its own. Seamless travel never uses it. |
| Texts | `Texts` |  | Words the screens show. |
| Block Reasons | `BlockReasons` | empty | Words for the reasons of Add Save Block, such as BossFight: You cannot save during this fight. |
| Slot Screen Class | `SlotScreenClass` | None | Your Blueprint subclass of the slot screen with a layout of its own; empty: the built-in one. |
| Slot Row Class | `SlotRowClass` | None | Your Blueprint subclass of the slot row; empty: the built-in one. |
| Profiles Screen Class | `ProfilesScreenClass` | None | Your Blueprint subclass of the profiles panel; empty: the built-in one. |
| Saving Indicator Class | `SavingIndicatorClass` | None | Your Blueprint subclass of the saving indicator; empty: the built-in one. |
| Loading Overlay Class | `LoadingOverlayClass` | None | Your Blueprint subclass of the loading overlay; empty: the built-in one. |
| Input Mode | `ScreenInputMode` | Menu | Overlay for a slot screen on a Widget Component, so the game's input reaches your Widget Interaction component. |

## Plugins > Rolly Save Core

`[/Script/RollySaveCore.RollySaveCoreSettings]` in `DefaultGame.ini` · `URollySaveCoreSettings`

Project-wide settings shared by all Rolly systems.

| Setting | Key | Default | Description |
|---|---|---|---|
| Verbose Logging | `bVerboseLogging` | false | Print extra setup diagnostics from Rolly systems to the Output Log. Handy while wiring a new project. |
| Device Families | `DeviceFamilies` | 15 entries | Which gamepad family an input device's name means, for button prompts. Exact names are tried first, then parts of names; anything else is Generic. |
| Gamepad Analog Switch Threshold | `GamepadAnalogSwitchThreshold` | 0.5 | How far a stick or trigger must move (0 to 1) before prompts switch to the gamepad. A stick that drifts at rest stays below it; buttons switch at once. From 0.05 to 1.0. |

## Plugins > Rolly Save Core UI

`[/Script/RollySaveCoreUI.RollySaveCoreUISettings]` in `DefaultGame.ini` · `URollySaveCoreUISettings`

Project-wide options of the Rolly UI design system: the theme every Rolly screen draws with, and how each player's screen stack shows screens, handles the game's input and pauses. Every asset and class named here is always cooked, and so is the shared theme.

| Setting | Key | Default | Description |
|---|---|---|---|
| Theme Source | `ThemeSource` | Shared | Where this product's theme comes from. Shared (the default): the theme every installed Rolly product uses, which a theme asset's "Use as the Rolly UI theme for all Rolly products" picks (the built-in Ember until then). Preset or Asset: a look for this product only. |
| Theme Preset | `ThemePreset` | Ember | The built-in preset this product uses when Theme Source is Preset. |
| Theme | `Theme` | None | The theme asset this product uses when Theme Source is Asset. If the asset cannot be loaded, Ember is used and a setup error says why. |
| Layout | `Layout` | None | The layout template of this product's screens: Tabs, Rail (side rail), Panel (centered panel), Hub (couch hub) or Drawer (side drawer). Empty: the theme's own Layout. |
| Density | `Density` | Auto | Text, spacing inside components and sizes: Compact (x0.9), Standard, Large (x1.3). Auto: the theme's density, or the layout's own (Large for the couch hub). |
| Drawer Side | `DrawerSide` | Right | The side a side drawer docks to. In split screen it docks to the outer edge of the player's part of the screen instead. |
| Dialog Class | `DialogClass` | None | Dialogs (questions, confirmations). Empty: the built-in one. Pick a Blueprint subclass to change its layout. |
| Template Classes | `TemplateClasses` | empty | Your own layout templates, by id: a Blueprint subclass of a Rolly template that arranges the named slots in the designer. Under a built-in id (Tabs, Rail, Panel, Hub, Drawer) it replaces that template; under a new id (Codex) it adds a layout that Layout, the theme's Layout and Set Layout can pick. An id left out uses the built-in template. |
| Toast Class | `ToastClass` | None | Toasts (short messages that do not stop the player). Empty: the built-in one. Pick a Blueprint subclass to change its layout. |
| Scroll Lists on Hover | `bScrollListsOnHover` | false | Scroll a list when the pointer gives one of its rows focus. On: the row under the pointer is kept in view with a row to spare, so a pointer resting near the list's top or bottom edge scrolls it. Off: only the mouse wheel, a drag, the scroll thumb, the keyboard and the gamepad scroll lists, and a partly visible row under the pointer still takes focus. |
| Screen Layer | `ScreenLayer` | Player | Where screens are drawn: in each player's part of the screen (split-screen aware), or over the whole viewport, above a HUD added with Add to Viewport. |
| Viewport ZOrder | `ViewportZOrder` | 100 | Z order of the screens when Screen Layer is Viewport (higher draws on top). |
| Above Game ZOrder | `AboveGameZOrder` | 10000 | Z order of a player's screens while one of them shows above the game's widgets (a screen's Show Above Game Widgets): above every widget the game adds to the viewport at a lower order, whichever Screen Layer is set. |
| Input After Screens | `InputAfterScreens` | Previous | What the game's input becomes when the last screen closes. |
| Pausing | `Pausing` | Standalone Only | When screens that ask for it pause the game. |
| Narration Provider Class | `NarrationProviderClass` | None | The game's own voice for menu narration: a Blueprint subclass of Rolly Save Core UI Narration Provider. Players find it among the narration voices as the Game Voice, and Auto picks it when no screen reader runs and no Windows voice or engine speech exists. Empty: no Game Voice. |
| Common UI | `CommonUI` | Auto | Common UI: Auto hosts each player's Rolly screens in an activatable widget of their own while the game uses Common UI's game viewport client, so Common UI's focus and input follow them and focus returns to the game's widget when they close. Off leaves Rolly screens as they are without Common UI. |
| Common UIHost Class | `CommonUIHostClass` | None | The activatable widget that hosts each player's Rolly screens in a Common UI game: a Widget Blueprint subclass of Common Activatable Widget, to set its input config or focus target. Empty: Common UI's own Common Activatable Widget. |
| Common UIHost Panel | `CommonUIHostPanel` | None | The panel of the Common UI Host Class the screens go into (an Overlay by name). Empty, or not found: the screens fill the widget. |
| Keyboard Layouts | `KeyboardLayouts` | empty | The letter rows of the Rolly Keyboard per culture ("fr", "pt-BR"), top to bottom, under the digits: for a language whose built-in rows you want to change or that has none (built in: QWERTY for Latin-script languages, AZERTY for French, QWERTZ for German, Czech, Slovak and Hungarian, the Russian and Greek layouts, and a grid of the text's letters for other alphabets). |