Free cloud gaming has one quiet failure mode that no start screen warns you about. You play two hours on a borrowed remote PC, close the tab, and the next session opens an older save. The fix is not a better connection. It is knowing where each game keeps its progress, and proving that the sync worked before you trust it with a 40-hour run.
This tutorial builds a small Python audit tool that takes a snapshot of your Steam Cloud save folders before and after a cloud session, then tells you in plain text whether anything changed. If you are still choosing a service, the four-platform free cloud gaming setup guide covers the accounts first. Here we assume you can already log in to at least one service and want your progress to follow you.
The whole job is short and broken into clear steps. You end with one compact script, a games list, a baseline snapshot, a verified round trip in both directions, and a habit that costs thirty seconds per session. Every output example below comes from a real run of the script against a test folder with made-up game data, so you can compare your own results line by line.
Don’t miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
Add Now
What Free Cloud Gaming Does With Your Saves
A cloud gaming service does not stream a video of a game that lives on your machine. It runs the game on a remote computer, and your keyboard or controller input travels there. That remote computer has its own disk, its own store client, and its own idea of who you are. Your local PC knows nothing about it unless some account in the middle moves the files.
That middle layer is almost always a store account. When a game supports Steam Cloud, the Steam client on the remote machine downloads your latest save before the game starts and uploads changes after you quit. The same logic applies to Epic’s cloud saves and to Microsoft account saves for Xbox titles. The cloud gaming service is only the delivery truck. The store account is the warehouse.
Free tiers add pressure to this system. Sessions are capped, queues can be long at peak hours, and a session that ends on a timer gives a game very little time to finish an upload. If you want the background on how the free tier of one big service ties into Steam libraries, the GeForce NOW free tier and Steam setup walkthrough explains the account link in detail. Plan limits change often, so check each service’s own membership page for current session lengths and queue rules before you build habits around them.
Three things can go wrong, and the audit tool catches all three. First, the game has no cloud save support, so progress stays on whichever machine you played on. Second, cloud sync is switched off for that game, usually by an old per-game toggle. Third, the upload never finished because the session ended early. In every case the symptom is the same: you open the game somewhere else and find yesterday’s progress.
Prerequisites and Versions
You do not need a powerful machine. The tool reads folder metadata and never touches the save contents, so it runs on an old laptop or a Chromebook with Linux enabled. The table lists what to have ready.
| Requirement | Version or detail | Why you need it |
|---|---|---|
| Python | Not listed | Runs the audit script, which uses only the standard library |
| Steam client | Current stable release, signed in | Creates the userdata folders and handles cloud sync locally |
| Operating system | Windows 11, Linux, or macOS | The script auto-detects the usual Steam folder on each |
| Cloud gaming account | Any free tier that lets you link a Steam library | Provides the remote session you will test |
| Test game | One with a small save and a Steam Cloud notice on its store page | Keeps each round trip short |
| Disk space | Under 50 MB for snapshots and one zip backup | Snapshots are small JSON files |
| Time | Not listed | Most of it is one short cloud session and two syncs |
Open a terminal and confirm Python before anything else. On Windows use the command prompt or PowerShell, and on Linux or SteamOS use any terminal.
python3 --version
# Windows may need: py -3 --versionIf the command prints a version number, you are set. An older version may fail on some syntax in later steps, so update first.
Which Saves Sync Where
Before you audit anything, sort your games by where their progress actually lives. This table is the mental model for the rest of the tutorial. It describes typical behavior, and individual games can differ, so treat the store page as the final word for any single title.
| Save type | Where it lives | Follows you to a cloud session? | How to check |
|---|---|---|---|
| Steam Cloud or Auto-Cloud | Steam servers, mirrored in the userdata folder | Yes, if the cloud service launches the game through your Steam account | This tutorial’s script |
| Steam game without cloud support | A local folder on whichever machine you played | No | Store page lacks the Steam Cloud notice |
| Epic cloud saves | Epic servers, per game | Yes, when the game supports it and you are signed in to Epic on the remote machine | Epic launcher sync message |
| Microsoft account saves (Xbox titles) | Xbox servers | Yes, for titles that share saves between cloud and PC | Resume the game on a second device |
| Publisher accounts (Ubisoft, EA, Riot and similar) | Publisher servers | Usually, but you must sign in again on each remote machine | Check the publisher launcher |
| Mod or custom saves | Local folders you manage | No | Back up by hand |
The script in this tutorial audits the Steam rows only, because Steam is the one store that leaves a readable mirror of cloud files on your local disk. For the other stores, the habit still works: change something small in the game, quit cleanly, open the game on a second device, and confirm the change arrived.
Each service also treats your library differently. Some let you stream only games they have installed on their servers, and some let you bring games you own. The Luna, GeForce NOW and Xbox Cloud Gaming comparison lays out those library models side by side. Save behavior follows the library model, so read it before you assume your Steam saves apply.
Phase 1: Link Accounts and Switch On Sync (Steps 1-4)
The first four steps involve no code. They make sure the plumbing exists, because a perfect audit script cannot repair a game that never uploads.
Step 1: Choose One Store as the Source of Truth
List the games you plan to stream for free and write down which store sells each one. For this tutorial, pick a single game that you own on Steam and that shows a Steam Cloud notice in its store page sidebar. A small indie game with a tiny save makes the best test because sync finishes fast. Avoid your longest-played favorite until the process is proven.
Write down the game’s app ID too. It is the number in the web address of the Steam store page, and it also names the folder the script will read. You will need it in Step 6.
Step 2: Turn On Steam Cloud on Your Local PC
In the Steam client open Settings, then Cloud, and make sure the option to enable Steam Cloud synchronization for supported applications is checked. Then right-click your test game in the library, choose Properties, stay on the General tab, and confirm the per-game option to keep saves in the Steam Cloud is on.
Old accounts often have a per-game toggle switched off from years ago, for example to stop a conflict prompt. That single checkbox explains a large share of “my cloud save is gone” complaints. Fix it now, launch the game once locally, and quit through its menu so Steam uploads the current state.
Step 3: Link Your Steam Account on the Cloud Service
Sign in to your chosen free service in a browser and find its account or library connection page. Connect the same Steam account you used in Step 2. Services that support bringing your own library usually ask you to sign in to Steam on a remote machine at the first launch, and some ask again at the start of each fresh session, depending on how they store credentials.
If you use a Microsoft-based service instead, the link is your Microsoft account, and the relevant save system is the Xbox one from the table. The audit script will not see those files, but the later cloud session steps still apply as a manual test. For plan differences that affect library access, the GeForce NOW membership tier breakdown shows what the free level does and does not include.
Step 4: Create the Working Folder
Make a folder for the project and move into it. Keep it outside the Steam directory so a Steam update or reinstall never touches your tools or snapshots.
mkdir savesync
cd savesync
python3 --versionOn Windows, run the same commands in PowerShell and swap python3 for py -3 if the first form is not found. Leave this terminal open. Every remaining step runs from this folder.
Phase 2: Build the Save Audit Script (Steps 5-9)
The script has four commands: scan, snapshot, diff and backup. Each step below adds one piece and explains the choice behind it. The full file appears in the assembled project section, so you can either type along or paste it once.
Step 5: Find Your Steam userdata Folder
Steam stores per-account data under a folder named userdata, with one numeric subfolder per Steam account on that machine. Inside each, every game gets a folder named after its app ID. Cloud-synced files sit in a remote subfolder of that game folder. The usual locations are below.
# Windows
C:\Program Files (x86)\Steam\userdata
# Linux and SteamOS Desktop Mode
~/.local/share/Steam/userdata
# Linux with the Flatpak build of Steam
~/.var/app/com.valvesoftware.Steam/.local/share/Steam/userdata
# macOS
~/Library/Application Support/Steam/userdataOpen the folder in your file manager and confirm you see at least one numeric subfolder. If Steam lives on a second drive, your path will differ, and that is fine because the script accepts a --root option. The script tries the four defaults above in order and uses the first one that exists.
Step 6: Create the Games List
Folders named with bare numbers tell you nothing at a glance. A small JSON file maps each app ID to a readable name. Create games.json next to the script and add the games you care about. Unknown IDs still appear in reports as “unknown”, so a partial list works.
{
"1245620": "Elden Ring",
"413150": "Stardew Valley",
"570": "Dota 2"
}Use the IDs from your own library. The three above are only sample entries that the demonstration folder uses. Keep each ID as a quoted string, since folder names are strings and the script looks them up as text.
Step 7: Write the Scan Function
The scan walks each account folder, then each app folder, and reads only file counts, sizes and modification times from the remote subfolder. It never opens a save file, which keeps the tool safe to run while a game is open. The core loop looks like this.
def scan(root, names):
rows = []
for user in sorted(p for p in root.iterdir() if p.is_dir() and p.name.isdigit()):
for app in sorted(p for p in user.iterdir() if p.is_dir() and p.name.isdigit()):
remote = app / "remote"
files = [f for f in remote.rglob("*") if f.is_file()] if remote.is_dir() else []
newest = max((f.stat().st_mtime for f in files), default=0)
rows.append({
"user": user.name,
"appid": app.name,
"name": names.get(app.name, "unknown"),
"files": len(files),
"bytes": sum(f.stat().st_size for f in files),
"newest": newest,
})
return rowsTwo design choices matter here. The isdigit() filter skips helper folders that Steam also keeps in userdata, such as a shared config folder. The default=0 on the newest timestamp means an app with no cloud files reports “never” instead of crashing on an empty list.
Step 8: Add Snapshot and Diff
A snapshot is the scan result saved as JSON. A diff compares two snapshots and reports what changed. This pair is the heart of the tool, because it turns “I think it synced” into a yes or no. The diff exits with code 1 when nothing changed, which lets a script or scheduled task react to a failed sync.
def cmd_diff(a):
old = {(r["user"], r["appid"]): r for r in json.loads(Path(a.before).read_text())}
new = {(r["user"], r["appid"]): r for r in json.loads(Path(a.after).read_text())}
changed = 0
for key, r in sorted(new.items()):
o = old.get(key)
if o is None:
print(f"NEW {r['appid']:<9}{r['name']}: {r['files']} files")
changed += 1
elif (o["files"], o["bytes"], o["newest"]) != (r["files"], r["bytes"], r["newest"]):
print(f"CHANGED {r['appid']:<9}{r['name']}")
changed += 1
if not changed:
print("No cloud save changes between snapshots.")
sys.exit(1)The comparison uses three fields together: file count, total bytes and newest modification time. A save that overwrites itself with the same size still changes its timestamp, so the tuple catches it. A pure checksum would catch even more, and the advanced tips section shows how to add one.
Step 9: Add the Backup Command
Never test sync on a save you cannot afford to lose. The backup command zips every file under any remote folder into a timestamped archive. Run it before each experiment and you can always roll back, even if a conflict prompt picks the wrong side.
def cmd_backup(a):
root = find_root(a.root)
stamp = time.strftime("%Y%m%d-%H%M%S")
out = Path(a.dest).expanduser()
out.mkdir(parents=True, exist_ok=True)
target = out / f"steam-cloud-saves-{stamp}.zip"
count = 0
with zipfile.ZipFile(target, "w", zipfile.ZIP_DEFLATED) as z:
for f in root.rglob("*"):
if f.is_file() and "remote" in f.relative_to(root).parts:
z.write(f, f.relative_to(root))
count += 1
print(f"backed up {count} files -> {target}")Save the finished script as savesync.py. If you did not type each function, copy the full listing from the assembled project section below. Then run a first scan to confirm the folder is found.
python3 savesync.py scanPhase 3: Run a Real Cloud Session Test
Now the script meets a real service. The method is a controlled experiment. Change one thing, record the state before and after, and let the diff decide. Steps 10 and 11 test cloud to local. The remaining steps test the other direction. If you also want to see how latency or data use behaves during the same session, the Python lag test for free cloud gaming and the data use tracker run alongside this one without conflict.
Step 10: Take the Baseline Backup and Snapshot
Close the test game on your local PC, and let Steam finish any sync it shows in the status area. Then back up and snapshot. The backup is your safety net, and the snapshot is your “before”.
python3 savesync.py backup ./backups
python3 savesync.py snapshot before.json
python3 savesync.py scanRead the scan output. Your test game should show at least one file and a recent “newest save” age. If it shows zero files, the game either has no cloud support or sync is off. Go back to Step 2 before continuing.
Step 11: Play a Short Session in the Cloud
Start a session on your free cloud gaming service, launch the test game, and make one unmistakable change. Start a new character, buy one cheap item, or move a slider in a way you will recognize. Then quit the game through its own menu, not by closing the browser tab or letting the session timer kill it.
After the game exits, leave the session open for a minute or two so the remote Steam client can finish uploading. Then end the session from the service’s own menu. Free tiers often reclaim the machine fast once you leave, and an upload cut off by a timer is the single most common cause of lost progress.
Step 12: Pull the Save Back and Run the Diff
Back on your local PC, open Steam in online mode and watch the status bar for a cloud sync notice. Do not launch the game yet, because launching triggers a download and you want to observe it cleanly. Wait until the sync indicator settles, then snapshot and compare.
python3 savesync.py snapshot after.json
python3 savesync.py diff before.json after.jsonA CHANGED line for your test game means the cloud session wrote to Steam Cloud and your local copy pulled it down. A “No cloud save changes” message means the chain broke somewhere. Jump to the troubleshooting section and work through the list from the top.
Test the Reverse Direction
Sync that works one way can still fail the other. Launch the game locally, make a second recognizable change, and quit through the menu. Let Steam upload, then start a new cloud session and check that the game opens with your local change intact.
This round trip is the real acceptance test. If both directions pass, the setup is trustworthy for that game. Repeat the forward and reverse tests for each title you care about, since support varies per game, not per service. After the first full pass, a future check takes about two minutes.
Example Output: What Good and Bad Runs Look Like
These outputs come from a real run against a test folder built for this article. The game names are sample entries and the file contents are dummy text, but the formatting is exactly what the script prints. Your own numbers will differ.
A healthy baseline scan shows one row per app folder, sorted with the newest save first. Notice how the script flags both a stale folder and one with no cloud files at all.
APPID GAME FILES KB NEWEST SAVE
1245620 Elden Ring 1 0.0 0.0h ago
413150 Stardew Valley 1 0.0 0.0h ago
570 Dota 2 1 0.0 45.0d ago <- stale
999 unknown 0 0.0 never <- no cloud files
4 app folders scannedA successful diff after a cloud session lists the game that changed, with file counts and byte totals before and after. In this sample, a second save file appeared and the first one grew.
$ python3 savesync.py diff before.json after.json
CHANGED 1245620 Elden Ring: files 1->2, bytes 5->16, newest 0.0h ago
$ echo $?
0A failed sync produces the opposite: no lines of change, a plain warning, and exit code 1.
$ python3 savesync.py diff before.json same.json
No cloud save changes between snapshots. If you played in between, the save did not sync.
$ echo $?
1The backup command prints how many files it zipped and where the archive went. On the test tree it found four files, including one nested inside a subfolder, which confirms the recursive search works.
backed up 4 files -> backups/steam-cloud-saves-20261031-233448.zipThe Complete Project, Assembled
Here is the full working file. Save it as savesync.py in your project folder, keep games.json beside it, and you have the entire tool. It uses only the Python standard library, so there is nothing to install.
#!/usr/bin/env python3
"""savesync: audit Steam Cloud save folders before and after a cloud gaming session."""
import argparse, json, os, sys, time, zipfile
from pathlib import Path
DEFAULT_ROOTS = [
Path(os.environ.get("PROGRAMFILES(X86)", "C:/Program Files (x86)")) / "Steam" / "userdata",
Path.home() / ".local/share/Steam/userdata",
Path.home() / ".var/app/com.valvesoftware.Steam/.local/share/Steam/userdata",
Path.home() / "Library/Application Support/Steam/userdata",
]
def find_root(arg):
if arg:
p = Path(arg).expanduser()
if p.is_dir():
return p
sys.exit(f"error: {p} is not a directory")
for p in DEFAULT_ROOTS:
if p.is_dir():
return p
sys.exit("error: no Steam userdata folder found, pass --root")
def load_names(path):
if path and Path(path).is_file():
return json.loads(Path(path).read_text(encoding="utf-8"))
return {}
def scan(root, names):
rows = []
for user in sorted(p for p in root.iterdir() if p.is_dir() and p.name.isdigit()):
for app in sorted(p for p in user.iterdir() if p.is_dir() and p.name.isdigit()):
remote = app / "remote"
files = [f for f in remote.rglob("*") if f.is_file()] if remote.is_dir() else []
newest = max((f.stat().st_mtime for f in files), default=0)
rows.append({
"user": user.name,
"appid": app.name,
"name": names.get(app.name, "unknown"),
"files": len(files),
"bytes": sum(f.stat().st_size for f in files),
"newest": newest,
})
return rows
def fmt_age(ts):
if not ts:
return "never"
days = (time.time() - ts) / 86400
return f"{days:.1f}d ago" if days >= 1 else f"{days * 24:.1f}h ago"
def cmd_scan(a):
rows = scan(find_root(a.root), load_names(a.names))
print(f"{'APPID':<9}{'GAME':<28}{'FILES':>6}{'KB':>9} NEWEST SAVE")
for r in sorted(rows, key=lambda r: -r["newest"]):
flag = ""
if r["files"] == 0:
flag = " <- no cloud files"
elif a.stale_days and (time.time() - r["newest"]) / 86400 > a.stale_days:
flag = " <- stale"
print(f"{r['appid']:<9}{r['name'][:27]:<28}{r['files']:>6}{r['bytes'] / 1024:>9.1f} {fmt_age(r['newest'])}{flag}")
print(f"\n{len(rows)} app folders scanned")
def cmd_snapshot(a):
rows = scan(find_root(a.root), load_names(a.names))
Path(a.out).write_text(json.dumps(rows, indent=2), encoding="utf-8")
print(f"snapshot saved: {a.out} ({len(rows)} apps)")
def cmd_diff(a):
old = {(r["user"], r["appid"]): r for r in json.loads(Path(a.before).read_text())}
new = {(r["user"], r["appid"]): r for r in json.loads(Path(a.after).read_text())}
changed = 0
for key, r in sorted(new.items()):
o = old.get(key)
if o is None:
print(f"NEW {r['appid']:<9}{r['name']}: {r['files']} files")
changed += 1
elif (o["files"], o["bytes"], o["newest"]) != (r["files"], r["bytes"], r["newest"]):
print(f"CHANGED {r['appid']:<9}{r['name']}: files {o['files']}->{r['files']}, "
f"bytes {o['bytes']}->{r['bytes']}, newest {fmt_age(r['newest'])}")
changed += 1
if not changed:
print("No cloud save changes between snapshots. If you played in between, the save did not sync.")
sys.exit(1)
def cmd_backup(a):
root = find_root(a.root)
stamp = time.strftime("%Y%m%d-%H%M%S")
out = Path(a.dest).expanduser()
out.mkdir(parents=True, exist_ok=True)
target = out / f"steam-cloud-saves-{stamp}.zip"
count = 0
with zipfile.ZipFile(target, "w", zipfile.ZIP_DEFLATED) as z:
for f in root.rglob("*"):
if f.is_file() and "remote" in f.relative_to(root).parts:
z.write(f, f.relative_to(root))
count += 1
print(f"backed up {count} files -> {target}")
def main():
p = argparse.ArgumentParser(description=__doc__)
p.add_argument("--root", help="Steam userdata folder (auto-detected if omitted)")
p.add_argument("--names", default="games.json", help="JSON map of appid to game name")
sub = p.add_subparsers(dest="cmd", required=True)
s = sub.add_parser("scan"); s.add_argument("--stale-days", type=float, default=30); s.set_defaults(fn=cmd_scan)
s = sub.add_parser("snapshot"); s.add_argument("out"); s.set_defaults(fn=cmd_snapshot)
s = sub.add_parser("diff"); s.add_argument("before"); s.add_argument("after"); s.set_defaults(fn=cmd_diff)
s = sub.add_parser("backup"); s.add_argument("dest"); s.set_defaults(fn=cmd_backup)
a = p.parse_args()
a.fn(a)
if __name__ == "__main__":
main()
The final layout is small. Keep snapshots with dates in their names if you want a history, and keep the backup archives somewhere with space.
savesync/
savesync.py
games.json
before.json
after.json
backups/
steam-cloud-saves-20261031-233448.zipThe command summary is short enough to memorize: scan to look, snapshot FILE to record, diff A B to compare, and backup DIR to protect. Add --root before the command name when your Steam folder is in a non-default place, and --names to point at a different games list.
Common Pitfalls With Free Cloud Gaming Saves
Most lost progress traces back to a handful of habits. Each of these has burned players who did everything else right.
- Closing the tab instead of quitting the game. The game never gets to write its final save, and the store client never gets a clean exit to upload. Always leave through the game menu first, then end the session.
- Ending the session the moment the game closes. Upload takes time. Give the remote client a minute or two, longer for large saves, before you hand the machine back.
- Trusting a service because the game launched. A game can start fine and still run without cloud sync, for instance when you signed in to the store with a different account than the one holding your progress.
- Playing offline locally, then streaming. Steam in offline mode keeps changes on disk and uploads later. If you start a cloud session in between, the remote machine sees the old save and may overwrite the newer one when the conflict is resolved the wrong way.
- Assuming all your games sync. Support is per game. A launcher full of titles can include several with no cloud saves at all, and the scan flags those with the “no cloud files” note.
- Skipping the backup. The first conflict prompt is the dangerous one, because players click through it quickly. A zip made two minutes earlier turns a disaster into an annoyance.
- Testing on a Chromebook or locked-down laptop without checking the browser. Streaming works there, but the audit script needs a real Python install. The guide to free cloud gaming on a Chromebook, TV or old laptop shows which devices stream well and which need a second machine for the audit.
Troubleshooting: 10 Fixes When the Diff Says Nothing Changed
Work through these from the top. They are ordered from most common cause to least common, and most problems end by the fourth item.
- The script cannot find userdata. It prints “no Steam userdata folder found”. Pass the path directly with
--root, for examplepython3 savesync.py --root "D:\Steam\userdata" scan. - Every game shows zero files. Steam Cloud may be off globally. Reopen Settings, then Cloud, and enable synchronization, then restart Steam.
- Only the test game shows zero files. Check its per-game cloud toggle in Properties, and confirm the store page lists Steam Cloud. Some games keep saves in a path Steam does not mirror.
- The diff shows no change after a cloud session. The upload probably did not finish. Repeat Step 11 and wait longer before ending the session.
- The diff shows no change, but the game clearly updated in the cloud. You may have signed in to a second Steam account. Look for more than one numeric folder under
userdata, and check that the cloud service uses the same account as your local client. - Steam shows a sync conflict dialog. It asks which version to keep. Choose the one with the later timestamp that matches your last real session, and keep the backup from Step 10 until you confirm the game loads correctly.
- Steam is stuck on “syncing” or “pending”. Check your connection, then restart the client. A firewall or VPN that blocks Steam’s servers can stall uploads on both machines.
- Dates in the scan look wrong. Timestamps come from your system clock. A machine with a skewed clock reports misleading ages, so fix the time and re-run the scan.
- Permission errors on Linux or SteamOS. Run the script as the same user that runs Steam, and avoid
sudo. On the Flatpak build, use the Flatpak path from Step 5. - Python reports a syntax error. You are likely on an older Python version than the script needs, or a paste dropped an indent. Check the version, then compare against the full listing character for character.
If you have worked through all ten and the diff still reports no change, the game itself probably does not write cloud saves in a way Steam tracks. In that case, treat it as a local-save game and use the manual backup habit from the advanced tips below.
Advanced Tips for Power Users
Once the basic round trip works, a few upgrades turn the tool into a routine. None are required, and each one is worth adding only if the problem it solves has bitten you.
Add checksums. Change the scan to hash each file with hashlib.sha256 and store the combined digest per app. A checksum catches the rare case where a save changes content but keeps the same size and timestamp, and it makes the diff exact instead of heuristic.
import hashlib
def folder_digest(files):
h = hashlib.sha256()
for f in sorted(files):
h.update(f.name.encode())
h.update(f.read_bytes())
return h.hexdigest()Schedule the baseline. On Linux or SteamOS, a cron entry such as 0 22 * * * python3 ~/savesync/savesync.py backup ~/savesync/backups makes a nightly zip. On Windows, a daily scheduled job can run the same command. Prune old archives monthly so the folder does not grow without limit.
Cover non-Steam saves. The script reads Steam only. For games that keep saves in documents or app data folders, a dedicated open-source backup tool such as Ludusavi covers the usual locations for thousands of titles, and pairs well with this audit. Use the audit for Steam and the backup tool for everything else.
Mirror the backups off the machine. Point a sync tool such as Syncthing or rclone at the backups folder, so a dead disk does not take your safety net with it. If you already stream from your own hardware through a home server, the Sunshine, Moonlight and Tailscale self-hosted setup removes the question entirely, since the game and the save live on your own PC.
Use the Steam Deck. Desktop Mode gives you a normal terminal and the Linux path from Step 5, so the audit runs directly on the handheld. Linux users on a regular PC can pair this with the GeForce NOW Linux setup on Ubuntu, which covers the browser side of the same workflow.
Build a Free-Tier Save Routine That Holds Up
Tools help, but habits decide whether progress survives. Free tiers push you toward short, queue-limited sessions, and that rewards a routine you can run half asleep. The version below takes about thirty seconds on each end.
Before a cloud session, close Steam games locally, let the status bar settle, and take a snapshot. During the session, play, quit through the menu, and wait before leaving. After the session, open Steam locally, let it sync, snapshot again, and run the diff. A CHANGED line means you are safe. Anything else means stop and look before you play further.
Pick a session budget that leaves room for the exit. If a service gives you a fixed block of play time, stop a few minutes early and treat the last minutes as upload time. Queue waits make this tempting to skip, because you spent real time getting in, but a lost evening costs more than a short session. The broader gaming section has more setup guides for handhelds, consoles and emulators if you build a multi-device routine.
Keep a short notes file next to the script with one line per tested game: the app ID, which services you verified, the date, and any quirks. Players who skip this rediscover the same quirks every few months. A game that passed in October may behave differently after a publisher patch, so recheck after major updates.
How a Session Ends and What the Game Gets to Do
The order of events at the end of a session decides whether your save survives. A clean exit follows a fixed sequence. You quit through the game menu, the game writes its save file to disk, the store client notices the changed file, and the client uploads it to the store’s servers. Only after the upload completes is the remote machine safe to release.
A forced exit breaks that sequence at different points. Closing the browser tab drops the stream, but the remote game may keep running for a short while before the service tears the session down. An expiring session timer is harsher, since the service reclaims the machine on its own schedule and gives the upload no extra time. Either way, the file might sit on a disk that is about to be wiped, with the upload still unfinished.
Games also differ in when they write. Some write continuously, so a crash costs you a few seconds. Others write only at checkpoints or when you manually save, and quitting between checkpoints loses everything since the last one. The audit tool cannot fix that, but it does show you the timestamp of the last file the game wrote, which tells you whether your session left any trace at all.
One more detail trips up careful players. Steam keeps a small record next to each game’s saves that tracks what it last synced, so it can detect which side changed. If you edit saves by hand or restore a zip while Steam is running, that record can disagree with the files, and Steam may raise a conflict. Close Steam fully before you restore any backup, then reopen it and let it settle.
Reading Your Results: What Each Outcome Means
The scan and diff produce a short list of outcomes, and each one points to a specific next move. Use this table the first few times, until the patterns feel familiar.
| What you see | What it usually means | Next move |
|---|---|---|
| CHANGED line after a cloud session | The remote upload finished and your local client pulled it | Run the reverse test from the previous step |
| “No cloud save changes” after playing | The upload was cut off, or the accounts differ | Repeat with a longer wait, then compare account folders |
| “no cloud files” on a game you play | No cloud support, or the per-game toggle is off | Check Properties and the store page, then back up by hand |
| “stale” on an active game | You play it elsewhere, or sync stopped weeks ago | Launch it locally once and rescan |
| NEW line for an unfamiliar app ID | The cloud session created a folder for a game you had not synced before | Add the ID to games.json so reports stay readable |
| Exit code 1 from diff in a scheduled job | A sync check failed unattended | Open Steam and review the last session before playing again |
Treat a single failure as data, not a verdict. Networks hiccup and uploads retry. Two failures in a row on the same game, with proper waits, point to a real configuration problem. A pass in both directions, repeated once on a different day, is as close to proof as a home setup gets.
Frequently Asked Questions
Do free cloud gaming services keep my saves?
Usually the store account keeps them, not the service. When a game supports Steam Cloud, Epic cloud saves or Microsoft account saves, progress follows the linked account. Games without cloud support keep saves on the remote machine, which a free tier may wipe after the session ends.
How do I know if a game supports Steam Cloud?
Look for the Steam Cloud notice in the sidebar of the game’s Steam store page. You can also run the scan from this tutorial. A game with files under its remote folder after you play it is syncing.
Can the script damage my saves?
No. It only reads file sizes, counts and timestamps, and the backup command writes a new zip without changing the originals. It never opens or edits a save file.
Does this work for Xbox Cloud Gaming?
The script cannot see Microsoft account saves, because they do not leave a readable mirror on your disk. The manual round trip still works. Change something in the game, quit cleanly, and check the other device.
Why does the diff report no change after I played for hours?
The most likely causes are an upload cut off when the session ended, a different Steam account on the remote machine, or a game with no cloud support. The troubleshooting list above covers each case in order.
Is it safe to sign in to Steam on a remote cloud machine?
Use the same precautions as any shared environment. Enable Steam Guard, sign out when the session ends if the service lets you, and never reuse a password from another site. Read the service’s privacy page to see how it stores linked credentials.
How often should I run the audit?
Run the full before-and-after check for every new game, then again after major game updates or service changes. For games already proven, a quick scan once a week catches stale folders early.
