RomM as Save Sync provider

[XargonWan]

Is your feature request related to a problem? Please describe.

I'd like to use RomM as the central storage for my game saves, but currently there is no way for SaveState to associate a profile with a RomM game and synchronize its saves.

This is particularly useful for games I own on Steam or other PC launchers. I may want to store their saves in RomM without actually storing the game itself in RomM.

For example:

• Steam: Sonic Mania
• SaveState: Sonic Mania profile with the local save path
• RomM: no Sonic Mania game entry

I'd still like to use RomM to store and synchronize the Sonic Mania save data.

Describe the solution you'd like

I'd like SaveState to support RomM as a save synchronization provider, with the ability to associate each SaveState profile with a RomM game entry.

I envision a RomM button/icon on each SaveState profile. Clicking it would open a dialog such as "Link to RomM".

The dialog would:

1. Automatically search RomM using the SaveState profile name.
2. Display matching games including their platform, since the same title can exist on multiple platforms.
3. Allow the user to select the correct RomM entry.
4. Allow the user to modify the search query and search again if the correct game isn't found.
5. Store the selected RomM rom_id in the SaveState profile for future save synchronization.

For example, searching for Sonic Mania could return:

• Sonic Mania — Windows
• Sonic Mania — Nintendo Switch
• Sonic Mania — PlayStation 4

The user can then select the appropriate entry.

Creating a new RomM entry

If the game does not exist in RomM, the same dialog could provide a + button to create a new entry.

Instead of requiring the user to manually open RomM and upload a dummy file, SaveState could create a small temporary placeholder file and upload it using RomM's upload API.

For example:

Sonic Mania.dummy

SaveState would:

1. Determine the appropriate RomM platform.
2. Create a small temporary dummy file.
3. Upload it through RomM's ROM upload API.
4. Finalize the upload so RomM indexes the file and creates the ROM entry.
5. Retrieve the resulting rom_id.
6. Associate that rom_id with the SaveState profile.
7. Delete the local temporary dummy file.

This would make the whole process transparent to the user.

The dummy file would not need to be a playable game. Its only purpose would be to create a RomM ROM entry that can provide a stable rom_id for save synchronization.

If RomM's scanning/indexing process requires an additional scan step after the upload, SaveState could either trigger that through the available API or provide a fallback asking the user to run a scan before completing the association.

Example workflow

SaveState profile
    │
    ▼
[ RomM icon ]
    │
    ├── Search existing games
    │       │
    │       └── Sonic Mania — Windows
    │
    └── [+ Create new entry]
            │
            ├── Create Sonic Mania.dummy
            ├── Upload via RomM API
            ├── Index/scan
            ├── Get rom_id
            └── Associate profile
                    │
                    ▼
                Save Sync

RomM already provides an API specifically intended for companion applications, and Client API Tokens are the recommended authentication mechanism for this type of integration.

Describe alternatives you've considered

Using generic cloud storage such as WebDAV, SMB, FTP, or Google Drive can store the save files, but it doesn't provide the game-aware organization and metadata that RomM already provides.

Another option would be to manually configure a RomM rom_id, but this is not very user-friendly and makes it difficult to discover the correct game when multiple platforms have the same title.

A manual workflow where the user opens RomM's /upload page and uploads a dummy file would also work, but having SaveState perform the upload through RomM's API would make the process considerably more seamless.

Additional context

RomM provides an API for ROM uploads:

• POST /api/roms/upload/start
• PUT /api/roms/upload/{upload_id}
• POST /api/roms/upload/{upload_id}/complete

The upload completion step assembles and indexes the uploaded file.

RomM also provides Client API Tokens specifically for companion applications and third-party integrations.

SaveState already has the concept of profiles representing individual games and supports automatic save-path detection, so associating a profile with a RomM rom_id seems like a natural extension.

The important part for the UX would be that the user should not need to know or manually enter a RomM rom_id. Searching by game name and selecting the correct platform should be sufficient in the normal case.

For games that don't exist in RomM, creating a tiny placeholder ROM through the RomM upload API could provide a simple way to create the required rom_id without requiring the actual game to be stored in RomM.

[Matteo842]

i love how you write the new features.
this is problably for the 3.2 why 3.1 is OS sync and im curretly working on android version of crash bandicoot decomp.