🧞 Game Save Genie

Steam Cloud for the games that don't have it.

Automatic, versioned, self-hosted cloud save sync for PC games — Hydra and manual installs, GOG offline installers, repacks, anything a launcher isn't protecting. Your saves, your cloud, no subscription.

gamesavegenie website →

Why this exists

If you play games outside Steam/Epic/Xbox, nothing is protecting your saves. One corrupted file, one Windows reinstall, one "wait, which PC did I play on last?" and dozens of hours are gone. Paid save-sync services cap your history at a couple of backups and delete everything when you stop paying.

Game Save Genie runs quietly in the background and gives you what the launchers give their games:

• 🕹️ Knows 19,000+ games — save locations detected via the open-source Ludusavi database, plus process watching to know when you're playing
• 🎮 Emulators too — gsg add --path backs up any folder or file (RetroArch, PCSX2, Dolphin, memcards, save states), so games Ludusavi doesn't know are covered as well
• 💾 Backs up automatically — when a game closes, and every 10 minutes while it runs
• 🔔 Shows save health — the dashboard, gsg status, and tray distinguish protected, local-only, queued, paused, and failed saves; a healthy game never hides another game's failure
• 📶 Recovers from outages — failed uploads stay queued across restarts and retry automatically without another play session
• 🕰️ Every session is a version — immutable, checksummed snapshots; roll back to any point with gsg restore --version
• ☁️ Your own cloud — Google Drive (free 15 GB), OneDrive, any S3 bucket, or anything rclone speaks; version retention controls history, and delta uploads only send the save files that changed (an unchanged 40 MB slot is never re-uploaded)
• 🖥️ Follows you between PCs — gsg pull restores on any machine, remapping paths saved under a different username on Windows, Linux or macOS
• 🔒 Paranoid by design — downloads are verified before anything is touched, a safety backup is taken before every restore, restores never run while the game is, and a strictly-newer rule means offline progress is never clobbered

Steam/Epic/Xbox games are detected and skipped automatically — those launchers already sync their own saves.

Get started in 30 seconds

Windows installer (recommended): grab GameSaveGenie-Setup.exe from Releases — per-user, no admin needed, adds gsg to your terminal, offers to run setup when done. Portable: gsg.exe from the same Releases page — no install at all. From source (Python 3.10+): pip install git+https://github.com/Vasanthdev2004/Game-Save-Genie

Then:

gsg

That's the whole setup. A wizard finds your games, connects your cloud (Google Drive/OneDrive open a browser — sign in, click Allow, done), and offers start-at-boot. From then on gsg auto protects everything, hands-free. Ludusavi and rclone are downloaded automatically on first use.

Once you're set up, running gsg again opens the dashboard — your games, every version, and a one-key restore. No ids to copy.

Example library in an 80-column terminal. Wider terminals show games and history side by side.

Homelab? Run your own save server with one docker compose up and connect it with gsg setup-s3 — see docker/README.md. Works with any S3-compatible store (MinIO, Garage, TrueNAS…), supports per-friend accounts, and your saves never leave your network.

Somewhere gsg can't run? The cloud layout is documented in CLOUD_FORMAT.md — content-addressed blobs plus a small JSON manifest per backup, reachable with rclone and sha256sum from a shell script. A handheld or NAS that writes that layout produces storage gsg understands and deduplicates against; a one-command restore from a device-written backup is not there yet (#43).

Status: single-machine backup on Windows is stable and used daily. Cross-machine sync (gsg pull) and Linux/Steam Deck support are beta — solid in testing, but not yet battle-tested across many real setups. Keep a second copy of anything precious for now, and please file an issue with anything you hit — that feedback is what moves it out of beta.

How it compares

	Game Save Genie	Ludusavi	Game Backup Monitor	Hydra Cloud	Syncthing DIY
Auto-backup on game close	✅	❌	✅	✅	➖ folder sync only
Periodic backup during play	✅	❌	✅	❌	➖
Automatic cloud restore	✅	❌ manual	⚠️ via a sync folder	❌	➖ no game awareness
Native cloud (direct, delta uploads)	✅	✅	❌ needs Dropbox etc.	✅ their servers	➖ folder sync
Cross-machine path remapping	✅	❌	❌	✅	❌
Version history	✅ per session	✅	✅	⚠️ 2 per game	❌ conflict files
Storage you own	✅	✅	⚠️ sync folder	❌ their servers	✅
Free	✅	✅	✅	❌ subscription*	✅

