Retrode 2026: Dump Carts & Saves in 12 Steps, 30 Min

There is a small grey box, roughly the footprint of a paperback, that will turn a Super Nintendo cartridge into a folder of files. You plug it into a USB port, you slot in the cartridge you spent 1994 blowing into, and it mounts like a thumb drive. No emulator. No ripping software. No mysterious download the ROM you supposedly already own step that ends with a copyright attorney clearing his throat. The box is the Retrode, and it has been performing this exact trick, essentially unchanged, since a German physicist got bored with his cartridge shelf in 2009.

This tutorial walks you through the whole ritual: connecting the unit, mounting a cart, verifying the dump, pulling your battery-backed saves off before the CR2032 dies, editing the config file, and — for the brave — reflashing firmware that has not seen a meaningful update in roughly a decade. It ends with a complete, copy-pasteable configuration. Along the way, one honest caveat: the thing people type into a search box as retrode in 2026 is the Retrode 2. The much-discussed Retrode 3 is, as of this writing, a set of GitHub repositories doing a convincing impression of a product. We will get to that indignity in its own section.

What It Is (and Refuses to Be)

Not an emulator, not a ripper — a bridge

The single most useful thing to understand before you buy one is what the Retrode is not. It is not an emulator; it contains no cores, plays no games, and outputs no video. It is not a flash cart, an ODE, or a menu system. It is a bridge. The cartridge you insert is the storage medium; the Retrode exposes the silicon inside it — the mask ROM, and where present the battery-backed SRAM — as ordinary files on a virtual USB drive. Your operating system sees a removable disk. Your emulator opens a .sfc or .bin off that disk exactly as it would open any other file. The maker's own framing is blunt: it is for people who "want to keep enjoying their own original games," and it is explicitly "not for pirates." Whether that disclaimer survives contact with reality is a question for a different article; legally, dumping a cartridge you physically own for personal use is the least adventurous thing in this entire hobby.

Two devices wearing one name

There are two Retrodes, and conflating them is the fastest way to buy the wrong thing. The Retrode 2 is real, shipping, and sitting in a warehouse right now: an 8-bit Atmel microcontroller wearing two cartridge slots and four controller ports. The Retrode 3 is a Linux single-board computer that DragonBox has been promising for years, targeted — again — for "end of the year," priced under €100, and available for exactly one action: signing up to be notified. Everything in the walkthrough below concerns the Retrode 2. If a listing says "Retrode 3" and offers a Buy button, close the tab.

A brief, faintly litigious history

The device was conceived in 2009 by Matthias Hullin, who floated it on the OpenPandora forums as a way to feed real cartridges into emulators without the tedium of a dedicated dumper. It was produced commercially under Retrode UG (haftungsbeschränkt — the German equivalent of a shoestring limited company), which ceased trading in the summer of 2013. The second revision, the Retrode 2, was resurrected in March 2015 by Michael Mrozek's OpenPandora GmbH, the same operation behind the DragonBox store and the Pyra handheld. That lineage matters: it explains why the hardware is frozen, why the software is open, and why the successor keeps almost-existing. You are buying a well-loved orphan, not a supported product. For the canonical spec sheet and the AT90USB646 microcontroller detail, the Wikipedia entry for the Retrode is accurate and unusually well-cited.

Prerequisites & Exact Versions

The hardware you actually need

The shopping list is short and the prices, in mid-2026, are stable. A Retrode 2 is $99.99 from Stone Age Gamer in the US, or €64.90 from DragonBox in Europe. The box contains the unit, a USB-A cable, and a single-sheet instruction card — that is all. If you want anything beyond SNES/Super Famicom and Sega Mega Drive/Genesis carts, you need plug-in adapters, sold separately at $39.99 each (or €25 each, €65 for the three-pack). The official current adapter set is N64, Game Boy family, and Sega Master System; more on their individual quirks later. You also need the cartridges themselves, a free USB port, and — this is not optional — reasonably clean cartridge contacts. A cotton swab and 99% isopropyl alcohol will save you more grief than any config setting.

