A rewind button for your game saves

The idea

A background service that watches the save directories of every game you own and commits a snapshot every time one changes. Instead of one overwritten autosave, you get a scrollable timeline per game: "Tuesday 9:41pm, 3 hours before you sold the wrong artifact." Pick a point, restore it, keep playing. The same snapshot store doubles as sync, so the timeline follows you between your desktop and your laptop.

Why build this

Modern games have quietly removed the ability to undo. Single-save-slot design, aggressive autosave, and cloud save that silently overwrites the local copy mean a mistake made an hour ago is permanent — a wasted skill point, a botched dialogue branch, a corrupted file after a crash. Players work around this by manually zipping save folders, which nobody keeps up for long.

The technical pieces are all sitting there now. Save locations for thousands of games are already mapped in community-maintained manifests. Content-addressed storage makes a snapshot-per-write cheap, because saves are small and mostly-identical between writes. Filesystem watching is a solved problem on all three desktop OSes. What's missing is something that assembles them into an app your non-technical friend can install and forget about.

Stack sketch

• Tauri (Rust core, web frontend) — small binary, native filesystem access, ships to Windows/macOS/Linux from one codebase. Windows is the priority target.
• notify crate for debounced filesystem watching; games write saves in bursts, so coalesce events over a 5-second window before snapshotting.
• Game detection: parse steamapps/libraryfolders.vdf and appmanifest_*.acf for installed Steam titles, plus the Ludusavi save-path manifest (MIT-licensed YAML) to resolve each title's actual save directory across platforms.
• Storage: content-addressed blob store — SHA-256 per file, zstd compression, hard-linked dedup. A snapshot is a JSON manifest of path → hash. Thousands of snapshots of a 2MB save cost a few hundred megabytes.
• Index: SQLite via rusqlite for snapshot metadata, playtime correlation, and search.
• Sync (optional): rclone-compatible remote or any S3 API — Backblaze B2 is the cheap default. Sync the blob store and manifests; the format is already deduplicated, so uploads stay small.
• UI: a timeline per game, with snapshots annotated by wall-clock time, session boundaries, and file size deltas.

Scope for v1

In: - Steam library detection on Windows, save-path resolution from the community manifest, and a manual "add game folder" fallback. - Automatic snapshot on save-file change, with retention (keep everything from the last 48 hours, then hourly for a week, then daily). - Timeline UI, restore-to-point, and an automatic pre-restore snapshot so restoring is itself undoable. - Pause-per-game toggle and a global disk budget.

Out: - Cloud sync. Ship local-only first; the storage format should be sync-ready but the network layer can wait. - Console and mobile saves. - Any parsing or editing of save contents. Snapshots are opaque bytes. - Non-Steam launchers (Epic, GOG, Xbox) beyond the manual folder path.

Where it could go

The obvious next step is sync, and it's the feature that turns a utility into a subscription: your timeline available on every machine, with the client resolving conflicts by keeping both branches rather than picking a winner. Charge for hosted storage, keep bring-your-own-bucket free.

After that, annotation. A snapshot timestamp is a weak label; what players actually want is "before the point of no return." Correlating snapshots with screenshots the game already writes, or with achievement unlock timestamps from the Steam API, gives each point on the timeline a recognizable name. A further step is shared save states — a curated timeline someone else publishes at a specific chapter, so a friend can jump straight to the fight that keeps killing them.

Watch out for

Cloud save is the real adversary: restore an older file locally and Steam Cloud may cheerfully overwrite it with the newer remote copy on next launch, or throw a conflict dialog the user resolves the wrong way. You have to detect cloud-enabled titles and walk the player through disabling per-game sync — get this wrong once and the app looks like it ate their progress. Also stay well clear of multiplayer titles with anti-cheat; touching those save directories is a ban risk, so keep an explicit blocklist.