_{*Hydra Cloud is subscription-only, caps each backup at 500 MB and 2 versions per game, and deletes saves 7 days after a subscription ends. Game Backup Monitor is a solid tool that also auto-backs-up and auto-restores — its difference from Game Save Genie is cloud: "cloud" in GBM means pointing its backups at a separate folder-sync client (e.g. Dropbox), whereas Game Save Genie uploads directly to your own cloud/S3/self-hosted server with delta transfers, unlimited versions, and cross-machine path remapping. Comparison reflects mid-2026; check each project for current features. Ludusavi is a fantastic backup engine — Game Save Genie builds on it and adds the automation layer.}

Everyday commands

gsg auto                  # the only command most people need — watch + backup + restore
gsg auto --install        # start hidden at logon (per-user, no admin needed)
gsg ui                    # interactive dashboard: browse versions, restore by arrow key

gsg status                # per-game overview, storage meter, quota warning
gsg scan                  # what's installed (--source all to include Steam/Epic/Xbox)
gsg add "Elden Ring" --exe eldenring.exe    # track something manually
gsg add "RetroArch" --path ~/.config/retroarch/saves --path ~/.config/retroarch/states --exe retroarch
                            # emulator / custom folders — repeat --path as needed

gsg backup [game-id]      # back up now (--dry-run previews, changes nothing)
gsg retry [game-id]       # retry queued uploads now, or upload the latest local-only snapshot
gsg versions <game-id>    # local history      gsg cloud-list <game-id>  # cloud history
gsg restore <game-id> [--version ID]         # roll back to any local snapshot
gsg pull <game-id> [--version ID]            # restore from the cloud (any machine)
gsg pull --all            # catch this machine up on everything that's behind

gsg pause / resume <game-id>   # exclude/re-include a game
gsg remove <game-id> [--purge] # untrack (--purge deletes local + cloud saves)

Save health and offline recovery

Open gsg ui (or gsg status) to see each game's protection state, last backup, last recorded successful upload, and any failure with a next step. In the dashboard, u retries uploads for the selected game; b makes a backup. Health refreshes every five seconds without changing your selected restore point.

Press / to find a game, Enter to browse matches, and Esc to clear the search. Tab moves between panes; c switches local/cloud history, r restores the selected point after confirmation, and F5 reloads. Restore points show readable times, labels, and an explicit Safety kind for pre-restore copies; the confirmation still shows the full version ID. L toggles the activity log, which opens after an operation. Long health messages can be scrolled without hiding the game/history tables.

Protected means the latest local snapshot was successfully uploaded to the currently configured destination. It is local evidence of a completed upload, not a fresh check that the remote copy still exists. Older versions may have no recorded upload time.

gsg auto and gsg watch check the persistent upload queue every minute. Failures back off from one minute to at most one hour. Retrying uploads the original checksummed snapshot, even if the live save has since changed. No new game session is required. A watcher must be running for automatic retries; otherwise use gsg retry or the dashboard's u key.

• --no-cloud backups and pre-restore safety snapshots are never automatically queued. Explicitly retrying may upload the latest local-only regular snapshot.
• Paused or removed games are skipped. Queued uploads keep their original remote name and root; changing cloud settings does not silently redirect them.
• Pending snapshots are exempt from local retention until uploaded, so an extended outage can temporarily exceed max_versions and use more disk space.
• Damaged queued snapshots are retained and marked Needs attention, not repeatedly uploaded. Recover the original snapshot file from another copy, then use u or gsg retry to revalidate it. New healthy backups can still upload while an older snapshot is blocked.
• If another save operation is busy when a game closes, its automatic backup request survives restart and is retried before uploads or idle cloud restores.
• Games discovered by a periodic rescan get their first backup immediately.
• A separate writer lock serializes backup, upload, restore, and purge operations across the CLI, dashboard, and watcher. An idle watcher does not block them.

Restart any older watcher after upgrading so it participates in the new writer lock.

Playing on two machines

Run the same setup (same cloud account) on both PCs. Each machine backs itself up; newer cloud saves are pulled down at startup and while a game isn't running. gsg pull --all catches a machine up on demand.