Software and operating-system versions

The Retrode 2 is a driverless composite USB device, so the software requirements are almost insultingly light. Any host with a USB port and a FAT-reading filesystem works: Windows 10 or 11, macOS (any release this decade), or Linux with the standard usb-storage and usbhid kernel modules — which is to say, every distribution shipped since roughly 2011. Historically it even ran on the OpenPandora and Caanoo handhelds, which tells you how modest its demands are. You will want a checksum tool for verification: sha1sum from GNU coreutils on Linux/macOS, or a right-click hasher like HashCheck on Windows. Optionally, install an emulator to test dumps immediately — RetroArch with a Super Nintendo core, or standalone Snes9x and Genesis Plus GX. The libretro documentation covers core installation if you go the RetroArch route.

Firmware, and why the version is frozen

The Retrode 2 ships with firmware that has effectively stopped evolving. The last builds are 0.18c (stable) and 0.18d beta 3 (~2016), both built on Dean Camera's LUFA USB stack. The 0.18 line brought improved N64 and GBA size detection, a LUFA library refresh, a Master System plug-in bug-fix, and — genuinely useful — Master System SRAM reading. Ninety-nine percent of readers should never touch this. But you should know the version you have, because a couple of the config keys below only exist from firmware 0.17g onward, and because the flashing procedure in the firmware section assumes the AT90USB646 DFU bootloader. If your unit is second-hand, assume 0.18c until proven otherwise.

How It Works: A USB Drive From Silicon

Mass storage and HID, in a single plug

When you connect a Retrode 2, it enumerates as a composite USB device — two logical devices down one cable. The first is a USB Mass Storage endpoint: this is the virtual drive that holds your ROM and save files. The second is a bank of USB HID gamepads, because the four controller ports on the sides are wired straight through to the host. Plug a real SNES pad into the Retrode and your PC sees a generic gamepad; this is how people use the device as a controller adapter entirely separate from dumping. The composite design is why no drivers are needed anywhere — the OS already knows how to talk to mass-storage and HID class devices.

The AT90USB646, and why ROM is read-only

Inside is an Atmel 8-bit AVR microcontroller, the AT90USB646. It reads the cartridge's address and data lines, presents the mask ROM as a file, and — crucially — cannot write to it. This is not a limitation the makers imposed to placate lawyers; a mask ROM is physically Read-Only Memory. The maker's FAQ answers the inevitable "can I write a ROM back?" with the driest possible logic: ROM stands for Read Only Memory, hence, no. What the microcontroller can write is battery-backed SRAM — your saves — which is why the save-backup workflow exists and the ROM-restore workflow does not.

What the virtual drive looks like

Insert a Super Nintendo cartridge and the drive populates with files named from the cart's internal header: a .sfc for the ROM and, if the cart has a save battery, a .srm for the SRAM. Sega carts produce a .bin and, where applicable, a .srm. There is also a RETRODE.CFG text file in the root — the entire configuration surface of the device. An onboard LED lights during ROM and RAM access and blinks when the config file is written. A representative Linux mount looks like this — note the two logical devices appearing together, storage and input:

$ dmesg | tail -n 6
[ 1234.567890] usb 1-2: new full-speed USB device number 7 using xhci_hcd
[ 1234.789012] usb-storage 1-2:1.0: USB Mass Storage device detected
[ 1234.890123] scsi host6: usb-storage 1-2:1.0
[ 1235.900234] scsi 6:0:0:0: Direct-Access     Retrode2 RETRODE  0001 PQ: 0 ANSI: 4
[ 1235.912345] sd 6:0:0:0: [sdb] Attached SCSI removable disk
[ 1235.923456] input: Retrode2 Gamepad as /devices/pci0000:00/.../input/input42

And the drive contents, with a Super Nintendo cart inserted:

$ ls -la /media/retrode
total 3076
-rwxr-xr-x 1 user user 3145728 Jan  1  2016 'SUPER MARIOWORLD.SFC'
-rwxr-xr-x 1 user user    2048 Jan  1  2016 'SUPER MARIOWORLD.SRM'
-rwxr-xr-x 1 user user     412 Jan  1  2016  RETRODE.CFG

