GUIDES
OpenFront Singleplayer Save & Share: Persist a Solo Campaign and Hand It to a Friend
In OpenFront v0.36 and later, save a singleplayer (Solo) game to your account from the in-game menu, resume it from the Solo panel, and share a link or code so a friend can open the exact same position — replacing the temporary replay links and record-to-YouTube workarounds.
Direct answer: save the run, resume it from the Solo menu, and share a link or code
In OpenFront v0.36 and later you can save a singleplayer (Solo) game to your own account, come back to it any time, and hand a friend the exact same position. The loop is: pause your Solo game and open the save action from the in-game menu, where the description reads “Save this game to your account to continue it later”; confirm, and you get “Saved. Find it in the Solo menu.” Your save then appears in the Saved games panel, from which you can Play it (resume), Share it (copy a link), Rename it, or Delete it. Sharing produces a link of the form <origin>/#modal=single-player&save=<code> where <code> is a short nanoid; a friend opens that link in a browser and the game loads directly, or — on Steam and the game portals, where the link cannot navigate the app — they paste the code into the paste field that reads “Paste a shared game link or code”. Because the load path accepts either the full link or the bare code, a friend can hand you just the short code and it still resolves to the same save.
This matters because before v0.36 there was no first-party way to keep a solo run. The community threads from 2025 and 2026 are full of players trying to save an impossible-mode win, told “look at your history for the game id,” discovering that game links “only seem to be temporarily available” and “will work until the next update or version, after that it will not work,” or reaching for a third-party tool and screen recording. A saved game is different from a replay in three ways that change how you play. First, it is your account object rather than a temporary public record, so it is tied to your account and not to a public URL that can expire. Second, you load it instead of watching it, so you can continue playing from the saved tick as a live game, not observe a recording. Third, it is durable within your version line in the sense that nothing about it expires on the next client update the way a replay link does. The one rule that keeps it singleplayer: only a singleplayer game can be saved and loaded — a multiplayer match is rejected with “Only singleplayer games can be loaded.” If your run is multiplayer, the save loop does not apply to it at all.
Version boundary: v0.36.0 or later, account required, singleplayer only
The save-and-share loop is new in v0.36.0 (official Release published 2026-11-09T16:58:23Z, tag v0.36.0). Everything in this guide assumes you are on v0.36.0 or a later build; on any older client the in-game save action and the Saved games panel simply do not exist, and the feature is not back-compatible. That has two consequences you should plan around. First, if you save a game on a newer build and then try to open it on an older one, the client reports unreadable — “This saved game can’t be loaded by this version of the game” — so a save is tied to the version line that created it, not to the exact patch, and you cannot step backwards. Second, if you share a save with a friend who is on an older client, the same unreadable wall appears for them; check that your friend is on v0.36.0 or later before you send the link, otherwise the share is dead on arrival and you will only find out when they report the error.
Saving also has three hard preconditions, and missing any one of them is the reason a save or a share silently produces nothing. Account: saving requires you to be signed in — the status string is “Sign in to save games.” — so an anonymous or logged-out Solo session cannot save, which is exactly the trap players hit in the community threads where a milestone win produced no replay or trophy because the state of the session and the record did not line up. Singleplayer only: the feature is scoped to Solo; you cannot save or share a multiplayer match, and loading something that is not singleplayer is rejected outright. Size ceiling: each save captures a snapshot of the full game state, and the client enforces MAX_SNAPSHOT_BYTES = 64 * 1024 * 1024 (64 MiB); a snapshot larger than that cannot be saved, so a late-game state on a very large, very populated map is the situation most likely to trip the ceiling. Knowing these three boundaries before you start a campaign you want to keep — be logged in, be in Solo, and expect the biggest endgame states to be the ones closest to the limit — is the difference between a save that just works and one that surprises you at the worst moment. You can check your own client version from the main menu’s about / settings surface, and the same check tells you whether a friend’s reported version is new enough before you send them a share, so make that two-second check a habit the first time you share rather than the first time a load fails.
How to reach the save action and what the menu actually does
You reach the save from the Solo / in-game menu, not from the main menu and not from the replay viewer. Start your singleplayer game the way you always do, and once it is running and you have paused, open the in-game menu; the save entry is labeled “Save game” (label string save_label) and its helper line is “Save this game to your account to continue it later” (save_desc). Pressing it runs the save and the status advances through saving (“Saving…”) to saved (“Saved. Find it in the Solo menu.”). The panel that holds your saves is titled “Saved games” (title) and, when you have none, shows “No saved games yet. Save one from the in-game menu.” (empty) — so an empty panel is the normal starting state and not an error. The panel is where you manage everything you have saved, and it is reachable any time from your account, which is why a save is a persistent object rather than something tied to the open game window.
From the Saved games panel each saved entry exposes four actions plus a load path. Play opens the save as a live singleplayer game at the saved state — this is the resume, and it is a real game with a working economy, live borders, and AI opponents, not a playback. Share toggles the save to a shared state and copies the link; a shared save shows a “Shared” badge and a “Copy link” control, with “Link copied” confirming success. Rename changes the display name, and Delete removes it with a confirmation that reads Delete the save name? This can't be undone. Beyond the panel, there is a paste field — “Paste a shared game link or code” — that loads either a pasted share link or a bare code; the helper savedGameIdFrom() in the client accepts a full link or the code by itself, so a friend can hand you just the short code and it resolves to the same save. Two guards run automatically on the name: if the name you choose is not allowed you get name_invalid (“That name isn’t allowed.”), and if the name cannot be shown on a shared game you get name_not_shareable (“That name can’t be shown on a shared game. Rename it first.”) — the latter blocks sharing until you rename, which is why a clean, shareable name matters the moment you intend to send a save to anyone rather than only to yourself.
The decision framework: when to save, when to share, when not to bother
Treat a save as a checkpoint you create deliberately, not a passive record the game keeps for you. The single most useful rule is to save before a risky, expensive phase rather than after it — right before a large offensive, a mass nuke, or a final push into the enemy core — so that if the phase fails you can reload the saved tick and retry with different timing instead of replaying the whole campaign. In a long singleplayer campaign this is the move that turns an all-or-nothing run into an iterative one: you are not racing to a single perfect completion, you are driving the same campaign to a win you can reach, and the save is what lets you afford the failed attempt. A practical cadence is to save at every major turning point — after an expansion that you are not sure about, after an alliance decision, and before any commit you would not want to redo — and to keep at least one “safe harbor” save from earlier in the campaign so a late blunder never costs you the whole run.
The second decision is when a save is worth sharing at all. Share when the position itself is the point: a puzzle you want a friend to finish, a boss fight you want to run together from the same start, or a showcase of how far you pushed before the map turned on you. Do not share when the value is in the play rather than the position, because a shared save only carries the state at the saved tick — the decisions that got you there, the route you took, the mistakes you made — are not part of it. If your goal is to show someone how you played, a replay (see the replay-review and replay-takeover guides) is the honest tool; if your goal is to hand them the board and say “get me across this,” the shared save is the right tool. The third decision is capacity and naming: because the panel enforces a finite limit and the error tells you to “Delete one from the Solo menu first,” you should decide in advance which checkpoint to drop when the list fills, and a good default is to keep the oldest safe harbor and the newest pre-commit save, and delete the intermediate checkpoints once the phase they guarded is safely behind you. Alongside that, give each save a short, descriptive, shareable name — for example the tick and the phase, like “t1200 pre-offense” — so the list stays legible and the name never trips the share guard.
Failure modes and countermeasures
Most save/share failures fall into a small set, each with a specific recovery, and recognizing which one you hit saves real time. limit — “You’ve reached the saved game limit. Delete one from the Solo menu first.” — is the client mapping an HTTP 409 from the server; the countermeasure is to delete a checkpoint you no longer need and re-save, and it is best to manage capacity from the start rather than discover the ceiling at the exact moment you want to save. unauthorized — “Sign in to save games.” — means you are not logged in; sign in and retry, and this is the exact reason an earlier anonymous win produced nothing to save. name_not_shareable blocks sharing until you rename the save, so if a name with characters the share surface refuses, rename it first and share again. code_invalid — “That isn’t a shared game link or code.” — means the pasted string is neither a valid share link nor a bare code; re-copy the link or paste only the code. shared_not_found — “This shared game isn’t available. It may have been deleted or made private.” — means the save was deleted or made private by its owner, so a share is only as durable as the owner keeping it shared.
unreadable is the version wall: the save was made on a newer build than the client trying to load it, and there is no recovery other than updating the client (or asking the owner to re-save on a compatible build). not_found — “That saved game no longer exists.” — is the own-save analogue: the record is gone, so there is nothing to load. download_failed and load_failed are transient network/parse problems (“Couldn’t download the saved game. Try again.” / “Couldn’t start the saved game.”) and usually resolve on a retry; request_failed (“Something went wrong. Try again.”) is the generic failure and also worth one retry before assuming something deeper is wrong. The cross-cutting countermeasure for all of these is the same discipline that makes the feature reliable in the first place: save early and often, keep the list short so the limit never ambushes you, use clean shareable names, confirm your friend’s client version before sending a share, and never treat a save as something you can recreate later — if you want a position, save it now, because the state at a tick you did not save is not recoverable from the running game.
How this replaces the old workarounds (comparison)
The community spent the pre-v0.36 era improvising around the absence of a save, and it is worth being explicit about what changed, because each old workaround had a specific cost that the save/share loop removes. A temporary replay or game link could be watched but not continued, and it “will work until the next update or version, after that it will not work” — so a link you were relying on could vanish the moment the game updated, with no way to recover the position. Screen recording (the “record then post on youtube” advice) preserved the video of the run but not the game, so it could never be resumed or handed over as something a friend could play — it was proof, not a position, and it could not answer “what if I tried this from here.” The third-party replay tool (the one that “will open the correct version automatically and instantly start the replay” from a game id) was the closest substitute, but it depended on external hosting, a separate site, and the game id surviving, and it still only replayed the game rather than letting you take control and continue from the state.
| Approach (pre-v0.36) | What it preserved | What it could not do | What v0.36 save/share adds |
|---|---|---|---|
| Temporary replay / game link | A watchable record of a finished game | Resume or continue; survive the next client update | A durable, loadable save you can play forward from |
| Screen recording (YouTube) | A video of the run and the play | Resume, share as a playable state, or verify the exact board | A real game state, not pixels, that loads as a live match |
| Third-party replay tool | Replay in the correct version from a game id | Take control and continue; guaranteed/first-party durability | First-party, on your account, resumable and shareable |
| v0.36 save (own) | Full singleplayer state on your account | — (resumable, durable within your version line) | The baseline checkpoint the other rows approximate |
| v0.36 share (to a friend) | The same state, opened by link (browser) or pasted code (Steam/portals) | — (singleplayer only, needs friend on v0.36+) | Hand the exact position to another player as a playable game |
The honest limits of the new loop are equally clear and worth stating alongside the wins. It is singleplayer-only, so it does nothing for multiplayer matches, and if you want to keep a multiplayer moment the replay tools remain the right answer. It is version-bound, so a save is only loadable on the version line that made it (newer is fine; older is unreadable), which means a save is not a permanent archive of a specific patch. It is bounded by a limit and a 64 MiB snapshot ceiling, so a fully packed endgame on a huge map is the thing most likely to be refused, and you should plan around it. And a share is only as durable as the owner’s choice to keep it shared, so a share you intend to keep working must not be a save you quietly delete. On the core complaint from every community thread — “is there a way to save my offline game without losing it” — the answer in v0.36 is now yes, first-party, on your account, and shareable.
Scenario: a long impossible-mode campaign you want to resume
Assume the concrete situation from the community threads: you are running an impossible-mode singleplayer campaign on a large world map, you are logged in, and you are about to launch a final offensive against the leading bot that has been stockpiling a huge army. You are on tick 1,200 of the match, your economy is solid but thin against that army, and you have no idea whether the offensive will hold. This is exactly the moment to save: pause, open the in-game menu, press “Save game,” and you are at saving then saved with the checkpoint in your Solo panel. The value of that checkpoint is concrete. If the offensive fails — the bot’s army absorbs your first wave and turns on your border — you reload the saved tick at 1,200 and retry with a different timing, a repositioned front, or a held-back unit that you commit only after the first exchange, and you have not lost the 1,200 ticks of setup that got you to this position. That is the difference between a campaign where every blunder costs a full restart and one where a failed commit costs a reload.
Two numbers make the discipline tangible. First, the tick you save at is the tick you return to: a save at 1,200 returns you to 1,200, so saving before the 1,300 offensive is what lets you retry it; saving after it only protects the post-offensive state and does nothing for the attempt you want to redo. Second, the snapshot size: a late-game state on a large, populated map is the biggest snapshot you will create, so it is the one most likely to approach the 64 MiB MAX_SNAPSHOT_BYTES ceiling — which is another reason to keep an earlier, smaller “safe harbor” save (say, a checkpoint from tick 600 when the map was less dense) that is far from the ceiling and always loads. A third practical number is the cadence of retries: if each offensive attempt from tick 1,200 takes you about ten in-game minutes to fail, a save means each retry costs those ten minutes rather than the full run, so over three attempts you save the entire pre-1,200 buildup twice. If your offensive eventually wins, the win is yours either way; the save is what lets you take the losses on the way there without paying for them again, which is the entire point of persisting a solo campaign rather than gambling each run from scratch, and it is the move that turns an impossible-difficulty campaign from a lottery into something you can actually grind toward.
Scenario: sharing a boss position with a friend across platforms
Now the sharing side, with the platform split that actually trips people up. You have saved a singleplayer game at the moment just before a difficult “boss” sequence, and you want a friend to take it on from your exact position. On the browser, you Share the save, copy the link of the form <origin>/#modal=single-player&save=<code>, and send it; your friend opens the link in their browser and the game loads directly into the Solo modal at your saved state — they are now playing your position, and everything else in it (economy, borders, AI armies) is live. On Steam and the game portals, the same link cannot navigate the app, so the flow is different: you send them the code (or the full link) and they open the Solo modal’s paste field — “Paste a shared game link or code” — and paste it; savedGameIdFrom() resolves the link or the bare code to the save and it loads the same way. The single most common failure here is a friend who is not on v0.36.0 or later: they paste a perfectly good code and get unreadable, because their client is older than the save. Before you send anything, confirm their client version, because a share sent to an older client is unrecoverable on their end until they update, and the least you can do is state in the message “you need v0.36 or newer.”
The second trap is name-based: if your save’s name contains characters the share surface refuses, the Share action is blocked with name_not_shareable until you rename it, so set a clean name before you share rather than discovering the block at the moment you try. The third is durability: a share is only alive while the save exists and stays shared, so if you later Delete the save or make it private, your friend’s link starts returning shared_not_found (“This shared game isn’t available. It may have been deleted or made private.”). If the share is time-sensitive — “play this tonight” — do not plan on it still working next week, and if it is durable — a position you keep sharing — leave the save in your panel and shared. Put the platform rule and the version rule together and the reliable sequence is: save the position, give it a clean shareable name, confirm the friend is on v0.36+, send the link for a browser friend or the code for a Steam/portal friend, and keep the save shared for as long as the share needs to be open. One more detail worth internalizing: because the friend loads the state at your tick, they inherit your setup but not your intent, so if the position has a “right way to proceed” you should tell them that in words alongside the link, since the save carries the board but not the plan.
Mode, map, and the practical limits of a save
The feature behaves differently across modes and maps, and a few of those differences change where saving is worth the effort. Mode: the save/share loop is singleplayer-only and applies to every Solo difficulty — easy through impossible — so a save is equally valid on a casual easy run and on the impossible campaign the community threads are obsessed with; nothing about the difficulty changes whether the save works, only how tempting it is to want one, and an impossible run is simply the run where losing a position costs the most, which is why the save matters most exactly there. Map size and density: the snapshot captures the full state, so a larger, more populated map produces a bigger snapshot, and the biggest snapshots are the ones closest to the 64 MiB MAX_SNAPSHOT_BYTES ceiling. The practical consequence is that a late-game save on a large world is the one most likely to be refused, while an early save on the same map is small and safe — which is precisely why keeping an early “safe harbor” checkpoint is cheap insurance, and why if a big late-game save is refused you fall back to the earlier, lighter one.
Number of opponents: more live AI players and more structures mean more state to capture, so a dense endgame with many surviving players is heavier than the opening; if a save is refused at a late tick, the fallback is to load an earlier, lighter checkpoint and drive forward again rather than fighting the ceiling head-on, and this is especially relevant on the largest world maps where the endgame is the densest. Persistence across sessions: a save is an account object, so it survives closing the game and reopening it — that is the whole point of “Save this game to your account to continue it later” — and you can resume a days-old save the same as a fresh one, which is what makes the feature a real persistence layer rather than an in-session pause. Persistence across versions: a save is loadable on the version line that made it (newer clients load it; older clients report unreadable), so it is durable within your version line but not a permanent archive of the exact patch. Sharing durability: a share lives as long as the owner keeps the save shared and not deleted. None of this changes the core value — a resumable, shareable singleplayer position — but it explains the shape of the failures you will actually meet: version walls on older clients, the size ceiling on huge late-game states, the limit on a full panel, and a share that quietly dies when its owner deletes the save. Manage those four and the feature is about as reliable as a first-party save gets.
Where this fits with the other singleplayer tools
The save/share loop is one of several singleplayer tools, and it is useful to know which one reaches for which, because mixing them up wastes time. The replay viewer and replay takeover are about review and what-if on a finished game: you pause a recorded match, pick a surviving player and a bot difficulty, and play the decision forward as a new singleplayer game — that is the tool when you want to test a branch of a game that already happened, and it writes a separate singleplayer record without touching the original. The save/share loop is about persisting a live singleplayer campaign you are actively playing: it is the tool when you want to stop, come back, or hand the position to someone, and it does not create a what-if from an old game — it resumes the one you are in. If your question is “was that call right?” use the replay takeover; if your question is “let me keep playing this campaign tomorrow” or “can you take this from here?” use the save and the share. The cleanest way to hold the distinction is by time: the replay tools look backwards at a finished game and the save/share loop looks forwards at a game you are still in, so the moment you are still in the game and want to keep it, that is the save, and the moment the game is over and you want to re-run a part of it, that is the takeover.
For the concrete next steps, the adjacent guides that complement this one are the seekable replay viewer (the default v0.36+ viewer you are saving out of or into), the replay takeover (the what-if tool for finished games), and replay review (how to actually read a recorded match). Together they cover the full singleplayer toolset: save to persist and resume a live campaign, share to hand that position to a friend, and replay + takeover to study and re-run a finished game. The decision is almost always the same question asked one way — do I want to keep playing this (save/share) or study and re-run that (replay/takeover) — and v0.36 gives you a first-party answer for the first of those two, which is the one the community had been working around with temporary links and recordings for a long time. If you are new to the singleplayer side of the game and not yet sure which tool to reach for, start with the save loop, because it is the one that changes a long solo campaign from a gamble into something you can stop, finish, and share.
Related content
Use OpenFront v34.3 costs, troop growth, route payback, and stop signals to choose City, Port, Factory, defense, or a liquid reserve without copying a fixed script.
- OpenFront AFK Teammate Takeover: Absorb a Disconnected Ally for Zero Troop Loss
A Team-mode decision guide for what a teammate's disconnect does to your win/loss position, when absorbing their land is free, when it is a trap, and what the 30-second mark and the ranked 2v2 rules actually change.
Sep 23, 2026
- How Nations Aim Their Nukes: Smarter Targeting, No Wasted Blasts
A strategy guide for the upcoming AI Nation nuke targeting change: Nations now compute how much of a blast hits enemy land before firing (atom 25%, hydrogen 40% minimums), they skip a spot where another player's nuke is already landing, and they never nuke a target that would hit friendly land. What changes in your decision, the coverage gate, the anti-double-nuke rule, the failure mode and the mode/map adjustments.
Oct 8, 2026
- Alliance-Break Timing: When 30 Seconds Is Worth the Trade
Decide whether to break a live alliance now, wait for it to expire, or renew it, using the 30-second traitor window, the 0.5 defense and 0.8 speed debuffs, and the -100/-40 relation drops in OpenFront v0.34.
Sep 30, 2026