Introduction
Kumo (雲, Japanese for "cloud") is an Android app that automatically syncs emulator files to the cloud, including saves and ROMs. It runs as a foreground service in the background, watching your emulator directories in real time and uploading changes as soon as they happen. When you turn on your handheld after a break — or switch from one device to another — your files are already waiting.
How it works
🎮 Device A (雲 App) ──⇄── ☁️ cloud storage ──⇄── 🎮 Device B (雲 App)🔗 Authentication — 雲 App uses a secure account system for sign-up and sign-in. After login, credentials scoped to your account are obtained — no other user can access your files.
⬆️ Sync — A full bidirectional sync runs on startup and whenever the network becomes available. A file watcher then monitors your emulator directories for changes and uploads each modified file within seconds.
🔄 Real-time push — When another device uploads a file, the upload triggers a notification to all connected devices. The app downloads the new file immediately without waiting for the next full sync.
🌍 Regions — During registration, 雲 App performs a geo-IP lookup and picks the server region nearest to you. After registration, your account stays in that region.
Architecture overview
| Layer | Technology |
|---|---|
| Mobile app | Android (Kotlin, MVVM, ViewBinding) |
| Storage | Cloud storage (per-region, versioning enabled) |
| Real-time | WebSocket push |
| Linux client | Python 3 daemon (kumo-sync) |
Key design decisions
Cloud versioning is always enabled. This means deleting a file creates a delete marker rather than destroying the object immediately. Kumo uses these markers to distinguish a deliberate local deletion from a file that simply hasn't been downloaded yet.
No central server. There is no Kumo backend sitting between you and the cloud. After authentication, your device talks directly to cloud storage. The only server-side logic handles real-time push notifications, data export, and subscription management.
Forced dark mode. The app enforces dark mode regardless of system settings.
Why not Syncthing?
Syncthing is an excellent piece of software — open source, battle-tested, and trusted by millions of users for general-purpose file synchronisation. If you need to sync arbitrary folders between devices, Syncthing is hard to beat. Kumo exists because emulator save sync on Android has a few specific challenges that Syncthing was not designed to solve.
Android/data is off-limits. Since Android 11, the Android/data/ directory is locked down by scoped storage. Most emulators (RetroArch, DuckStation, PPSSPP, Dolphin, and others) store their saves there. Syncthing cannot access these directories at all. Kumo uses the Storage Access Framework (SAF) to read and write saves in Android/data/ with explicit user permission.
Cloud as central storage. Syncthing is peer-to-peer — it needs at least one other device to be online and reachable to sync. If your phone and your handheld are never powered on at the same time, saves never transfer. Kumo stores everything in the cloud, so your saves are always available regardless of which devices are online.
Simple setup. Syncthing requires you to pair devices, share folders, configure ignore patterns, and potentially deal with port forwarding or relay servers. Kumo keeps setup simple: create an account, enable the emulators you use, do a quick one-time setup for most emulators, then tap Start Sync.
Emulator-aware. Kumo auto-detects save paths as much as possible (including reading RetroArch configuration files), filters uploads by file extension so only actual save data is synced, and organises files into categories (saves, states, memory cards, BIOS, ROMs). There is no manual folder configuration for supported emulators.
Real-time push. When a save is uploaded from one device, all other connected devices are notified instantly via WebSocket and download the file within seconds. Syncthing's discovery and relay infrastructure works well for general use, but Kumo's push model is purpose-built for the low-latency, small-file pattern of emulator saves.
Versioned cloud storage. Every file change is versioned server-side. Deleting a save creates a delete marker rather than destroying the data. If a conflict arises (two devices editing the same save offline), both versions are preserved as conflict copies. Syncthing offers file versioning too, but it is local to each device — Kumo's versioning is centralised and survives device loss.