The 12-Step Dump Walkthrough

This is the core procedure — connect the unit, mount a cart, verify, and copy off a clean dump. Every step carries a reason, because "it usually works" is not a preservation standard. Budget about thirty minutes for your first run including setup; subsequent carts take two minutes each.

1. Clean the cartridge contacts. Cotton swab, 99% isopropyl, gentle scrub of the edge connector, let it dry. Why: the overwhelming majority of bad dumps are dirty-contact dumps, not device faults. Do this first and you eliminate the single biggest failure mode before it happens.
2. Inspect the two slots. The lower, shorter slot takes Sega Mega Drive/Genesis carts; the upper, wider slot takes SNES/Super Famicom. Why: forcing a cart into the wrong slot bends pins. The slots are keyed differently for a reason.
3. Insert the cartridge fully, label facing you. Seat it with steady pressure until it stops. Why: a partially seated cart reads intermittently and produces a truncated file that looks valid until it crashes mid-level.
4. Connect the Retrode to the host via USB. Use a rear/motherboard port on a desktop, not an unpowered hub. Why: the device draws its power from the bus, and a marginal hub causes read errors that masquerade as bad carts.
5. Confirm the drive mounted. Check for the removable volume (Explorer/Finder) or run the dmesg/lsblk check above. Why: if it did not enumerate, nothing after this matters — stop and troubleshoot the connection now.
6. Open the volume and read the filename. The file should be named from the cart's internal header, e.g. SUPER MARIOWORLD.SFC. Why: a sensible name means the header parsed correctly. A garbage name or a zero-byte file signals a bad read before you have wasted time copying.
7. Note the reported file size. A 4 Mbit cart is 512 KB; a 32 Mbit cart is 4 MB. Why: if the size is implausibly small or a suspiciously round wrong number, detection failed — jump to the config section and set forceSize.
8. Copy the ROM to your host, do not open it in place. Drag it to a working folder, or cp it. Why: emulating directly off the Retrode hammers the cart's contacts and, on save-capable carts, risks writing back. Copy once, then work from the copy.
9. Generate a checksum of the copy. Run sha1sum (or your hasher of choice) against the file you just copied. Why: a hash is the only objective proof you have a good dump. "It booted" is not verification.
10. Dump the same cart a second time and compare hashes. Re-seat, re-copy, re-hash. Why: two identical hashes from two independent reads is your evidence the dump is stable and repeatable — the poor man's error correction.
11. Eject the volume before removing the cart. Use the OS "safely remove" action, or press the RESET button (the lower of the two) to force a remount. Why: hot-yanking a cart mid-access can corrupt the on-cartridge save. The maker's guide is explicit: unplug or eject first.
12. Test the copy in an emulator. Load your verified .sfc/.bin into RetroArch or a standalone emulator. Why: the final proof. A clean hash plus a clean boot means the job is done and the cart can go back on the shelf.

The copy-and-verify pair, on the command line, looks like this:

$ cp "/media/retrode/SUPER MARIOWORLD.SFC" ~/dumps/
$ cd ~/dumps
$ sha1sum "SUPER MARIOWORLD.SFC"
3b8f6c1e9a7d40f2b5c8...c21a  SUPER MARIOWORLD.SFC
# Re-seat the cart, copy again as pass2.sfc, then:
$ sha1sum pass2.sfc
3b8f6c1e9a7d40f2b5c8...c21a  pass2.sfc
# Identical hashes = a stable, trustworthy dump.

Once you have a folder of verified ROMs, they behave like any other legally-obtained backup. Drop them into a Batocera build on an old PC, feed them to a RetroPie box, or sync them to a cheap handheld like the Miyoo Mini Plus for the commute. The Retrode's job ends the moment the hash checks out.

Backing Up Saves Without Corruption

ROM is read-only; SRAM is not

