Active development

Game Save
Manager.

A .NET 10 desktop application for discovering Steam games and profiles, resolving known save locations, and moving save data through workflows designed to be previewable, reversible and auditable.

My role
Independent developer
Current phase
Interface revamp
Platform today
Windows
Stack
.NET 10 · Avalonia · SQLite

The problem

Save files are valuable and inconsistent

PC games store saves across Steam userdata, documents, AppData, installation directories and custom locations. Players often only discover that complexity when moving between profiles or recovering from data loss.

Game Save Manager turns those inconsistent locations into a reviewed mapping system and a set of guarded workflows. The goal is not simply to automate file copying, but to make every action understandable before it runs and recoverable if something goes wrong.

Implemented application

A complete safety workflow, end to end

Three roadmap phases are complete: discovery and transfer, backup and restore, and sync through local folders, SFTP/SSH and Google Drive. Phase 04, the interface revamp, is what the gallery above shows.

01

Steam discovery

Finds the Steam installation, additional libraries, installed games and local Steam profiles by reading registry and VDF data.

02

Safe profile transfer

Previews files before copying between Steam profiles, validates path containment, skips existing files by default and requires explicit confirmation.

03

Backup & restore

Creates manual and automatic backups with SHA-256 manifests, supports dry-run restore, presets, retention and self-contained ZIP export/import.

04

Provider-backed sync

Synchronises completed backup runs through local-folder, SFTP/SSH and Google Drive providers on one preview-and-execute contract, with connection checks, selectable plans, live progress and conflicts that are reported rather than silently resolved.

05

Dockable workspace

Every page is a set of sections that can be docked left, right, above or below the centre, resized, collapsed, floated into their own window, saved under a name and reset to the default arrangement.

06

Appearance & accessibility

Light, dark and system themes, five accents, Acrylic and Mica window materials, a navigation rail that docks left, right or top, reduced motion, High Contrast and a text scale from 85 to 150 per cent that reflows every layout.

Living save-path dataset

Turning public data into trusted mappings

The dataset is built continuously by fetching Steam AppIDs and harvesting save-location candidates primarily from PCGamingWiki, while manually researched paths can be added alongside them.

120k / ~ 170k

Steam AppIDs processed so far

5,978

Games with collected mappings

2,698

Mappings reviewed and approved

Current development snapshot. Approximately 70% of the target Steam AppID catalog has been processed; 5,978 of those entries currently have mapping data, and 2,698 mappings are approved for trusted application use.

Daily catalog mining

Automated harvesting processes roughly two thousand new catalog entries each day and records candidate paths with their provenance.

Two ways to grow

Mappings can also be added or corrected manually, so new titles are not limited to what an automated source can extract.

Review can broaden later

The project will keep supporting new releases. A future direction is letting additional trusted reviewers help approve the growing candidate queue.

From public clue to trusted path

Why the application needs a reviewed catalog

Steam identifies games, but it does not provide one dependable catalogue of where every title stores its save files. Public sources can suggest locations, yet those suggestions may be outdated, incomplete or written for a different operating system.

The pipeline therefore treats collected paths as candidates, not facts. Rule-based checks expand reusable path templates and flag repeatable problems, while human review handles ambiguity and decides which mappings are safe enough to approve. The application uses only those approved mappings when it prepares a backup or transfer preview, reducing the risk of selecting the wrong files or folders.

01

Collect game IDs

Steam AppIDs create the catalog queue and tell the pipeline which games still need save-location research.

02

Find possible paths

PCGamingWiki and manual research provide candidate save locations together with their source and context.

03

Review each candidate

Templates are expanded, ambiguous or unsafe paths are flagged, and every candidate receives a visible review state.

04

Use approved mappings

Approved paths let the app build clearer previews and target the intended save data during backup and transfer.

Design principles

Safety is an architectural requirement

Save files can represent hundreds or thousands of hours. Guardrails are part of the product, not warnings added at the end.

01

Copy, never move

Source saves are not deleted or modified during transfer or restore.

02

Preview first

Transfers, restores, sync and cleanup expose a dry run before execution.

03

Overwrite is opt-in

Existing files are skipped unless the user explicitly enables replacement.

04

Backup before overwrite

Safe Mode refuses an overwrite when its automatic backup cannot be completed.

05

Verify integrity

SHA-256 manifests identify missing or modified backup files before restore.

06

Keep an audit trail

SQLite history, manifests and per-file results record what every workflow did.

Architecture

A thin UI over explicit services

The shared core stays independent of Avalonia, SQLite, registry access, VDF parsing and filesystem details. Views bind to view models, while preview generation, containment checks, hashing, persistence and provider behavior live behind testable contracts.

GameSaves.Core

Platform-neutral models, contracts, sync plans and transfer rules. It defines what a safe operation means without knowing about Avalonia, SQLite or a particular filesystem.

Infrastructure

Concrete adapters for Steam discovery, registry and VDF parsing, SQLite, path expansion, backup, restore, history, and the local-folder, SFTP/SSH and Google Drive sync providers.

Avalonia App

A thin MVVM interface that coordinates explicit services, presents previews and confirmations, keeps provider-specific controls driven by declared capabilities, and hosts the dockable workspace, navigation rail and theme system.

CLI & Reviewer

Separate developer tools for catalog fetching, PCGamingWiki harvesting, verification and deliberate human approval of candidate mappings before the desktop app trusts them.

Phase 04 · in progress

Three providers shipped, the interface rebuilt around them

The provider abstraction is proven rather than promised: local or mounted folders, SFTP over SSH and Google Drive all run on one preview-and-execute contract, with copy-only conflict rules, named remote profiles, connection checks and auditable results. Google Drive brought interactive sign-in, protected locally stored authentication that Disconnect removes, and a managed backup folder scoped to files the application created itself. With that contract stable, Phase 04 rebuilds the interface on top of it: a dockable workspace with saved layouts, a navigation rail that docks left, right or top, five accents, Acrylic and Mica window materials, and an accessibility pass measured at four text sizes. Further synchronisation targets are being weighed against the same contract, not written yet.

Delivered

Local-folder, SFTP/SSH and Google Drive providers on one capability catalog, provider factory and remote-profile store, with selectable plans and conflicts reported rather than resolved.

In progress

The interface revamp: dockable regions with saved layouts, a rail that docks left, right or top, five accents, Acrylic and Mica, High Contrast, reduced motion and an 85–150% text scale.

Planned next

More synchronisation targets. WebDAV, OneDrive and others are being evaluated against the existing contract before any is committed to; cross-platform support follows.

Engineering lessons

What this project is teaching me

  1. 01Separating domain rules from infrastructure and UI makes safety-critical workflows easier to reason about and test.
  2. 02External data is not automatically trustworthy: scraped save paths need provenance, review states and verification before use.
  3. 03Destructive-adjacent operations need visible plans, explicit confirmation, containment checks and auditable outcomes.
  4. 04Backup design is more than copying files; manifests, hashes, history, retention and reversible restore all matter.
  5. 05Provider abstractions help introduce sync incrementally without coupling the core application to one cloud service - the third provider was the proof, not the plan.
  6. 06A growing dataset needs repeatable harvesting, deduplication and review workflows—not a one-time import script.
  7. 07Capturing every page at four text sizes, in both themes, against throwaway data found layout defects no manual pass had - and keeps personal paths out of every published screenshot.

Follow the dataset and application as they grow.

Open GitHub - opens in a new tab