Save files are the one part of an emulation library you cannot download again. Emulator builds come back from the project sites, and game images and firmware come from dumps of hardware you own, but a 60-hour memory card or a Wii save lives in one folder on one drive. Ludusavi scans those folders, copies them into a tidy backup tree, and pushes the result to your own cloud through rclone. This tutorial takes 13 steps and about 45 minutes, and it ends with a scheduled PowerShell job that backs up six PC emulators every night.
Two version facts frame the setup. Ludusavi v0.31.0 is still the latest release on the project’s GitHub releases page as of October 26, 2026. For rclone, install 1.75.2, a security release published October 9, because versions 1.75.0 and 1.75.1 were affected by the vulnerabilities it fixes.
If you only play Pokémon, our Pokémon emulator save backup guide covers game-specific details such as battery saves. This article takes the wider view. Every emulator on the PC gets one backup tree, one cloud copy and one tested restore.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Ludusavi Does and What You Build in This Tutorial
Ludusavi is a save backup application, not an emulator, and it does not run as a background sync daemon. You point it at folders, it copies what it finds into a backup tree, and it restores that tree on request. Going by the project’s repository and release notes, it is free and open source with no paid plan, and it reportedly ships builds for Windows, Linux and macOS. The maintainer, mtkennerly, packs a graphical app and a command-line interface into the same program. The command line is what makes the scheduled job in this tutorial possible.
For retail PC games, Ludusavi relies on a manifest, a community-maintained list of save locations that it refreshes from the internet. Emulator saves are a different case. A Dolphin memory card or a PCSX2 card file belongs to the emulator rather than to a game install, so the manifest rarely knows where yours lives. The fix is the custom games feature. You name a folder, and Ludusavi treats it like any other game. Every emulator in this article uses that technique.
Why not drop the emulator folder into a synced cloud directory and call it done? File-sync clients copy files at random moments. If the client grabs a memory card while the emulator is mid-write, it uploads a half-written file and then overwrites your good cloud copy with it. A backup tool that snapshots on a schedule, keeps several generations and verifies afterwards avoids that failure. Our roundup of the best emulators for Windows PC lists the emulators this approach covers, and the folder logic applies to any of them.
Here is what you will have at the end:
- A portable emulation folder tree on one drive, with every emulator’s save data in a known place.
- A Ludusavi config that lists memory cards, console saves and save states as custom games.
- A first backup that you previewed, ran and inspected by hand.
- An rclone remote pointing at your own cloud account, wired into Ludusavi’s cloud sync.
- A PowerShell runner that backs up, uploads, verifies and logs, plus a scheduled task that fires nightly.
- A restore rehearsal, because a backup you have never restored is only a hope.
Budget about 45 minutes if your emulators are already installed. Add 15 minutes if you need to hunt for save folders.
Prerequisites With Versions
Check this list before you start. The versions below are the ones the tutorial was written against on October 26, 2026.
| Component | Version to use | Why it matters |
|---|---|---|
| Windows 11 | 26H2 preferred, 25H2 acceptable | 24H2 Home and Pro stopped receiving updates on October 13, 2026 |
| Ludusavi | v0.31.0 (latest release listed on GitHub) | Provides the GUI, the CLI and the cloud sync hooks |
| rclone | 1.75.2 | Security release, fixes issues present in 1.75.0 and 1.75.1 |
| PowerShell | The Windows PowerShell that ships with Windows 11 | Runs the backup and restore scripts |
| Cloud account | Any backend rclone supports | Google Drive, Dropbox, OneDrive, Backblaze B2 and S3-compatible storage all work |
| Emulators | Your current builds, portable mode where offered | Keeps saves inside one folder you control |
| Spare disk space | A folder on a second drive if possible | Holds the local backup tree, separate from the emulators |
The Windows row deserves a sentence of explanation. Microsoft reported Windows 11 version 26H2 as generally available, with the phased rollout reaching full availability on October 21, 2026. In Windows Central’s report on the October 2026 update, the cumulative update is KB5127648, and the 26H2 build is 26300.9711. A backup host that no longer gets security patches is a poor place to keep cloud credentials. Move any 24H2 Home or Pro machine to 25H2 or 26H2 first. The 26H2 upgrade arrives as a small enablement package on top of 24H2 or 25H2, so it needs no reinstall.
You also need the emulators themselves, ideally in portable mode. Portable mode keeps configuration, memory cards and save states inside the emulator’s folder instead of scattering them across Documents and AppData. If EmuDeck manages your Windows emulators, our EmuDeck Windows setup guide shows the folder layout it creates, and you can point Ludusavi at those paths instead of the ones used below.
One legal note. Ludusavi backs up save data only. It never touches ROMs, disc images or BIOS files, and nothing here asks you to download any of them. Keep game images and firmware dumps to material from hardware you own, as the emulator projects themselves advise.
Finally, pick a cloud account you already pay for, or a free tier. Save data is tiny next to game images, so the cheapest plan with an rclone backend is enough. Step 9 compares the options.
Phase 1: Install Ludusavi and rclone (Steps 1 to 3)
The first phase takes about eight minutes. You confirm the Windows release, then install the two command-line tools that everything else depends on.
Step 1: Confirm a supported Windows 11 release (3 min)
Open Settings, go to Windows Update and install anything pending. Then read the feature version from PowerShell, because the About page hides it behind a click.
(Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion').DisplayVersion
[System.Environment]::OSVersion.VersionThe first line should print 26H2 or 25H2. If it prints 24H2 on a Home or Pro edition, update before continuing, since that release stopped getting monthly updates on October 13. The second line prints the build number, which you can match against the Windows Update history if you ever need to prove what the host was running.
Step 2: Install Ludusavi with winget (2 min)
Winget is the quickest route on Windows 11. Run the install, open a fresh terminal, and check the version.
winget install --id mtkennerly.ludusavi --exact
ludusavi --versionThe second command should print v0.31.0 or newer. The release notes for v0.31.0 reportedly changed Windows registry backups so they are stored as .reg files rather than YAML, and existing backups stay valid. That change does not touch emulator saves, which are plain files, but it explains why older tutorials show different registry output.
If winget cannot find the package, run winget source update and try again. As a fallback, download the Windows zip from the project’s GitHub releases page and unzip it into D:\Emulation\saves-tool\bin. Ludusavi runs fine from any folder, and the scripts later in this tutorial look in that folder when the program is not on PATH.
Step 3: Install rclone 1.75.2 (3 min)
winget install --id Rclone.Rclone --exact
rclone versionClose the terminal and open a new one before running rclone version. PATH changes only reach new sessions, and this is the single most common reason the next phases fail. The output should name version 1.75.2. If it shows 1.75.0 or 1.75.1, upgrade with winget upgrade --id Rclone.Rclone.
Reports on the release say 1.75.2 fixed vulnerabilities touching the rclone selfupdate command, the S3 server and the WebDAV backend. Because of that, do not run selfupdate from an old build to reach the new one. Use winget or the official download page instead. A 1.76.0 beta build also appeared in mid-October, but it is not a stable release, so stay on 1.75.2 for a backup job.
Phase 2: Lay Out Folders and Map Emulator Saves (Steps 4 to 6)
Phase 2 is where most of the thinking happens. You decide where things live, then tell Ludusavi where each emulator keeps its saves.
Step 4: Build a portable emulation tree (5 min)
Pick a drive that is not your Windows drive if you have one. The goal is a single root that holds the emulators, the backup tree and the tooling, so a restore on a new PC means copying one folder and one cloud download.
$root = 'D:\Emulation'
'dolphin','pcsx2','duckstation','rpcs3','retroarch','cemu',
'saves-backup','saves-tool\bin','saves-tool\logs' |
ForEach-Object { New-Item -ItemType Directory -Force -Path (Join-Path $root $_) | Out-Null }
Get-ChildItem $rootInstall or unzip each emulator into its own subfolder, then switch it to portable mode. The common pattern is a marker file next to the executable, such as portable.txt for Dolphin or portable.ini for PCSX2. Each project documents its own switch, so check the emulator’s docs rather than guessing. Keep the backup folder outside every emulator folder. A backup tree nested inside the thing it protects will get scanned, copied and backed up again.
Avoid Documents as a home for emulator data. Many Windows 11 setups redirect Documents into OneDrive, which means the real path differs from the one in the emulator’s menu, and OneDrive’s own sync then fights with yours.
Step 5: Find each emulator’s real save folders (10 min)
Do not trust a table from the internet over your own install. Every emulator has a menu entry that opens its data folder, so use it, then look for the subfolders in the table below. The names reflect typical layouts and may differ in your build.
| Emulator | Typical save folders under its data folder | What lives there |
|---|---|---|
| Dolphin | User\GC, User\Wii\title, User\StateSaves | GameCube memory cards, Wii saves, save states |
| PCSX2 | memcards, sstates | PlayStation 2 memory cards, save states |
| DuckStation | memcards, savestates | PlayStation memory cards, save states |
| RPCS3 | dev_hdd0\home\00000001\savedata | PlayStation 3 saves for the default user |
| RetroArch | saves, states | Core battery saves and save states, folder names configurable |
| Cemu | mlc01\usr\save | Wii U saves |
Memory cards and console saves are your ground truth. Save states are convenient, but they depend on the emulator version, and an update can leave old states unreadable. Back them up anyway, because they are small, and treat them as a bonus. If you still need a working PS2 setup to test against, our PCSX2 BIOS setup walkthrough gets that emulator running with a BIOS from your own console. The shadPS4 setup guide does the same for PS4 titles, and shadPS4 keeps its own user folder that you can add as one more custom game.
Step 6: Write the Ludusavi config (7 min)
You can add custom games through the app. Open the Custom games tab, press Add game, name it, and add each path. For six emulators it is faster to write the file once. Save the following as D:\Emulation\saves-tool\config.yaml.
backup:
path: D:/Emulation/saves-backup
format:
chosen: simple
retention:
full: 5
differential: 0
restore:
path: D:/Emulation/saves-backup
customGames:
- name: Dolphin (portable)
files:
- D:/Emulation/dolphin/User/GC
- D:/Emulation/dolphin/User/Wii/title
- D:/Emulation/dolphin/User/StateSaves
- name: PCSX2 (portable)
files:
- D:/Emulation/pcsx2/memcards
- D:/Emulation/pcsx2/sstates
- name: DuckStation (portable)
files:
- D:/Emulation/duckstation/memcards
- D:/Emulation/duckstation/savestates
- name: RPCS3 (portable)
files:
- D:/Emulation/rpcs3/dev_hdd0/home/00000001/savedata
- name: RetroArch (portable)
files:
- D:/Emulation/retroarch/saves
- D:/Emulation/retroarch/states
- name: Cemu (portable)
files:
- D:/Emulation/cemu/mlc01/usr/saveUse forward slashes, even on Windows, because YAML treats the backslash as an escape character in some contexts. The field names match v0.31.0 as far as the project’s config documentation goes. If a future release renames something, run ludusavi schema config to print the current layout.
The --config flag tells Ludusavi to read its settings from a folder of your choice instead of AppData. Create a desktop shortcut with the target ludusavi.exe --config D:\Emulation\saves-tool and always open the app through it. Otherwise the GUI will write settings to a second config file, and your scheduled job will never see the cloud settings you enter in Step 10.
Phase 3: Run and Verify Your First Backup (Steps 7 and 8)
Step 7: Preview before you write anything (4 min)
Close every emulator first. A running emulator can hold a memory card open or flush it late, and a backup taken mid-write is the exact failure this project exists to avoid. Then run a preview, which lists what Ludusavi would copy without copying it.
ludusavi --config D:\Emulation\saves-tool backup --previewRead the output for three things. Every custom game you defined should appear. Every game should list real files, not an empty set. And the paths should sit under D:/Emulation, not under your user profile. A game that shows zero files means a typo, an emulator that is not in portable mode, or a folder that does not exist yet. Fix those now, because a silent empty backup looks identical to a good one until the day you need it. A sample of healthy output appears in the output examples section below.
Step 8: Run the real backup and inspect the tree (6 min)
ludusavi --config D:\Emulation\saves-tool backup --force --no-cloud-sync
Get-ChildItem D:\Emulation\saves-backup -Recurse -Depth 2 | Select-Object FullNameThe --force flag skips the confirmation prompt, and --no-cloud-sync keeps this first run local. Afterwards you should see one folder per game, each holding a mapping.yaml file and copies of the saves. Open one memory card copy and compare its size and timestamp with the original. If they match, the local half of the system works.
The config chose the simple format, which stores plain files. That choice has trade-offs worth knowing before you move on.
| Format | Strengths | Weaknesses |
|---|---|---|
| Simple (plain files) | Easy to browse, easy to diff, friendly to rclone because unchanged files are skipped | Uses more cloud space than compressed archives, many small files |
| Zip | Compact, one file per backup generation | Cloud sync re-uploads the whole archive when anything inside changes, harder to inspect by hand |
For memory cards and small saves, simple wins. The retention block in the config keeps five full generations, so an overwritten or corrupted save can be rolled back to an earlier night. If you add save-state folders for heavy emulators and the tree grows, drop the retention number or move to zip. For an emulator with unusual save quirks, such as the NES and SNES core in our MesenCE setup guide, add its folder as one more custom game and repeat the preview.
Phase 4: Add Cloud Sync With rclone (Steps 9 and 10)
Step 9: Create an rclone remote and pick a provider (10 min)
A remote is a named connection to your storage. Start the interactive wizard, choose n for a new remote, give it the name emusaves, and pick your provider from the list. Most consumer providers open a browser window for sign-in and then store a token locally.
rclone config
# n new remote
# name> emusaves
# Storage> pick your provider, accept defaults for advanced options
rclone lsd emusaves:
rclone mkdir emusaves:ludusavi-backup
rclone about emusaves:If rclone lsd lists your top-level folders without an error, the remote works. Save data is small, so the provider choice comes down to what you already pay for. A third-party price tracker last checked on October 18, 2026 lists these US plans.
| Provider and plan | Tracked price | Fit for emulator saves |
|---|---|---|
| Google One, Google AI Pro 5 TB | $19.99 per month | Overkill for saves, sensible only if you already subscribe |
| Dropbox Plus 2 TB | $9.99 per month, billed yearly | Good if Dropbox is already in your life |
| iCloud+ 50 GB | $0.99 per month | Cheapest paid tier, but check rclone support for your setup first |
| iCloud+ 2 TB | $9.99 per month | Same caveat, larger than you need |
| pCloud Premium 500 GB lifetime | $219 promotional, $279 list | One-off payment, useful if you hate subscriptions |
Prices change, so confirm on the provider’s page before you pay. Free tiers also work. Reports put the free OneDrive allowance at 5 GB and Dropbox Basic at 2 GB, and a year of memory cards fits in either. Rclone also speaks S3-compatible storage, which Yandex Cloud’s rclone backup tutorial demonstrates, so a Backblaze B2 or S3 bucket is a fine alternative.
One security habit before you move on. Rclone keeps your sign-in token in rclone.conf, which anyone with that file can use. Keep it out of every synced and shared folder, and consider protecting it with rclone config encryption set, though a password-protected config means the scheduled task needs a way to supply the password.
Step 10: Connect Ludusavi to the remote (6 min)
Open Ludusavi through your --config shortcut, go to the Other tab, and find the Cloud section. Choose the custom remote option, select emusaves and set the path to ludusavi-backup. Leave automatic synchronization off until the first upload succeeds. If rclone is not on PATH, set its executable path in the same section.
The command line offers the same controls. Preview the upload first, then do it for real.
ludusavi --config D:\Emulation\saves-tool cloud upload --preview
ludusavi --config D:\Emulation\saves-tool cloud uploadFlags occasionally move between releases, so run ludusavi cloud upload --help if either line complains. Once the upload finishes, browse your cloud account and confirm the folder structure matches the local tree. Console owners will recognize the problem this solves, and our comparison of how PS Plus, Xbox, Steam and Switch 2 cloud saves compare shows how little control subscription services give you over capacity and retention. With rclone you pick the provider, the folder and the history.
Phase 5: Automate, Rehearse a Restore and Monitor (Steps 11 to 13)
Step 11: Schedule the nightly job (6 min)
The runner script and the registration script are listed in full in the project section below. Save them in the tool folder, then register the task once. The task runs as your own user, only while you are signed in, because rclone’s token lives in your profile and a service account would not find it.
powershell -NoProfile -ExecutionPolicy Bypass -File D:\Emulation\saves-tool\Register-Task.ps1
Get-ScheduledTask -TaskName EmuSavesNightly | Select-Object TaskName, StateRun the task once by hand from Task Scheduler, or with Start-ScheduledTask -TaskName EmuSavesNightly, and read the new log file. Do this before trusting the schedule. A task that has never run successfully has not been tested.
Step 12: Rehearse a restore (8 min)
This step separates a backup from a hope. Start with a harmless preview that lists what a restore would write.
ludusavi --config D:\Emulation\saves-tool restore --previewThen do a real restore into a scratch location. In the app, open the Other tab, find Redirects, and add a restore redirect that maps D:/Emulation/pcsx2/memcards to D:/Emulation/_restore-test/memcards. Restore only the PCSX2 entry, open the scratch folder, and check the files. Better still, copy one restored card into a fresh emulator install and load a game from it. Battery saves from a GBA emulator make an easy first test because the file is tiny, and our mGBA setup for Pokémon games shows where that emulator keeps them.
Delete the redirect afterwards. A forgotten restore redirect sends the next real restore to the wrong place, and you will wonder why your recovered saves are missing.
Step 13: Monitor the task and read the logs (4 min)
Get-ScheduledTaskInfo -TaskName EmuSavesNightly |
Select-Object LastRunTime, LastTaskResult, NextRunTime
Get-ChildItem D:\Emulation\saves-tool\logs | Sort-Object LastWriteTime -Descending | Select-Object -First 3A LastTaskResult of 0 means the script finished cleanly. Anything else means open the newest log. Set a calendar reminder to run the restore drill script monthly, and again after every Windows feature update, emulator upgrade or rclone upgrade. A tool chain that worked in October can break in November without a single error message.
Complete Working Project: Runner, Scheduler and Restore Drill
The project is four files in D:\Emulation\saves-tool. You already created config.yaml in Step 6. The three scripts below do the rest. Save each one under the filename in its comment line.
The runner is the heart of the project. It finds both tools, skips the run if an emulator is open, refreshes the manifest, backs up through Ludusavi, parses the JSON report, verifies the cloud copy with rclone, trims old logs, and exits non-zero on any problem so Task Scheduler records a failure.
# D:\Emulation\saves-tool\Backup-EmuSaves.ps1
[CmdletBinding()]
param(
[string]$ToolDir = 'D:\Emulation\saves-tool',
[string]$BackupDir = 'D:\Emulation\saves-backup',
[string]$Remote = 'emusaves:ludusavi-backup',
[switch]$SkipCloud,
[int]$KeepLogDays = 30
)
$logDir = Join-Path $ToolDir 'logs'
New-Item -ItemType Directory -Force -Path $logDir | Out-Null
$stamp = Get-Date -Format 'yyyyMMdd-HHmmss'
$logFile = Join-Path $logDir "backup-$stamp.log"
$failed = $false
function Write-Log {
param([string]$Message)
$line = '{0} {1}' -f (Get-Date -Format 's'), $Message
Add-Content -Path $logFile -Value $line
Write-Host $line
}
function Find-Tool {
param([string]$Name, [string]$Fallback)
$cmd = Get-Command $Name -ErrorAction SilentlyContinue
if ($cmd) { return $cmd.Source }
if (Test-Path $Fallback) { return $Fallback }
throw "Cannot find $Name. Install it or fix PATH."
}
$ludusavi = Find-Tool 'ludusavi.exe' (Join-Path $ToolDir 'bin\ludusavi.exe')
$rclone = Find-Tool 'rclone.exe' (Join-Path $ToolDir 'bin\rclone.exe')
Write-Log ("Ludusavi: " + (& $ludusavi --version))
Write-Log ("rclone: " + ((& $rclone version) | Select-Object -First 1))
# Skip if an emulator is open, because open files can be half-written
$running = Get-Process -Name 'dolphin*','pcsx2*','duckstation*','rpcs3*','retroarch*','cemu*' -ErrorAction SilentlyContinue
if ($running) {
Write-Log ("Skipped, emulator running: " + (($running | Select-Object -ExpandProperty ProcessName -Unique) -join ', '))
exit 2
}
# Manifest refresh is useful but not fatal
& $ludusavi --config $ToolDir manifest update 2>&1 | ForEach-Object { Write-Log "manifest: $_" }
$cliArgs = @('--config', $ToolDir, 'backup', '--force', '--api')
if ($SkipCloud) { $cliArgs += '--no-cloud-sync' }
$errFile = Join-Path $logDir "stderr-$stamp.txt"
$raw = & $ludusavi @cliArgs 2> $errFile
$exit = $LASTEXITCODE
$raw | Set-Content -Path (Join-Path $logDir "report-$stamp.json") -Encoding UTF8
try {
$report = ($raw -join "`n") | ConvertFrom-Json
Write-Log ("Games processed: {0} of {1}" -f $report.overall.processedGames, $report.overall.totalGames)
} catch {
Write-Log 'Could not parse the JSON report. See the report file next to this log.'
}
if ($exit -ne 0) { Write-Log "Ludusavi exit code $exit, see $errFile"; $failed = $true }
if (-not $SkipCloud) {
& $rclone check $BackupDir $Remote --one-way --size-only 2>&1 | ForEach-Object { Write-Log "rclone check: $_" }
if ($LASTEXITCODE -ne 0) { Write-Log 'Cloud copy differs from local backup'; $failed = $true }
}
Get-ChildItem $logDir -File |
Where-Object LastWriteTime -lt (Get-Date).AddDays(-$KeepLogDays) |
Remove-Item -Force
if ($failed) { Write-Log 'RESULT: FAILED'; exit 1 }
Write-Log 'RESULT: OK'
exit 0The scheduler script registers the nightly task. The StartWhenAvailable setting runs a missed job as soon as the PC wakes, which matters for a gaming machine that is often off at 9 p.m.
# D:\Emulation\saves-tool\Register-Task.ps1
$script = 'D:\Emulation\saves-tool\Backup-EmuSaves.ps1'
$action = New-ScheduledTaskAction -Execute 'powershell.exe' `
-Argument "-NoProfile -ExecutionPolicy Bypass -File `"$script`""
$trigger = New-ScheduledTaskTrigger -Daily -At 9:00pm
$settings = New-ScheduledTaskSettingsSet -StartWhenAvailable -ExecutionTimeLimit (New-TimeSpan -Hours 1)
$principal = New-ScheduledTaskPrincipal -UserId $env:USERNAME -LogonType Interactive -RunLevel Limited
Register-ScheduledTask -TaskName 'EmuSavesNightly' -Action $action -Trigger $trigger `
-Settings $settings -Principal $principal -ForceThe restore drill is the monthly check. It never writes to your emulator folders. It lists backups, previews a restore, compares the cloud copy with the local tree, and prints how fresh each game’s newest file is, which is the quickest way to spot a game that silently stopped backing up.
# D:\Emulation\saves-tool\Restore-Drill.ps1
param(
[string]$ToolDir = 'D:\Emulation\saves-tool',
[string]$BackupDir = 'D:\Emulation\saves-backup',
[string]$Remote = 'emusaves:ludusavi-backup'
)
$ludusavi = (Get-Command ludusavi.exe).Source
$rclone = (Get-Command rclone.exe).Source
Write-Host '1. Local backup folders:'
Get-ChildItem $BackupDir -Directory | Select-Object -ExpandProperty Name
Write-Host '2. Restore preview (nothing is written):'
& $ludusavi --config $ToolDir restore --preview
Write-Host '3. Does the cloud copy match the local backup?'
& $rclone check $BackupDir $Remote --one-way --size-only
if ($LASTEXITCODE -eq 0) { Write-Host 'PASS' -ForegroundColor Green } else { Write-Host 'FAIL' -ForegroundColor Red }
Write-Host '4. Newest file per game:'
Get-ChildItem $BackupDir -Directory | ForEach-Object {
$newest = Get-ChildItem $_.FullName -Recurse -File | Sort-Object LastWriteTime -Descending | Select-Object -First 1
[pscustomobject]@{ Game = $_.Name; Newest = $newest.LastWriteTime }
} | Format-Table -AutoSizeThe JSON field names in the runner (overall.processedGames and overall.totalGames) follow Ludusavi’s API output as documented for recent releases. Run ludusavi schema api-output to confirm them on your version. If a field is missing the script logs a blank rather than failing, and the exit code still carries the verdict.
Output Examples: What a Healthy Run Looks Like
The samples below are illustrative. Exact wording, sizes and timestamps vary by Ludusavi version and by your saves, but the shape should look familiar. First, a preview from Step 7.
Preview of backup, 6 games
Dolphin (portable) [9.8 MiB]
D:/Emulation/dolphin/User/GC/MemoryCardA.USA.raw
D:/Emulation/dolphin/User/Wii/title/00010000/...
PCSX2 (portable) [8.1 MiB]
D:/Emulation/pcsx2/memcards/Mcd001.ps2
DuckStation (portable) [0.2 MiB]
D:/Emulation/duckstation/memcards/shared_card_1.mcd
...
Overall: 6 games, 27.4 MiBSecond, a runner log after a clean nightly run. The version lines are the quickest way to notice that a tool silently updated.
2026-10-26T21:00:02 Ludusavi: ludusavi v0.31.0
2026-10-26T21:00:02 rclone: rclone v1.75.2
2026-10-26T21:00:05 manifest: Manifest is up to date
2026-10-26T21:00:19 Games processed: 6 of 6
2026-10-26T21:00:41 rclone check: 0 differences found
2026-10-26T21:00:41 RESULT: OKThird, the verification step by itself. A matching count and zero differences is the result you want. Any number above zero means the cloud copy is missing or different, and the runner will mark the night as failed.
$ rclone check D:\Emulation\saves-backup emusaves:ludusavi-backup --one-way --size-only
NOTICE: emusaves root 'ludusavi-backup': 0 differences found
NOTICE: emusaves root 'ludusavi-backup': 37 matching filesCommon Pitfalls
These are the mistakes that turn a good setup into a false sense of safety.
- Using rclone sync with the arguments reversed. The sync command makes the destination match the source and deletes anything extra. Swap the two paths and you erase your local saves to match an empty cloud folder. Let Ludusavi drive the upload, and use
rclone checkonly to compare. - Backing up while an emulator is open. Memory cards can be mid-write. The runner script skips the night if it sees an emulator process, but a manual run does not, so close everything first.
- Running two configs. Opening Ludusavi from the Start menu uses the AppData config, while the scheduled job uses the one in the tool folder. Settings you enter in one never reach the other. Always launch the app through the shortcut that carries the config flag.
- Trusting Documents paths. A OneDrive-redirected Documents folder changes the real path, and Windows may hand Ludusavi a placeholder file that has not been downloaded. Keep emulator data on a plain local drive.
- Treating save states as saves. A state is a snapshot of one emulator version’s memory. After an upgrade it may refuse to load. Memory cards and native saves are what you can always restore, so verify those first.
- Skipping the restore rehearsal. Many people discover a wrong path only when they need the backup. The rehearsal in Step 12 costs eight minutes and catches it. The same lesson applies to newer emulators, such as the Switch fork in our Ryubing setup guide, where the save folder is easy to confuse with the firmware folder.
- Leaving rclone.conf where others can read it. The file holds a live token. Keep it out of the backup tree, out of Git repositories and out of screenshots.
Troubleshooting: 9 Problems and Their Fixes
Start with the log file. Nearly every failure leaves a line there, and the table below maps the usual symptoms to a cause and a fix.
| Symptom | Likely cause | Fix |
|---|---|---|
| winget reports no package found | Stale package source | Run winget source update, or unzip the release from GitHub into the tool\bin folder |
| Ludusavi says rclone cannot be found | PATH not refreshed, or rclone installed after the app opened | Open a new terminal, restart Ludusavi, or set the rclone executable path in the Cloud section |
| Cloud step fails with an auth or token error | The OAuth token expired or was revoked | Run rclone config reconnect emusaves: and sign in again |
| Warning that local and cloud backups differ | Another PC uploaded, or this is the first sync | Decide which side is correct, then upload or download once by hand before re-enabling automation |
| A custom game backs up zero files | Typo in the path, emulator not portable, folder not created yet | Check the path with Test-Path, then open the emulator’s own data folder menu |
| Access denied while copying | Windows Security controlled folder access, or a file locked by a running emulator | Close the emulator, then allow ludusavi.exe in Windows Security |
| Task shows last result 0x1 or an empty log | The task context has a different PATH, user or execution policy | Keep the fallback paths in the runner, register the task as your own user, run with the full script path |
| Restore lands in the wrong folder | A leftover redirect, or a changed drive letter | Run the restore preview, delete old redirects, add one only when you mean it |
| Backup tree keeps growing | Large state folders and five retained generations | Lower the retention number, ignore state folders, or switch the format to zip |
Two of these deserve more detail. The token error is the one most people hit after a few months. OAuth tokens expire or get revoked when you change a password, and the symptom is a cloud step that worked for weeks and suddenly fails. The command rclone config reconnect emusaves: opens the browser sign-in again without touching the rest of the remote, and the next scheduled run recovers by itself.
The scheduled task problem is subtler. A script that works in your terminal can fail in Task Scheduler because the task starts with a smaller environment. Run the task from Task Scheduler’s own Run button, not from your terminal, while testing. If that works but the nightly run does not, check that the PC was awake and that you were signed in, since the task was registered for an interactive session. The sixty-minute execution limit in the registration script also stops a stuck upload from holding the machine open all night.
Advanced Tips
- Encrypt before upload. Add a crypt remote on top of your cloud remote with
rclone config, then point Ludusavi’s cloud path at the crypt remote. File names and contents become unreadable to the provider. Store the crypt passwords in a password manager, because losing them makes the backup permanently unreadable. - Use differential retention. If you move to zip format and want more history for less space, set a few differential backups between full ones. Test a restore from a differential before relying on it.
- Exclude noisy folders. Save states are large and change constantly. Split them into a second custom game, such as Dolphin states, so you can back them up weekly while memory cards go nightly.
- Hook your launcher. Playnite and similar launchers can run a PowerShell snippet after a game exits. Call
ludusavi backup --forcewith the exact game name and the same config folder. The name must match your custom game entry, or Ludusavi will find nothing. Menu names for the scripting settings vary between launcher versions. - Share saves between two PCs. Use the same cloud path on both machines, run an upload on the one you finished playing on and a download on the other, and resolve the differs-from-cloud prompt deliberately. For a LAN-only setup, a folder-sync tool such as Syncthing on the backup tree is another option, though it lacks the verification step.
- Linux and handheld installs. Reports from October 2026 say the Flatpak build of Ludusavi was flagged on October 5 for using an unsupported runtime, and the maintainer said on October 14 that the update had been submitted to Flathub. If you run it on a handheld, check that your Flatpak is current. The tutorial’s config format is the same on every platform, but the paths differ.
- Pin and review tool versions. The runner logs both versions every night. When rclone or Ludusavi updates, read the release notes before the next scheduled run, since the rclone security fixes in 1.75.2 are a reminder that backup tooling deserves the same attention as the data it protects.
For more emulation setup and tuning guides to pair with this backup system, browse our gaming coverage.
FAQ
Does Ludusavi back up ROMs, BIOS files or disc images?
No. It copies save data from the folders you list, nothing else. Keep game images and firmware dumps from hardware you own in a separate, deliberate backup, and do not mix them into the saves tree.
Can I use Ludusavi without a cloud account?
Yes. Run the backup with --no-cloud-sync, or pass -SkipCloud to the runner script. Then copy the backup folder to an external drive on a schedule. You lose off-site protection, so pair it with a second copy elsewhere.
Which rclone version should I run?
Run 1.75.2 or newer on the stable channel. Versions 1.75.0 and 1.75.1 were affected by vulnerabilities that 1.75.2 fixes, so upgrading is worth five minutes.
Do I have to close my emulators before a backup?
Yes, for a clean backup. A running emulator can hold a memory card open or write to it late. The runner script skips the night when it finds an emulator process, which protects the data at the cost of a missed run.
Can I restore saves onto a different PC?
Yes. Install the same tools, run a cloud download, then restore. If the drive letters differ, add a restore redirect that maps the old paths to the new ones, and check the preview before writing anything.
How often should the job run?
Nightly is a good default for most players. If you play long sessions of games with no autosave, run the runner by hand after you quit. Backups cost little, and the retention setting keeps old generations around.
Will a Windows 11 feature update break this setup?
It should not. The 26H2 update arrives as a small enablement package on top of 24H2 or 25H2, so your folders, tools and scheduled task stay in place. Still, run the restore drill after any large update, because the cost is minutes and a silent break costs saves.