The reason a lot of people buy a Retrode is not the ROM at all — it is the save file. Every SNES and Genesis cart with a little coin-cell battery is running a countdown to oblivion. When that CR2032 dies, your hundred-hour Chrono Trigger file, your maxed-out Shining Force roster, your childhood Zelda save all evaporate. The battery-backed SRAM on those carts is exactly what the Retrode can read and write, unlike the immutable ROM. That distinction is the whole game: you cannot restore a ROM, but you can absolutely back up — and, carefully, restore — a save.

Copying a .srm off the cart

If the cart has a save, the virtual drive shows a .srm alongside the ROM. Copying it off is trivial — it is just a small file, typically 2 KB to 32 KB — but treat it with the same verify-twice discipline as a ROM. The .srm format the Retrode produces is the same raw SRAM layout most emulators expect, so a save pulled from a real cart usually drops straight into RetroArch or Snes9x with no conversion. This is genuinely the device's killer feature: preservation of the one thing that is actively decaying.

$ cp "/media/retrode/SUPER MARIOWORLD.SRM" ~/saves/
$ ls -l ~/saves
-rwxr-xr-x 1 user user 2048 Jul 17  2026 'SUPER MARIOWORLD.SRM'
# 2 KB of SRAM — small, irreplaceable, now backed up.

Writing a save back, and the sramReadonly switch

Restoring a save onto a cart is possible but deliberately gated. By default the Retrode mounts SRAM as write-protected — the guide states plainly that RAM files are "by default write-protected." To write a .srm back onto a cartridge, you set sramReadonly to 0 in the config file, remount, and copy your save file over the cart's .srm. Do this only when you mean it. A botched write, an interrupted copy, or a hot-swap during the operation can leave the cart's save in a worse state than the dying battery would have. Back up the existing save first, always. Note also that some newer adapters — N64 and GBA in particular — list save support as "firmware pending," so the write path is not universal across every cartridge the Retrode can physically read.

Tuning RETRODE.CFG

Where the file lives and how it is read

The Retrode's entire configuration is a single plain-text file, RETRODE.CFG, sitting in the root of the virtual drive. You edit it in any text editor, save it, and the device reads it on the next power-up or RESET — the LED blinks once when the file is parsed and written back. The configuration feature has existed since firmware 0.17g. One honest caveat: the official documentation page for this file now redirects to the store front and no longer serves the reference, so the examples here are illustrative of the format and use key names confirmed against the firmware. Treat exact syntax as a starting point and let the device's own behavior — does the LED blink, did the setting take — be the arbiter.

The keys that matter

You will realistically ever touch a handful of keys. sramReadonly (0/1) is the save write-protect discussed above. forceSystem overrides console auto-detection — set it to GG, for instance, when a Game Gear cart on the SMS adapter refuses to identify itself. forceSize overrides a mis-read ROM size, the cure for a cart that dumps as the wrong length. forceMapper overrides the detected memory map (LoROM vs HiROM) when a dump looks byte-shifted or scrambled. Rounding out the set are filenameChksum (append the internal checksum to filenames), detectionDelay (wait longer after insertion before reading — a lifesaver for marginal contacts), segaSram16bit (treat Sega SRAM as 16-bit wide), and the extension keys snesRomExt, segaRomExt, and sramExt.

A worked example: forcing Game Gear

Say your Sega Master System adapter reads a Game Gear cart but tags it as the wrong system, so the filename is generic and the dump will not run in your handheld. You force the system and give the contacts a beat longer to settle:

# RETRODE.CFG (illustrative; keys valid on firmware >= 0.17g)
sramReadonly    1
forceSystem     GG
detectionDelay  500

Save, eject, press RESET, re-read the drive. The file should now carry a Game Gear identity. If forceSystem GG is ignored, you are on an older firmware — the 0.18d beta line specifically fixed a "forceSystem GG not recognized" bug — and the firmware section is where you go next.

Firmware: Frozen at 0.18

Why it is stuck, and whether you should care

