TL;DR A cloud service can move save files between devices while the game decides what those files mean. Use a common ancestor and game-specific fields to distinguish safe reconciliation from competing progress. Preserve recoverable copies, explain any choice by its consequences, and keep the selected revision from being silently overwritten by a resumed or offline device.
Before the split
On Sunday morning Ellis saves at a campsite in Lantern Marsh, an invented single-player exploration game. The character has twelve repair tokens and has opened the north trail. The journal has two observations about a stone bridge. Ellis plays on a desktop at home and on a handheld while commuting. At this moment both have the same game revision, which the fictional studio calls revision 30. That record provides a shared past for everything that follows.
The studio treats a revision as an identified state with a parent, a schema version, and enough information to load an internally coherent world. The identifier does not come solely from the time on a device. The game can still show a meaningful date to Ellis. The product's comparison logic needs to reason about ancestry because travel, offline play, and changing clocks make timestamps weaker evidence than players expect.
When a device loads and continues revision 30, its next committed save names that starting point. If both devices advance independently, they produce two descendants of the same ancestor. A greater revision number on one local device can show more saved steps on that branch. It cannot establish that the device saw or incorporated the other branch. The game needs a picture of the relationship before it can tell a player what publishing one version will replace.
It helps to distinguish the object being synchronized. A platform can upload and download a group of files, while a studio defines how those files combine into a character and world. Valve's Steam Cloud documentation describes an API option and an Auto-Cloud option, along with synchronization between machines. Those features provide file transport. The story consequences of reconciling two creative decisions in Lantern Marsh are the studio's responsibility. Steam Cloud documentation
Sunday afternoon. Two versions of the same bridge
On the handheld Ellis crosses the marsh. The character spends eight of the twelve tokens repairing the bridge and picks up two more on the far bank. The trip leaves six tokens and a world with the bridge intact. In a side note Ellis identifies a tree with an unusual mark. The save completes offline. Its branch is called 30H, as a shorthand for the branch stemming from revision 30 on the handheld.
On the desktop the next day Ellis spends nine tokens improving a boat and gathers five from a landing. This branch ends with eight tokens. Ellis also makes a story choice to close the damaged bridge and reroute traffic through the boat landing. The save reaches cloud storage and becomes revision 30D. Its record contains a new mark showing the herb bed at the landing. The player on the handheld has not seen any of this. Each branch is a legitimate outcome within its own history.
The lead designer invites a tester to combine the two late saves by retaining the latest recorded value in each field. That rule selects a boat outcome from the desktop and, under one guessed timestamp order, a working bridge from the handheld. Its choice of token balance depends on which device wrote later. It can leave a character with two route upgrades purchased through an opening stock that could not fund both. The resulting world may contradict both its transaction history and the challenge the player agreed to undertake.
The obvious attempt to sum changes gives a better diagnostic. Revision 30H changes twelve tokens to six, a net loss of six. Revision 30D changes twelve to eight, a net loss of four. Starting from twelve, adding both net changes yields two. But the two purchases cost seventeen tokens before counting any pickups. In the handheld branch the two gained tokens follow the bridge improvement. In the desktop branch five follow the boat upgrade. One explicit order of actions may sometimes finance both. The events also belong to incompatible story choices. A positive merged balance is weak evidence of a reachable combined world.
The branches further encode mutually exclusive route policy. The studio wrote two different responses to the bridge choice. One keeps the reopened footway available. The other changes the region's path and its dialogue to depend on the boat landing. Choosing the repaired bridge together with dialogue saying it will remain closed creates a false story. This is about the game's original rules, not a limitation of a generic merge algorithm. The developers who built the choice are the people who can define how it may be reconciled.
Which pages belong together
Ellis's two observations seem more promising. The tree mark and the herb bed are separate pieces of optional investigation and could coexist in a personal field notebook. If each note has its own stable identifier and no branch deleted or corrected the other's entry, a designed union can preserve both. The studio first decides whether carrying the notes changes progress or unlocks a reward. If the notebook is purely informational, the union may be safe. If reporting both observations grants an entitlement that requires visiting both places in one world, the reward state needs the stronger rule.
That distinction encourages a cleaner data design. The profile can maintain its own set of optional discoveries, while each playable world keeps quest and resource state together under an identified save. The developer should write the contract for how the profile affects play. A set of collected names should not accidentally become a set of already obtained items. People may enjoy carrying annotations across versions while preserving the integrity of the harder choices they made.
Profile preferences have another set of consequences. Ellis changes subtitle size on the handheld because its screen is small. Ellis remaps a desktop key to work around a keyboard layout. Syncing one global last preferences file can make the desktop loud or difficult to use after the handheld changes. A carefully scoped preference can be appropriate to one device, activity, input class, or account. The preferences schema should record which value travels where before treating any conflict as a race between time fields.
Deletion requires special handling even for apparently independent notes. Suppose Ellis deliberately removed a note from the original notebook on one device and left it unchanged on the other. A merge that sees only two current sets can reintroduce something that was intentionally removed. A version with a common ancestor, or a data model that preserves specific delete operations, can distinguish removal from a missing upload. The studio evaluates how long it needs to retain a deletion marker and how it will behave when a much older device reconnects.
A correction can be ambiguous as well. A discovery about the stone bridge exists in revision 30. On the desktop Ellis changes the description. On the handheld Ellis renames the same discovery after seeing it from a new angle. Two edits to a human-authored note deserve different treatment from unioning two new notes. The studio preserves both if it cannot apply an explicit merge rule. The game can contextualize the choice in a notebook without disturbing the world branch Ellis presently wants to resume.
The contract is useful even if the studio has no immediate plans for automatic merges. It lets engineering specify what constitutes one coherent saved state, which fields can be exposed during selection, and which additions can be considered later. A generic account synchronizer has no reason to know that a notebook discovery is independent while a choice and its resource expenditure are linked. The data representation should give an eventual reconciliation system a way to see the relationship without reading script source during an incident.
The conflict screen shows two evenings
When the handheld reconnects, Lantern Marsh's launcher recognizes two branches with the same ancestor. A user interface says which session each came from and what the player did there. The handheld choice describes the repaired bridge, six repair tokens, and the location of the next playable moment. The desktop choice describes the upgraded boat, eight tokens, and the alternate route. Accurate creation dates can help orient Ellis. Meaningful details support the decision even when a system clock is wrong.
Because the state of the story cannot be combined under the published rules, the example interface asks Ellis to continue one branch and keep the other as a recoverable copy if storage permits. The recovery copy needs its own stable identity. Otherwise a file sync can reintroduce it as another current revision and present the same choice repeatedly. The game must clearly describe any finite retention period and what happens if a space limit prevents creating a new backup.
One prompt should avoid implying that the player did anything wrong. Offline progression is an expected feature of the game, and resuming across devices is a reasonable thing to attempt. The useful message explains the exact conflict. Both versions came from an earlier common save and now describe different outcomes. It tells Ellis what will be loaded and, if relevant, how to find the preserved alternative. The display can reveal story choices carefully if showing them would spoil a later act for someone else at the device.
The selection procedure needs recovery of its own. A client can be interrupted while archiving the other branch and marking the selected branch current. If recovery discovers that the current marker advanced before the preserved copy was durably saved, it needs a consistent way to finish or roll back the operation. A QA test can stop the application at each relevant point and verify the resulting files on initialization. An attractive conflict interface offers little assurance if half-written choices silently delete the branch it promised to protect.
Ellis's case also motivates provisional display. If the local machine can load a valid world but cannot establish the current cloud revision because connectivity is poor, it can distinguish an offline copy from a synchronized one. The game makes its commitment policy explicit before the user progresses, rather than showing the uncertainty only at exit. A game that chooses to block an ambiguous load needs an accessible recovery route, while one that permits it needs to accept the branches it deliberately creates.
A suspended device can wake inside the old world
The studio's test crosses a boundary that a simple restart misses. Lantern Marsh is suspended on a device with a world already loaded in memory. Another device advances during suspension. Depending on the actual platform and application settings, local save files may change while the suspended process still has the old world loaded. A careless autosave on resume can overwrite a perfectly good downloaded revision with the stale in-memory version.
Steamworks describes Dynamic Cloud Sync as support for synchronizing on suspension and downloading updates during a session, with a notification available to an application as local files change. Valve makes clear that existing builds should be tested before the feature is enabled widely. The developer still chooses how to respond to a loaded old state and a freshly downloaded save. A game can offer to reload at a safe point, or preserve a local fork when the app's rules allow it. Steam Cloud dynamic sync documentation
Steam's remote storage reference also describes write-batch hints for files that belong to one logical change. A hint can help the platform coordinate sync, but the game still needs a valid local save format and defined write failure handling. Lantern Marsh tests a revision manifest and its world data together. If either belongs to a different logical change, the loader can locate an earlier coherent copy or explain the issue. Passing a happy-path upload does not prove that a multi-file save will always remain usable after interruption. Steamworks remote storage API
Consider a suspension just as the app stores two independent files. One contains a world snapshot and the other an index saying it is the latest. The app should publish a logical revision only when the complete pieces it needs are present. A later reader should verify coherence and be able to identify a previously complete candidate if the newest pieces are missing. This is a design property of the save set. It should hold even when the system never uses a cloud transport.
Cloud support can also create expectations about platform coverage. A studio using multiple operating systems should verify how the configured storage paths and file formats interact. It can have modern account synchronization while an older build on one operating system still uses a local directory excluded from its sync configuration. The player may see an old revision without any visible conflict prompt if the studio never associated the right files with the save service. A cross-platform test begins by checking which profile and actual map state arrived.
The studio simulates a suspended session with a different connected user account to test a separate boundary. It records which profile owns each candidate and makes sure a cached anonymous preview cannot reveal another player's branch. The expected result depends on how the account and local device modes work, but the question is universal. Before carrying progress forward the game should establish which person's world it is entitled to read. A conflict can be valid even if the cloud files look perfectly formatted.
One studio runs the afternoon again with a format upgrade
A new game build adds a note field to its world format. The desktop upgrades first and writes revision 30D. The handheld is still running a release that does not understand the added data. This may be a fully supported upgrade path if the old reader preserves unknown values or an older format can safely coexist. It may also be intentionally a one-way migration. The studio needs to document and test the actual promise. Silently dropping content during a cross-device load is the kind of error a save chooser can make worse.
The practice version gives each candidate a schema identifier. A build may be able to show safe summaries without loading the candidate into an old simulator. Another test checks whether an older build can damage the newer reference by creating its own local revision and uploading it. The application's safeguards should be supported by the carrier's conflict and retention behavior, not merely by a user interface that no longer appears when the package is too old.
Account support also gets a reproducible case. Someone reports that a character disappeared after a device switch. The studio asks which slot, world revision, game build, and device class were visible. A support tool can use those references to locate candidate histories where authorized. It should generally avoid requesting full save contents if a redacted identifier, ancestry, and schema suffice. A save may contain a player's private names or play details unrelated to the investigation. More data can make troubleshooting slower if nobody knows which fields matter.
The last test examines capacity. Imagine two 20 MB world snapshots and a 40 MB quota designated by the studio for the test. Keeping both fits the invented quota, before any index or metadata usage is counted. Saving another complete copy would exceed it unless the team changes its format, rules, or storage plan. A backup promise should account for real serialized size and documented platform limits. If the game cannot preserve both, it needs to allow an export or make the consequence of choosing honestly clear. Players understand finite storage more easily than a promise that vanishes without explanation.
The tester concludes by restoring revision 30 from an archive in a separate slot. The operation keeps the current choice and its backup in view so the player can distinguish a deliberate replay from a cloud conflict. A backup that can be restored only by overwriting the sole current file is poor insurance. The restoration path is part of acceptance. It must work across the save formats and account settings the game claims to support. A test that proves a backup file exists is only the beginning.
A second restoration test reconnects the handheld after several more cloud revisions. The backup is available, but the player wants to continue both histories independently in separate slots. The design needs a deliberate fork operation that assigns a new slot identity while preserving the ancestral relationship for support. Copying the saved file into a slot with the original identity can hide that intention from a later sync. The studio checks that the local copy and synced slot each advance along their own history, and that the player can see which one remains local if they chose to keep it that way.
It is also worth testing a conflict between the game's own recovery choice and a platform's file-level conflict dialogue. Depending on implementation, the platform may present a decision before the game starts, when the player sees only storage metadata. The studio verifies which candidate files its own reader can still recover after the platform's supported resolution paths. It may choose fewer synced files, a different slot structure, or backups that persist independently through the platform selection. A robust studio design assumes only the transport properties the shipping integration actually provides. Internal conflict handling never recovers a candidate file that was already deleted elsewhere and has no retained copy.
Ellis finally boards the boat
In the worked case, Ellis selects the desktop branch and keeps the handheld branch as a separate local recoverable world. The profile retains the two independent observations under the studio's carefully defined notebook rules. The active world loads with the boat upgrade and eight repair tokens. When the handheld wakes again, it sees a later accepted choice and cannot conclude that an in-memory autosave should reopen the conflict. That decision has a durable record with a visible parent and a safe restoration path for the alternative.
A team can use one original scene like this to make a precise release gate. The recognized descendant of a known world should advance normally. Independent annotations may merge only if the game defines their semantics. Two divergent world histories must remain coherent and recoverable under the declared selection protocol. A device returning from sleep needs a chance to reconcile before overwriting new files. Those outcomes give the studio something real to demonstrate on each supported platform. The synchronization log is useful alongside them. It becomes evidence of transport rather than the last word on which adventure a person gets to keep.