The trust rules that make this safe:

1. Verify first — downloads are integrity-checked and staged before anything on disk changes; a bad download changes nothing.
2. Safety backup always — your current saves are snapshotted before every restore, and the restore aborts if that fails.
3. Strictly newer only — a restore only happens when the cloud is ahead of everything this machine has seen. Offline backups stay local and queued until an upload succeeds.
4. Never under a live game — if you're playing, you get a notification instead of a mid-session overwrite.
5. Usernames remapped — saves recorded under C:\Users\alice\... restore correctly for bob, both in Ludusavi's manifest and the backed-up file tree.

Configuration

gsg config shows everything; config lives at %APPDATA%\game-save-genie\Game Save Genie\config.yaml (Windows) or ~/.config/Game Save Genie/ (Linux).

Key	Default	Meaning
max_versions	10	Versions kept per game, locally and in the cloud
rclone_remote_name	–	rclone remote to upload through (set by the wizard)
remote_root	game-save-genie	Folder/bucket on the remote
storage_limit_gb	5.0	Warn in gsg status at 80% (0 = off)
backup_dir	<data>/backups	Local backup root
ludusavi_path / rclone_path	auto-download	Bring your own binaries

Cloud layout: each save file is stored once under its SHA-256 at <remote>:<remote_root>/<game-id>/blobs/<hh>/<hash>, and each version is a small JSON manifest at <game-id>/manifests/<version-id>.json listing that version's files. The manifest is uploaded last, so a version only becomes visible once all its data is there. That is what makes uploads incremental — an unchanged file is never re-sent. (Pre-0.3.0 versions are single zips and are still readable.)

FAQ

Is this safe for my saves? That's the whole design brief. Every restore is preceded by a verified download and a safety backup of your current state; any failure aborts cleanly rather than half-applying. The restore pipeline was built failure-first — see CHANGELOG.

Where do my saves live? In storage you own. Locally, each version is a plain zip of a Ludusavi backup tree that you can open with anything. In the cloud they are stored de-duplicated — file contents under their SHA-256, plus a readable JSON manifest per version — which is what keeps uploads incremental. No accounts, no servers of ours, no telemetry: gsg only ever talks to your configured remote and GitHub (to download the Ludusavi/rclone binaries).

What if I stop using it? Nothing expires and there is no subscription to lapse. Your local snapshots are plain zips of a Ludusavi backup tree, which Ludusavi can restore directly without gsg. The cloud copy is content-addressed, so rebuilding it by hand means following a manifest — plain JSON listing each file's path and hash. gsg is MIT-licensed and self-hosted, so there is no vendor to be cut off by.

Linux / Steam Deck? Beta, and testers are gold. The full pipeline runs on Linux: backup/restore/pull (with Wine-prefix handling), the process watcher, notify-send notifications, Steam detection (native/Deck/Flatpak paths), and gsg auto --install sets up a systemd user service (headless boxes: loginctl enable-linger $USER). What it needs now is real-world mileage — file an issue with anything you hit; see CONTRIBUTING.

Emulator saves? Games Ludusavi doesn't know? Covered since 0.4.0 — gsg add --path backs up any folder or file (RetroArch, PCSX2, Dolphin, memory cards, save states). Repeat --path as needed.

Project structure

src/game_save_genie/
  cli.py            # Typer CLI — all commands and orchestration
  ludusavi.py       # Ludusavi wrapper (scan/backup/restore)
  cloud.py          # rclone wrapper: upload/download/list/prune
  watcher.py        # process watcher (start/close/periodic/idle callbacks)
  sync.py           # pure restore-decision policy (unit-tested)
  remap.py          # cross-machine path remapping
  archive.py        # safe extraction, snapshot zipping, hashing
  database.py       # SQLite version + sync-state tracking
  health.py         # shared save-health status from local backup and upload evidence
  config.py         # config + tracked-games persistence
  launcher.py       # Steam/Epic/Xbox detection
  notify.py         # file logging + Windows toasts
  models.py         # Pydantic models

Development: pip install -e ".[dev]", then pytest, ruff check src tests, mypy src tests (strict). CI runs all three on Windows and Linux.

License

MIT. Built on the shoulders of Ludusavi and rclone — go star them too.

---

_{If Game Save Genie saved your save, a ⭐ helps other players find it.}