The Retrode 2's firmware has been frozen at the 0.18 line — 0.18c stable, 0.18d beta 3 — since around 2016. This is not neglect so much as completion: the device does what it was designed to do, the codebase is small, and the maintainer's energy has migrated to the Retrode 3. For the overwhelming majority of users the correct number of times to flash firmware is zero. You would only reflash to recover from a corrupted update, to move from stable to the 0.18d beta for its bug-fixes, or to install community firmware. If your dumps verify and your saves copy, leave it alone.

Entering DFU mode: the HWB dance

Flashing requires putting the AT90USB646 into its DFU bootloader, and that is a physical button sequence, not a software command. The unit has two buttons: number 7 is HWB (used for custom firmware functions), number 8 is RESET. To enter DFU: hold HWB, press and release RESET, then release HWB. The device now enumerates as an Atmel DFU bootloader — a completely different USB identity from its normal composite mode. On Linux you can confirm it:

$ lsusb | grep -i atmel
Bus 001 Device 012: ID 03eb:2ff9 Atmel Corp. atmega/at90usb DFU bootloader

That 03eb:2ff9 is the well-documented at90usb646 bootloader ID. Seeing it means you are in the right state to flash; not seeing it means the button dance did not take — try again before touching any flashing tool.

Flashing with dfu-programmer or FLIP

On Windows, Atmel's FLIP utility gives you a GUI: select the AT90USB646 target, load the .hex, erase, program, verify, reset. On Linux or macOS, dfu-programmer does the same job from the terminal, and it is the cleaner path:

$ dfu-programmer at90usb646 erase
$ dfu-programmer at90usb646 flash retrode-0.18c.hex
Validating...
32418 bytes used (49.46%)
$ dfu-programmer at90usb646 reset

After the reset the device leaves DFU mode and re-enumerates as the normal composite Retrode. Verify by mounting a known-good cart and checking the hash against your earlier dump. If the flash fails halfway, do not panic and do not unplug randomly — re-enter DFU with the HWB dance and re-run erase then flash. The AT90USB646 bootloader lives in protected memory and is very hard to brick from userspace.

Plug-In Adapters: N64, GB, SMS

Nintendo 64: ROMs yes, saves pending

The N64 adapter slots onto the Retrode 2 and reads Nintendo 64 cartridge ROMs cleanly. The catch is saves: the adapter's save support is listed as "firmware pending," so do not count on pulling your Ocarina of Time file off through it today. Two practical notes from the official adapter page: the N64 adapter runs at 3.3V, supports up to two controllers through the pass-through ports, and — importantly — should be connected to the Retrode before you plug the Retrode into USB. Enumerate the adapter first, then power the bus.

Game Boy, Color, and Advance

The Game Boy adapter covers the whole handheld line — original Game Boy, Game Boy Color, and Game Boy Advance — for ROM reads. Saves are partial: GB and GBC SRAM reads work, while GBA SRAM and flash saves are in the "pending" bucket. Watch the voltage: GB and GBC carts are 5V devices, GBA carts are 3.3V, and the adapter handles the switch, but it is a reminder that these are genuinely different electrical targets sharing one physical slot. For a Game Boy library this adapter is the single most useful accessory after the base unit.

Master System, and the adapters that no longer exist

The Sega Master System adapter reads SMS cartridge ROMs; the firmware 0.18 line added SMS SRAM reading, so saves are further along here than on N64 or GBA. One quirk: SMS cartridges frequently lack an internal header title, so the Retrode cannot name the file from the cart — expect a generic filename you will rename by hand. Beyond these three current adapters, a number of exotic ones existed historically and have been discontinued because their cartridge connectors are simply no longer manufacturable. If you see a listing for some rare adapter at a rare price, understand you are buying scarcity, not support. For the authoritative current list and each adapter's voltage and save-status notes, the official plug-in adapters page is the source of truth.

Five Pitfalls to Avoid

Hot-swapping, and other ways to eat a save

