Getting a ROM library into Steam used to mean adding each game one by one as a “non-Steam shortcut,” typing out launch commands by hand, and hunting down box art on Google Images. Steam ROM Manager automates all of it. Point it at your emulator folders, and it scans your ROMs, matches them against the emulator you tell it to use, pulls matching artwork from SteamGridDB, and writes proper Steam library entries complete with grid art, hero banners, and logos. The result is a library where Chrono Trigger or Persona 4 sits next to your Steam-native games with full controller support and Big Picture Mode compatibility.
This guide walks through installing Steam ROM Manager on Windows and Steam Deck/SteamOS, configuring your first parser, wiring up SteamGridDB for artwork, and saving a working multi-emulator library to Steam. It also covers the errors that trip up almost everyone on their first run, because the tool’s biggest weakness is a handful of very specific, very repeatable failure modes.
None of this requires a Steam Deck. Steam ROM Manager runs on a regular Windows gaming PC just as well as it does on SteamOS, and for a broader look at the emulator ecosystem it plugs into, it’s worth reading up on how the various PC emulator options and handheld setups compare before deciding which systems to import first.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
Why Bother Adding Emulators to Steam at All
The obvious question is why route emulated games through Steam instead of just launching them from a dedicated frontend like RetroArch’s own menu or a tool like Playnite. The answer comes down to what Steam gives you for free once a game is registered as a shortcut. Big Picture Mode turns your emulator library into a console-style interface you can navigate entirely with a controller, no keyboard required. Steam Input applies per-game controller profiles automatically, so a DualSense or Xbox controller gets remapped correctly the instant you launch a specific title, without you touching a settings menu first.
The Steam Overlay also comes along for the ride. Screenshot capture, the built-in FPS counter, and Steam’s background recording feature all work on non-Steam shortcuts exactly like they do on native Steam games, because as far as the Steam client is concerned, there’s no functional difference between the two once a shortcut exists. Steam Input, documented in Steam’s own support library, applies the same per-game controller remapping to emulated titles that it applies to native ones. If you’re running a handheld like a Steam Deck, ROG Ally, or Legion Go, having every emulator behind one unified library also means you stop juggling multiple launchers just to find the game you want to play, which matters more on a small screen than it does on a desktop monitor.
What Steam ROM Manager does not give you is Steam Cloud save syncing or Steam achievements for emulated games. Those remain tied to whatever save-state or save-file system your emulator uses natively, and to RetroAchievements for the handful of emulator cores that support it. Treat Steam ROM Manager as a library and launcher layer, not a full replacement for your emulator’s own save management.
What Steam ROM Manager Actually Does
Steam ROM Manager, built and maintained by the SteamGridDB organization on GitHub, describes itself as a bulk game importer and artwork manager for Steam. That description is accurate but undersells how much manual work it removes. Instead of adding games to Steam one at a time through the “Add a Non-Steam Game” dialog, you give Steam ROM Manager a folder of ROMs and a parser (a small config template that knows how to build a launch command for a specific emulator or system), and it generates every shortcut at once.
The tool works in three stages. First, a parser scans your configured ROM directory and matches file names against a title database. Second, a preview step shows you exactly what it found, including matched artwork thumbnails, before anything is written. Third, a save step writes the shortcuts directly into Steam’s shortcuts.vdf file, which is the same binary format Steam itself uses to store non-Steam game entries. Because it writes to that file directly, Steam ROM Manager needs the Steam client fully closed while it saves, a detail that causes a large share of the “it’s not working” reports floating around EmuDeck and Steam Deck forums.
The project itself is not new. Its GitHub history traces back to 2017, and the repository under the SteamGridDB organization has accumulated more than 150 tagged releases since then. The most recent one visible on the project’s GitHub releases page is version 2.5.30, labeled “Steam Categories Fix,” dated October 5, 2025. Pull requests and configuration updates, including a Ryujinx parser update submitted in early 2025, continued to land against the repository well into 2026, which is a reasonable signal that the project is maintained rather than abandoned, even if the release cadence has slowed to bugfixes and parser corrections rather than major version jumps.
Under the hood, Steam ROM Manager supports two parser types. “Glob” parsers, the type used for the vast majority of setups, scan a folder for files matching a pattern (every .sfc file, every .iso, every .xci) and treat each match as one game. “Manual” parsers instead read from a manifest file you maintain yourself, which is useful for emulators like RPCS3 or Cemu where a “game” is really a folder or an installed package rather than a single loose ROM file. Most tutorials, including this one, lean on Glob parsers because they require far less manual bookkeeping once your folder structure is set up correctly.
Prerequisites: What You Need Before You Start
Steam ROM Manager is not an emulator, and it does not download games for you. It only builds Steam shortcuts around emulators and ROM files you already have. Before touching the app, get these pieces in place.
| Requirement | Details |
|---|---|
| Operating system | Windows 10/11 (64-bit) or Linux/SteamOS, including Steam Deck |
| Steam client | Installed, updated, and logged in at least once before running Steam ROM Manager |
| At least one emulator | Already installed and tested manually (RetroArch, Dolphin, Cemu, PCSX2, Ryujinx-family, PPSSPP, etc.) |
| ROM library | Legally dumped from games you own, organized into folders by system |
| SteamGridDB account | Free signup at steamgriddb.com, used to generate an API key for artwork matching |
| Steam ROM Manager | Version 2.5.30 or the latest build from the SteamGridDB GitHub releases page |
| Free disk space | Roughly 200-300 MB for the app itself, plus artwork cache that grows with library size |
Note what is missing from that list: Node.js. Steam ROM Manager ships as a self-contained Electron app, a Windows .exe installer on Windows and an AppImage on Linux, so you don’t need to install a separate JavaScript runtime unless you’re building the project from source. If you’re setting this up on a Steam Deck running SteamOS, note that EmuDeck already installs and manages a copy of Steam ROM Manager for you. This tutorial focuses on the manual, standalone setup that gives you full control over parsers and paths, which is also exactly what you’ll need if EmuDeck’s automated version breaks or if you’re doing this on a regular Windows gaming PC that EmuDeck doesn’t touch.
It also helps to have your core emulators configured and working in standalone mode before you ever open Steam ROM Manager. If RetroArch can’t play a ROM directly, Steam ROM Manager won’t be able to launch it through a shortcut either, since it’s calling the exact same executable with the exact same arguments a manual launch would use. Get your BIOS files in order first (our guide to legally sourcing RetroArch BIOS files covers the systems that need them), confirm each core loads a test ROM cleanly, and only then move on to bulk-importing through Steam ROM Manager.
Step 1-2: Download and Install Steam ROM Manager
On Windows
Go to the official releases page and download the newest Windows build listed, currently 2.5.30. Run the installer like any other Windows application. It installs into your user profile and doesn’t require administrator rights on most systems. Once installed, launch it and let it create its default configuration folder before you do anything else, since some Windows security software flags the first launch of an unsigned Electron app and needs a manual “allow” click.
On Steam Deck and Linux/SteamOS
On Linux, Steam ROM Manager ships as a single AppImage file. Download it from the same releases page, move it somewhere permanent (many EmuDeck-adjacent guides use a path like Emulation/tools/srm/Steam-ROM-Manager.AppImage for consistency with other emulation tools), and mark it executable before running it.
chmod +x Steam-ROM-Manager.AppImage
./Steam-ROM-Manager.AppImageIf you skip the chmod +x step, double-clicking the AppImage on SteamOS’s desktop mode does nothing, which is one of the most common “why won’t it even open” complaints in Steam Deck communities. If you’re already running EmuDeck, it places its own managed copy of the AppImage automatically, and you generally don’t need a second manual install unless you want to test a specific standalone version.
Step 3-4: Organize Your ROMs and Point SRM at Your Emulators
Steam ROM Manager works best when your ROMs live in clean, system-specific folders rather than one giant mixed directory. A layout like the one below keeps parsers simple and makes troubleshooting far easier when something doesn’t match correctly.
ROMs/
snes/
Chrono Trigger.sfc
Super Metroid.sfc
psx/
Final Fantasy VII (Disc 1).chd
gamecube/
Metroid Prime.iso
wiiu/
Breath of the Wild.wux
switch/
Tears of the Kingdom.xciEvery parser in Steam ROM Manager needs to know two things: where your ROM files are, and what command to run to launch them. For emulators that use RetroArch cores, that command typically points at the RetroArch executable plus a core file plus the ROM path. For standalone emulators like Dolphin, Cemu, or PCSX2, the parser points directly at the emulator’s executable with the ROM passed as an argument. Open Steam ROM Manager’s settings panel and confirm the paths to your installed emulators are correct before building any parsers, since a wrong executable path is the single most common reason a “successfully generated” shortcut fails to launch anything when you click it in Steam.
Step 5-6: Configure Your First Parser
Parsers are the core concept in Steam ROM Manager. Each one is a saved configuration that tells the app: scan this folder, treat every file as this type of game, launch it with this executable and these arguments, and use this title-matching strategy against SteamGridDB. Click “Add New Parser” inside the app, give it a name (for example, “SNES – RetroArch”), and fill in the ROM directory, the executable path for RetroArch, and the core you want used for that system.
A typical RetroArch-based parser configuration, saved as JSON under the hood, resembles this structure:
{
"parserType": "Glob",
"configTitle": "SNES - RetroArch",
"romDirectory": "D:\\ROMs\\snes",
"executable": "C:\\RetroArch\\retroarch.exe",
"executableArgs": "-L \"cores\\snes9x_libretro.dll\" \"{{{filePath}}}\"",
"titleModifier": "{{{fuzzyTitle}}}",
"imageProviders": ["SteamGridDB"]
}You don’t need to hand-write this file yourself. The app’s UI generates it as you fill in form fields, but understanding the structure helps enormously when you’re debugging a parser that won’t match titles correctly. Repeat this process for every system you want in your library: one parser for SNES, one for PS1, one for GameCube through Dolphin, one for Wii U through Cemu, and so on. EmuDeck ships with dozens of pre-built parser templates covering RetroArch cores plus standalone emulators such as Dolphin, Cemu, PCSX2, PPSSPP, Xenia, Flycast, and RPCS3’s PKG format. On a manual desktop install, you’re building each one from scratch, which takes longer but gives you exact control over launch arguments.
Naming your parsers consistently matters more than it sounds like it would. Once you have ten or fifteen of them, a vague name like “Parser 3” is useless when you’re trying to figure out which one just failed to match a game. Stick to a “System – Emulator” naming convention, exactly like the SNES – RetroArch example above, and future troubleshooting gets dramatically faster. If you’re running multiple RetroArch cores for the same system, such as comparing MAME against FBNeo for arcade titles, name each parser after the specific core so you can tell them apart at a glance in Steam ROM Manager’s parser list.
Step 7-8: Connect SteamGridDB for Box Art and Artwork
Steam ROM Manager’s artwork comes from SteamGridDB, the same community-run art database that Steam itself increasingly draws on for custom grids. Create a free account at SteamGridDB, then go to your profile preferences to generate an API key. Paste that key into Steam ROM Manager’s settings under the SteamGridDB image provider option.
# Steam ROM Manager settings > Image Providers > SteamGridDB
apiKey: "your-steamgriddb-api-key-here"
imageTypes: ["grid", "hero", "logo", "icon"]
fuzzyMatching: trueWith fuzzy (natural) title matching enabled, Steam ROM Manager can correctly identify a file named Super Metroid (USA).sfc as “Super Metroid” and pull the correct grid image, vertical capsule, hero banner, and logo automatically. This matching isn’t perfect for obscure or heavily abbreviated ROM filenames, so expect to manually reassign artwork for a handful of games after your first import, particularly anything with unusual regional naming or ROM hacks.
Step 9: Preview Your Matches Before You Commit
Once your parsers are configured, click “Preview” rather than “Save.” This is the step most tutorials skip past too quickly, and it’s the one that saves you the most cleanup work later. The preview screen lists every game Steam ROM Manager found, the artwork it matched, and the exact launch command it plans to write. Scroll through it. Look for games with missing artwork (usually a filename-matching problem, fixable by manually searching SteamGridDB inside the app and picking the right game), and look for launch commands with obviously wrong paths, which usually means a typo in your parser’s executable field.
Fixing problems at the preview stage takes seconds. Fixing them after they’re already written into Steam’s shortcuts file means digging through Steam’s non-Steam games list one entry at a time, which is significantly more tedious for a library of more than a couple dozen titles.
Step 10: Save to Steam and Verify the Shortcuts
Before clicking “Save,” fully close Steam. Steam ROM Manager writes directly to Steam’s shortcuts.vdf configuration file, and Steam itself holds that file open and can silently overwrite or ignore external changes while it’s running. On Windows, close Steam from the system tray (right-click, Exit) rather than just closing the window. On Linux or SteamOS, the more reliable method is a terminal command:
killall steam
./Steam-ROM-Manager.AppImageWith Steam closed, click “Save” inside Steam ROM Manager. It writes every shortcut from your parsers into Steam’s configuration, including artwork assignments. Relaunch Steam afterward and check your library. The imported games should appear with full grid art, matching the layout of your native Steam titles. If a game shows up with a generic placeholder icon and no artwork, that specific title’s SteamGridDB match likely failed during the parser step, and you’ll need to reassign it manually from inside the game’s Steam properties panel.
Step 11: Configure Controllers and Launch Options in Big Picture
Once your games appear in Steam, right-click each one (or a batch of them) and confirm Steam Input is either enabled and correctly mapped, or disabled if you’d rather let the emulator’s own controller configuration handle input, which is usually the better choice for emulators like Dolphin or Cemu that already have mature native controller support. Running both Steam Input and the emulator’s internal input handler at once is a common source of double inputs or unresponsive menus, so pick one layer and stick with it per system.
For systems running through RetroArch, Steam Input generally works cleanly because RetroArch expects a standard XInput-style controller layout. For GameCube emulation through Dolphin, many users disable Steam Input entirely and rely on Dolphin’s own GameCube controller profiles, since GameCube’s button layout doesn’t map cleanly onto a standard Xbox-style Steam Input template without custom remapping.
Step 12: Add More Systems With Dedicated Parsers
Repeat the parser-preview-save cycle for each additional system you want in your library. The table below covers the systems and emulators most people import through Steam ROM Manager, based on the parser templates that ship with EmuDeck’s automated Steam ROM Manager configuration.
| System | Common Emulator | Parser Type |
|---|---|---|
| SNES, Genesis, NES, GBA | RetroArch (per-core) | Glob, launches RetroArch with a core argument |
| PS1 | DuckStation or RetroArch core | Glob, direct executable or RetroArch core |
| PS2 | PCSX2 | Glob, direct executable |
| PS3 | RPCS3 (PKG parser) | Glob, matches installed PKG titles |
| GameCube / Wii | Dolphin | Glob, direct executable |
| Wii U | Cemu | Glob, direct executable |
| Switch | Ryujinx-family (Eden, Citron, Ryubing) | Glob, direct executable |
| Xbox 360 | Xenia / Xenia Canary | Glob, direct executable |
| Dreamcast | Flycast | Glob, direct executable |
| Sega Saturn | Mednafen / Kronos (via RetroArch) | Glob, RetroArch core |
| PSP | PPSSPP | Glob, direct executable |
Each row in that table is its own parser inside Steam ROM Manager. There’s no limit on how many you configure, and once they’re all set up, you can re-run preview and save across all of them together, which is how people end up with 40-emulator libraries that look, at a glance, like an ordinary Steam collection.
Steam ROM Manager vs EmuDeck’s Built-In Automation
If you’re setting this up on a Steam Deck, you’ll run into a fork in the road almost immediately: EmuDeck installs and configures Steam ROM Manager automatically, so why go through manual setup at all? The honest answer is that most Steam Deck owners shouldn’t. EmuDeck’s own documentation for Steam ROM Manager confirms its installer delivers a curated list of parsers on install and can reset Steam ROM Manager to a known-good state if something breaks, which is precisely the kind of maintenance manual users have to do by hand.
| Aspect | Manual Steam ROM Manager | EmuDeck-managed Steam ROM Manager |
|---|---|---|
| Setup time | Longer, since you build every parser yourself | Faster, parsers come pre-configured |
| Control over paths and arguments | Full control, useful for custom setups | Limited to EmuDeck’s folder structure |
| Best platform | Windows desktop PCs, custom Linux builds | Steam Deck, SteamOS handhelds |
| Parser maintenance | You fix broken parsers yourself | EmuDeck ships parser bugfixes with updates |
| Path-breakage risk after OS updates | Lower if you use stable custom paths | Has occurred after SteamOS SD card path changes |
For a Windows gaming PC that isn’t running EmuDeck at all, manual configuration is the only option, and it’s also genuinely the better fit, since you have full control over where your emulators and ROMs live rather than being locked into a specific folder convention.
Does Adding Emulators to Steam Slow Anything Down?
A reasonable worry before importing dozens of games is whether wrapping them in Steam shortcuts adds any performance overhead. It doesn’t, in any way that matters. Steam ROM Manager only writes a launch command. When you click a game, Steam runs that exact command the same way it would if you’d typed it into a terminal yourself. There’s no compatibility layer, no translation step, and no background process specific to Steam ROM Manager once the shortcut exists. The Steam Overlay does add a small, generally imperceptible amount of GPU and memory overhead, the same overhead it adds to any native Steam game, and you can disable the overlay per-title from a game’s properties if you’re chasing every last frame on demanding 3D emulators like Cemu or RPCS3.
One place performance actually can shift is GPU driver behavior. Both Nvidia and AMD control panels let you apply per-executable settings, and once an emulator is launched consistently through the same shortcut, those per-game driver profiles apply reliably every time, which isn’t always true if you’re launching an emulator from multiple different shortcuts or frontends that pass slightly different arguments.
Using Steam ROM Manager on Steam Deck and SteamOS
Even if EmuDeck manages your copy of Steam ROM Manager, understanding its manual workflow pays off the first time something breaks, and on SteamOS, something eventually does. The most frequent Steam Deck-specific failure happens after a SteamOS system update changes the SD card mount path, commonly shifting from something like /run/media/mmcblk0p1/ to a different internal path. When that happens, every parser still pointing at the old path stops finding ROMs, and Steam ROM Manager reports zero matches on a library that worked fine the day before.
Fixing Broken Paths After a SteamOS Update
The community fix for this involves a small utility called jdReplace, which performs a bulk find-and-replace across Steam ROM Manager’s configuration directory, typically .config/steam-rom-manager. You search for the old, broken path fragment and replace it with the new correct one across every parser at once, rather than editing dozens of individual configs by hand.
# Inside jdReplace
Search for: /run/media/mmcblk0p1/
Replace with: /home/deck/
Search subdirectories: enabled
Target folder: ~/.config/steam-rom-managerThis single fix resolves the majority of “Steam ROM Manager suddenly stopped finding my games” reports that show up after SteamOS updates. It’s worth bookmarking even if you’re not troubleshooting anything right now, because the failure mode tends to arrive without warning right after a system update you didn’t think would touch your emulation setup at all. If you’re new to working outside SteamOS’s console-like interface, our guide to enabling and navigating Steam Deck’s desktop mode covers the terminal access you’ll need for commands like the one above.
Steam ROM Manager Alternatives Worth Knowing About
Steam ROM Manager solves one specific problem well: getting emulated games into Steam’s own library and Big Picture interface. It’s not the only way to organize a multi-emulator collection, and depending on what you actually want, a different tool might fit better.
If your goal is a standalone, console-style frontend rather than integration with Steam specifically, dedicated launchers like LaunchBox, Playnite, and ES-DE take a different approach, each with their own scraping systems and theming options rather than relying on SteamGridDB and Steam’s shortcut format. Our comparison of LaunchBox, Playnite, and ES-DE breaks down which fits different budgets and platforms. If you’d rather boot straight into a dedicated emulation-only environment instead of running Windows or a desktop Linux session at all, a bootable distribution like Batocera replaces the entire OS rather than layering on top of one. And if what you actually want is a self-hosted, browser-accessible library that streams ROM metadata and artwork to any device on your network, RomM solves a related but different problem than Steam ROM Manager does, despite the similar name. None of these replace Steam ROM Manager if your specific goal is a unified Steam library with Big Picture and Steam Input support. They solve adjacent problems for people who don’t specifically need that.
5 Common Pitfalls When Setting Up Steam ROM Manager
Most Steam ROM Manager problems trace back to a small number of repeatable mistakes. Here are the five that account for the majority of setup failures reported across EmuDeck’s issue tracker and community forums.
- Saving while Steam is still running. This is the single most common failure. Steam ROM Manager writes to a file Steam actively holds open, and the changes either don’t take or get partially overwritten. Always fully close Steam first.
- Mixed ROM folders with no system separation. Dumping every ROM into one flat folder confuses parsers that expect one system per directory, leading to mismatched artwork and broken launch commands.
- Wrong emulator executable paths. A parser can successfully “match” a game and still fail to launch it if the executable path in the parser configuration points to the wrong install location or an outdated version after an emulator update moved its folder.
- Skipping the preview step. Saving directly without previewing means artwork mismatches and bad launch arguments get written straight into Steam, where they’re more annoying to fix.
- Running Steam Input and the emulator’s own controller config at the same time. This causes double inputs, unresponsive menus, or controllers that seem to work in Steam but not once the actual emulator loads.
Troubleshooting: 8 Steam ROM Manager Errors and Fixes
Beyond the common pitfalls above, these are the specific error conditions that show up most often once you’re past initial setup and living with the tool day to day.
- “Steam ROM Manager does not create shortcuts.” Nearly always caused by Steam still running during save. Steam holds
shortcuts.vdfopen in memory and can overwrite it with its own cached version the moment it next writes to disk, silently undoing whatever Steam ROM Manager just wrote. Close Steam completely (killall steamon Linux, Exit from the tray on Windows, not just closing the window) and re-save. - AppImage won’t open on Steam Deck. The file isn’t marked executable, which is the default state for any file transferred or downloaded fresh on Linux. Run
chmod +x Steam-ROM-Manager.AppImagefrom a terminal in Desktop Mode, then try launching it again by double-clicking or running it directly from that terminal. - Games matched but launch nothing when clicked. The parser matched the filename successfully and pulled artwork, but the executable path baked into the launch command is wrong, or it points at an emulator version that moved after an update. Re-check the path in the parser settings and re-run preview and save.
- No artwork showing up after save. The SteamGridDB API key is missing, expired, or wasn’t saved correctly in settings. Regenerate it from your SteamGridDB profile preferences page and re-enter it in Steam ROM Manager’s Image Providers settings, then re-run preview to confirm thumbnails appear before saving again.
- Parsers “fail to launch” with a network error. Community reports point to DNS resolution failures reaching github.com or githubusercontent.com during parser downloads, particularly on EmuDeck-managed setups that fetch parser templates on first run. Check your network connection, try a different DNS provider, or retry after a few minutes if GitHub itself is experiencing an outage.
- Zero games found after a system update. On Steam Deck, this is usually the SD card path issue described above, where a SteamOS update silently shifts the mount point your parsers were configured against. Check whether your ROM directory path in the parser still matches the actual current mount point, and use jdReplace to bulk-fix it if several parsers are affected at once.
- Old shortcuts still pointing to a stale AppImage location. After moving or reinstalling Steam ROM Manager, existing desktop or start-menu shortcuts may still reference the old file location, so launching them does nothing or opens a “file not found” error. Launch the AppImage or executable directly from its current folder instead, and update or recreate the shortcut afterward.
- Categories or collections disappearing after a save. Steam ROM Manager’s 2.5.30 release specifically addressed a Steam Categories bug that could wipe or scramble existing category assignments during a save. If you’re on an older build and seeing this, updating to the current release resolves it. If you’re already current and still seeing it, back up
shortcuts.vdfbefore your next save so you can restore it if the problem recurs.
Advanced Tips: Categories, Batch Re-Scraping, and Custom Grids
Once your core library is working, a few advanced moves make it easier to maintain over time. First, use Steam ROM Manager’s category assignment to automatically sort imported games into Steam collections by system, so your SNES games, PS2 games, and Switch games each land in their own folder inside your library rather than one undifferentiated pile of non-Steam shortcuts.
Second, when you add new ROMs to an existing folder, you don’t need to reconfigure anything. Just re-run preview and save on the relevant parser. Steam ROM Manager only adds the new matches without disturbing existing entries, artwork, or your manual Steam Input configuration on already-imported games.
Third, for any game where the automatic SteamGridDB match picked the wrong art style or region variant, right-click the game inside your actual Steam library (not inside Steam ROM Manager) and use Steam’s native “Manage > Set custom artwork” option, which also pulls from SteamGridDB and lets you browse alternatives directly, without needing to redo an entire parser pass just to fix one game’s cover.
Build a Complete Multi-Emulator Steam Library: A Working Example
Here’s a full walkthrough tying every step together, using a realistic four-system library as the working project: SNES through RetroArch, GameCube through Dolphin, PS2 through PCSX2, and Wii U through Cemu.
Start with the folder structure below, keeping every system separate:
D:\ROMs\
snes\ (RetroArch, snes9x core)
gamecube\ (Dolphin)
ps2\ (PCSX2)
wiiu\ (Cemu)
D:\Emulators\
RetroArch\retroarch.exe
Dolphin\Dolphin.exe
PCSX2\pcsx2-qt.exe
Cemu\Cemu.exeInside Steam ROM Manager, build four parsers, one per system, pointing each ROM directory at its matching folder and each executable at its matching emulator. Enable SteamGridDB with your API key across all four. Run Preview on each parser and confirm artwork and launch commands look correct, paying particular attention to Cemu and Dolphin since both need the actual game file passed as an argument in a specific format that varies depending on whether you’re loading an ISO, WUX, or extracted game folder.
Fully close Steam. Run Save across all four parsers. Reopen Steam and confirm all four systems’ games appear with artwork in your library. Test one game per system by launching it directly from Steam rather than from the emulator itself, since that’s the real test of whether the shortcut, the launch arguments, and the controller configuration are all working together. If GameCube controls feel wrong through Steam Input, disable Steam Input for that specific title and let Dolphin’s native GameCube controller profile take over instead. That four-system build, done properly, takes about 45 minutes to an hour for a first-timer and considerably less on repeat setups once you’re familiar with the parser workflow.
Once the four-system build is confirmed working, expanding it is just repetition. Add a PS2 parser pointed at PCSX2, a Switch parser pointed at whichever fork you’ve settled on, and a Dreamcast parser pointed at Flycast, following the exact same pattern: separate folder, dedicated parser, preview before save. Each additional system adds only a few minutes once the workflow is familiar, and the folder-per-system convention from the very first step is what keeps a 20-system library just as manageable as the original four. For anyone building this out on a handheld rather than a desktop tower, it’s worth cross-referencing how your specific device handles storage and thermals under sustained emulation load, since a heavier library changes those considerations more than the Steam ROM Manager configuration itself does.
The end state is a Steam library, browsable in Big Picture Mode with a controller from the couch, where a GameCube classic, a PS2 favorite, and a Wii U exclusive all sit in the same grid as whatever you last bought during a Steam sale. That’s the entire point of running Steam ROM Manager in the first place: one library, one launcher, one place to browse everything you own and everything you’ve preserved.
Frequently Asked Questions
Is Steam ROM Manager legal to use?
Yes. The application itself only organizes and launches software you already have installed. It doesn’t distribute ROMs or copyrighted game files. Legality of the ROMs themselves depends on whether you dumped them from games you own, which varies by jurisdiction.
Do I need to buy anything to use Steam ROM Manager?
No. The application, the SteamGridDB account, and the API key are all free. You do need your own legally obtained ROMs and, for some systems, BIOS files dumped from hardware you own.
Does Steam ROM Manager work on macOS?
The project’s officially distributed builds focus on Windows and Linux, including SteamOS. Mac users generally aren’t part of the primary supported platform list and would need to build from source if attempting to run it there.
Why does Steam show my emulated games as “non-Steam games”?
Because that’s technically what they are. Steam ROM Manager automates the exact same non-Steam shortcut mechanism Steam has always supported. It just fills in the launch command, artwork, and categorization automatically instead of you doing it by hand for every title.
Can I use Steam ROM Manager without EmuDeck?
Yes. EmuDeck is a convenience layer that installs and configures Steam ROM Manager automatically alongside a full emulator suite on Steam Deck. On a regular Windows PC, or on a Linux build you’ve configured yourself, you install and configure Steam ROM Manager manually exactly as described in this guide.
What do I do if artwork doesn’t match my games correctly?
Check that fuzzy title matching is enabled and that your ROM filenames are reasonably close to official game titles. For persistent mismatches, use Steam’s native “Set custom artwork” option on the individual game after import to manually pick the correct SteamGridDB entry.
How do I update Steam ROM Manager to a newer version?
Download the latest release from the SteamGridDB GitHub releases page and install over your existing copy on Windows, or replace the AppImage file on Linux. Your parser configurations are stored separately and generally survive an update, though it’s good practice to back up your .config/steam-rom-manager folder (or the equivalent AppData folder on Windows) before a major version jump.
Why did my whole library disappear after a Steam or SteamOS update?
This is almost always a path issue, not a data-loss issue. Your parsers are likely still pointing at ROM or emulator paths that changed after the update. Check and correct the paths in each affected parser, then re-run preview and save.
Related Coverage
- Pokemon Emulator Online Setup: 12 Steps, 45 Min [2026]
- PS5 Remote Play Setup: PS5 Pro vs PS5 in 12 Steps [2026]
- Pokémon Infinite Fusion on Android: JoiPlay Setup in 13 Steps [2026]
- UEFN Setup: Build a Fortnite Island in 12 Steps [2026]
- PS5 Pro Enhanced Games List: PSSR 2.0 Setup in 13 Steps [2026]