Pitfall 1 — hot-swapping cartridges. Yanking one cart and jamming in the next while the drive is mounted is the classic mistake. The user guide is explicit that this is "possible, but it can potentially damage on-cartridge savegames," and recommends you "eject/unplug the Retrode first." Fix: eject the volume or press RESET between every cart. Two seconds of patience versus a corrupted save is not a close call. Pitfall 2 — writing a save back with no backup. The moment you set sramReadonly 0, you are one interrupted copy away from destroying a save. Fix: copy the existing .srm off before you flip the switch, so a failed restore costs you nothing.

Trusting a single dump

Pitfall 3 — accepting one read as gospel. A dump that boots is not a dump that is correct; contact noise can flip bits that only surface in a late-game room you will not reach for forty hours. Fix: dump twice, hash both, and compare — identical SHA-1s or the read gets redone. This is the entire reason steps 9 and 10 exist in the walkthrough. Bit-rot in your archive is silent; the checksum is the smoke detector.

Co-processor carts and dirty contacts

Pitfall 4 — assuming every enhancement chip dumps. Here the Retrode splits the SNES library in two. Cartridges built around the Super FX (Star Fox, Yoshi's Island) or DSP1 (Pilotwings, Super Mario Kart) dump fine — the Retrode reads the ROM and your emulator handles the chip. But cartridges built around the SA-1 (Super Mario RPG, Kirby Super Star, Kirby's Dream Land 3), the S-DD1 (Star Ocean, Street Fighter Alpha 2), or Sega's Virtua Processor (Virtua Racing) are officially unsupported and will not produce a clean dump. Fix: know before you insert — if the cart is on the SA-1/S-DD1/SVP list, the Retrode is the wrong tool and you want a Sanni-style cart reader instead. Pitfall 5 — blaming the device for dirty contacts. Intermittent detection, wrong sizes, garbage filenames: nine times in ten it is the connector, not the Retrode. Fix: isopropyl and a swab first, detectionDelay second, RMA never.

Troubleshooting Table

How to read this table

Symptoms on the left, the most likely cause in the middle, the fix on the right. Work top to bottom; the entries are ordered roughly by how often each actually happens, and "clean the contacts" appears more than once because it deserves to.

Detection and mounting problems

Dump-quality and save problems

Advanced Tips

Batch dumping with a shell loop

Once you have a stack of carts and a rhythm, scripting the copy-and-hash removes the tedium. The loop below copies whatever ROM files the Retrode currently exposes into a dated archive and appends every checksum to a running log, so your whole session is verifiable after the fact. Swap a cart, RESET, re-run — or wrap the whole thing in a prompt-to-continue if you want it hands-off.

#!/bin/sh
# Copy every ROM the Retrode currently exposes, with a checksum log.
SRC=/media/retrode
DEST="$HOME/retrode-dumps"
mkdir -p "$DEST"
for f in "$SRC"/*.SFC "$SRC"/*.BIN "$SRC"/*.SRM; do
  [ -e "$f" ] || continue
  name=$(basename "$f")
  cp -v "$f" "$DEST/$name"
  sha1sum "$DEST/$name" | tee -a "$DEST/checksums.sha1"
done
echo "Done. Log: $DEST/checksums.sha1"

Verifying against No-Intro and Redump

A hash you never compare to anything is a diary entry, not verification. The next level of rigor is matching your SHA-1 against a preservation database. The No-Intro project maintains reference checksums for cartridge ROMs; a tool like ClrMamePro or a No-Intro DAT lets you confirm your dump byte-for-byte matches the community's known-good reference. When your hash matches the DAT, you have not just a working dump — you have a verified one, indistinguishable from the canonical copy. That is the difference between "I made a backup" and "I preserved the cartridge," a distinction institutions take seriously; the University of Maryland's libraries have written about using exactly this class of device in their SNES preservation work.

Using the Retrode as a controller adapter

Because the controller ports enumerate as USB HID gamepads independent of the cartridge slots, the Retrode doubles as a very good adapter for real SNES and Sega pads — no cartridge required. Plug it in, plug in a controller, and it appears to your OS and emulator as a standard gamepad. Both SNES and Sega 3- and 6-button pads are supported; the SNES mouse works, but only in the left port. If you are already dumping your carts, you may as well retire your flaky third-party USB pad and play with the genuine article you just backed up.

The Retrode 3 & Complete Config

What DragonBox is promising

The Retrode 3 is the successor that will, apparently, always be arriving. DragonBox lists it at under €100, targeted for "end of the year," available only as a notify-me pre-registration — Out of Stock is its permanent condition. On paper it is a genuine leap: a Linux single-board computer running Debian with built-in Wi-Fi, enumerating as a USB-Ethernet device so the entire interface runs in a web browser with no drivers on any OS. It adds a third slot — NES, which the Retrode 2 never supported — alongside SNES/SFC and Mega Drive/Genesis, reads ROM and SRAM, and, unlike its read-only ancestor, can write flash carts (Mega Drive's DragonDrive works now; SNES and Lynx flashing are promised "when it ships"). It is billed as "practically unbrickable" and "fully open source and therefore future-proof."

The repos are real; the product is not (yet)

Here the deadpan writes itself. The Retrode 3's own store page cannot agree with itself on the processor — the opening description says MIPS, the body a few paragraphs down says it has "its own ARM processor and a Linux operating system (Debian)." Pick one. What is unambiguous is that the software exists in the open: four public repositories under DragonBox-Shop — retrode3-oscr (a Linux adaptation of Sanni's Open Source Cartridge Reader), retrode3-kernel, retrode3 (the Debian userspace), and retrode3-hardware. The OSCR foundation means Sanni Cart Reader plugins are cross-compatible in both directions. DragonBox has posted that it has "10 fully working prototypes" and is "looking for developers," which is either an encouraging sign of an imminent launch or a years-long status quo, depending on your optimism. The upstream project it builds on — Sanni's Open Source Cartridge Reader — is very much alive and shipping, and the retrode3-oscr repository is real code you can read today. If you want an FPGA-accurate way to play original carts rather than dump them, that is a different device class entirely — see our coverage of the Analogue 3D and its firmware saga for where that road goes. For the Retrode 2's own answers to the co-processor and controller questions, the official Retrode FAQ remains the primary source, and the full user guide is archived on the Internet Archive.

The complete working configuration

To close, here is a complete RETRODE.CFG with every confirmed key, commented, set to sane defaults — the file to drop in the root of your Retrode 2's virtual drive. It is illustrative of the format (the official CFG reference has gone offline), but the key names are valid on firmware 0.17g and later. Uncomment only what you need; the defaults are correct for the vast majority of carts.

# ------------------------------------------------------------
# RETRODE.CFG  —  complete working example (Retrode 2, fw 0.18)
# Place in the ROOT of the Retrode's virtual drive.
# Parsed on power-up / RESET; the LED blinks once when written.
# ------------------------------------------------------------

# Saves are write-protected by default. Set 0 ONLY when you
# deliberately intend to write a .srm back onto a cartridge.
sramReadonly      1

# Auto-detect the console. Force only for oddballs the header
# cannot identify (e.g. GG = Game Gear on the SMS adapter).
# forceSystem     auto

# Override the detected ROM size (in Mbit) for mis-sized carts.
# forceSize       0

# Override the memory mapper (LoROM/HiROM) if a dump looks shifted.
# forceMapper     auto

# Append the ROM's internal checksum to the filename, for sorting.
filenameChksum    0

# Milliseconds to wait after insertion before reading. Raise this
# if a cart with marginal contacts intermittently mis-detects.
detectionDelay    0

# Treat Sega SRAM as 16-bit wide (some Mega Drive saves need it).
segaSram16bit     0

# File extensions the Retrode hands to your OS.
snesRomExt        SFC
segaRomExt        BIN
sramExt           SRM
# ------------------------------------------------------------

That is the entire device, really: a read-only window onto silicon you already own, a writable back door for the saves that are dying, and a text file with ten knobs. It is not glamorous, it has not been updated in a decade, and its successor has been six months away for years. But it does the one job — turning a cartridge into a verified, preserved file — as well in 2026 as it did in 2012. For a hobby drowning in vaporware, a boring device that simply works is worth $99.99.