Retrode 2026: Dump SNES & Genesis Carts, 12 Steps

There is a specific flavor of disappointment reserved for the moment you discover that your childhood Chrono Trigger cartridge has a battery inside it, that the battery is now thirty years old, and that thirty-year-old batteries do not care about your nostalgia. The save is gone. The next thing to go will be the game itself, one oxidized contact at a time. Emulation solved the how do I play this problem two decades ago. It never solved the how do I get my copy — my saves, my region, my exact revision — off the plastic and onto something that will still exist in 2040 problem. That is the problem the Retrode was built to solve, and it has been quietly, stubbornly solving it since 2009.

The Retrode is a USB cartridge reader. You push a Super Nintendo or Sega Genesis cartridge into it, plug it into a computer, and the cartridge appears as a USB flash drive with the ROM sitting on it as a file you can drag off. No soldering, no photographing chips through a microscope, no proprietary uploader. It is the most boring-to-operate piece of preservation hardware ever made, and on this site that is the highest compliment we know how to pay. This guide covers the whole apparatus: the shipping Retrode 2 you can buy today, the twelve-step dumping workflow, the config file, the firmware, the plug-in adapters, the failure modes — and the Retrode 3, the MIPS-and-Debian successor due before the end of 2026 that quietly rewrites the premise.

What the Retrode Actually Is

Before you spend money, understand exactly what you are buying, because the Retrode is narrower and more honest than the marketing-brain part of you wants it to be. It reads memory. That is the entire trick. Everything good and everything frustrating about the device follows from that one sentence.

The one-sentence version

Per the manufacturer's own official FAQ, the Retrode "wraps whatever memory chips there are on the cartridge into virtual files on a USB drive, and makes the gamepads appear as USB HID-class controllers." Read that twice, because it tells you what the device is and — more usefully — what it is not. It is a composite USB device: one part mass-storage endpoint, one part game controller. Plug it in and your operating system sees a small removable disk and, if a controller is attached, a bog-standard HID gamepad. There is no driver to install. There is no companion app to update. Windows, macOS, Linux, and a couple of genuinely obscure targets (the Pandora and Caanoo handhelds were explicitly supported in the manual) all mount it, because they all already know how to mount a thumb drive. The Retrode does not innovate on the software side. It refuses to. That refusal is the product.

The corollary is the part people trip over: ROM is Read-Only Memory, and the FAQ is blunt about it — "'ROM' stands for Read Only Memory, hence: no." You cannot write a ROM back to a cartridge with a Retrode. You can, however, rewrite the SRAM — the battery-backed save memory — on many carts, which means you can pull a save off, edit it, and push it back. Dumping the game is a read; restoring a save is a write; the Retrode does both within those lanes and stays out of everything else.

Retrode 2 versus Retrode 3 — what you can actually hold

Two devices share the name and you should not confuse them. The Retrode 2 is the shipping product. It costs $99.99 at Stone Age Gamer in the US, it is built around an 8-bit Atmel AVR microcontroller (the AT90USB646), it presents itself as USB mass storage, and it has been on sale in this form since 2015. It is the device this tutorial is about, because it is the one you can put a cartridge into this afternoon.

The Retrode 3 is the successor, and as of mid-2026 it is not for sale. It targets availability by the end of 2026 at a price under €100, it runs Debian Linux on a MIPS processor with built-in Wi-Fi, and it talks to your computer as a USB-Ethernet device that you drive from a web browser. It is real — the source is on GitHub and the pre-registration page is live — but it is not a thing you can buy yet. We give it a full section near the end. For now: if you want to dump a cartridge today, you want a Retrode 2.

The legal part nobody reads

The Machine is not your lawyer, and this is lore, not counsel. But the lore matters. Dumping a cartridge you physically own, for your own use, is a categorically different act from downloading a stranger's ROM off a warez board, and the difference lives in copyright's reproduction and distribution rights, not in the act of reading a chip. The Retrode circumvents nothing: a bare mask ROM on a 1992 cartridge carries no technological protection measure, so the DMCA's §1201 anti-circumvention machinery — the thing that makes ripping an encrypted Blu-ray legally spicy — simply has no surface to grab. You are reading unencrypted memory the way the console itself reads it. Whether a personal archival copy is affirmatively permitted is genuinely unsettled in the US (§117's archival provision was written for "computer programs," and whether a game ROM qualifies is a debate lawyers enjoy more than you will), but the practical, moral, and preservationist case for dumping your own carts is about as strong as gray areas get. Keep your dumps to yourself, don't sell them, don't seed them, and the lore stays comfortably on your side.

Prerequisites: Hardware & Software

A dump only ever preserves what you actually own, so this is where you assemble the pieces. Nothing here is exotic, but the version numbers and the caveats matter more than the shopping list.

The hardware you need

The core kit is short. You need a Retrode 2 ($99.99 at Stone Age Gamer; also sold through DragonBox in the EU), which ships with the unit, a USB-A cable, and a single-sheet instruction card. That is it in the box — the "additional adapters are sold separately" line on every retailer page is not upselling, it is a fact of the platform. You need original SNES/Super Famicom or Sega Genesis/Mega Drive cartridges, because those are the two slots physically built into the unit (the lower, shorter slot takes Genesis/Mega Drive; the upper, wider slot takes SNES/SFC). You need a host computer with a free USB port — literally any machine from the last fifteen years, since the device is driverless. And you want, though do not strictly need, isopropyl alcohol (90%+) and lint-free swabs, because the single biggest determinant of a clean dump is clean cartridge contacts.

Optional but relevant: the three plug-in adapters — N64, Game Boy/GBC/GBA (GBx), and Sega Master System (SMS) — run $39.99 each at Stone Age Gamer and open up three more systems with important asterisks we cover later. Original controllers (up to two SNES and two Sega at once) are optional; the Retrode doubles as a controller-to-USB adapter, which is a nice throw-in but not why you bought it.

The software (with versions)

For pure dumping you need nothing beyond your operating system's file manager. That is the whole appeal. The software list only grows when you want to do the responsible things around the dump:

• A hashing tool — sha1sum/md5sum are built into Linux and macOS; on Windows use certutil -hashfile or 7-Zip's CRC context menu. You want this to verify dumps against a No-Intro DAT.
• Atmel FLIP 3.4.7 (Windows) or dfu-programmer 0.7.2+ (Linux/macOS) — only needed if you flash firmware. Skip unless you have a reason.
• An emulator or front-end to actually play the results — RetroArch (any 1.19+ build is fine in 2026), stand-alone Snes9x/bsnes, or a front-end OS like Batocera. Covered in its own section.

Note the thing that is not on this list: a Retrode driver, a Retrode app, or a Retrode account. There is no such thing. If a website offers you "Retrode drivers," close the tab.

What the Retrode will NOT do

Manage expectations now and you will save yourself an afternoon of confusion. The Retrode 2 cannot read cartridges that contain a full second console — the Super Game Boy and the Sega 32X-with-its-own-CPU class of hardware are out of scope by design (though, per the FAQ, the passive 32X adapter without its power supply does pass through). It cannot write ROMs, only SRAM saves. And critically, it does not support several SNES enhancement chips: the FAQ specifically names the SA-1 (Super Mario RPG, Kirby Super Star, Super Mario World 2 hardware variants) and the S-DD1 (Star Ocean, Street Fighter Alpha 2) as "currently not supported." The physical DSP and SuperFX carts are their own adventure. If your shelf is mostly enhancement-chip headliners, read the compatibility notes before you buy, because "it dumped garbage" is almost always "it dumped a chip the firmware never learned to speak to," not a defect.

The 12-Step Dumping Workflow

This is the main event, and it is deliberately over-specified. Each step includes the reason it exists, because a workflow you understand is one you can fix when a cartridge misbehaves. The happy path takes about ten minutes per cart; your first one, reading carefully, maybe forty. Everything below assumes a Retrode 2 and an SNES or Genesis cartridge.

1. Clean the cartridge contacts. Dampen a lint-free swab with 90%+ isopropyl alcohol and wipe the edge connector until the swab comes away clean. Rationale: the overwhelming majority of failed or corrupted dumps are contact problems, not hardware faults. Thirty years of oxide and one previous owner's fingerprints read as bad data, and the Retrode has no way to know the difference.
2. Leave the Retrode unplugged. Insert the cartridge fully into the correct slot before you connect USB — Genesis/Mega Drive in the lower slot, SNES/SFC in the upper. Rationale: the firmware probes cartridge memory at connection and reset time. Seating the cart first means the very first probe sees a clean, fully-inserted connector rather than a half-mated one.
3. Connect the Retrode to your computer with the supplied USB cable. Use a rear/motherboard port or a powered hub, not an unpowered front-panel port. Rationale: the Retrode draws its power and its logic levels from the USB bus. Marginal power is a leading cause of intermittent reads, and old cartridges are already marginal enough.
4. Wait for the removable drive to mount. A new volume — typically labeled RETRODE — appears in your file manager. Rationale: this is your confirmation that enumeration succeeded and the device is speaking USB mass storage. If nothing mounts, stop here; nothing downstream will work until it does.
5. Open the drive and read the file listing. You should see a ROM file named from the cartridge's internal header, a matching save file, and RETRODE.CFG. Rationale: the filename comes from the game's own header, so seeing a sane title (e.g. SUPER MARIOWORLD) is instant proof the ROM is being read coherently. Garbage in the name means garbage in the data.
6. Confirm the ROM's reported size looks right. A 4-megabit game should be ~512 KB; a 32-megabit game ~4 MB. Rationale: a size that is suspiciously round-but-wrong (or zero) is the Retrode telling you it couldn't determine the cartridge geometry — often a contact or enhancement-chip issue. Catch it here, before you trust the file.
7. Copy the ROM file to a working folder on your computer. Drag it off the Retrode drive to local storage; do not open or run it in place. Rationale: reading directly off the device every time is slow and stresses a thirty-year-old connector. Copy once, verify the copy, work from the copy.
8. Copy the save (SRAM) file too, if present. Grab the .srm alongside the ROM. Rationale: the save is the irreplaceable part. ROMs exist in a thousand archives; your save file — that specific 90-hour playthrough — exists only on that dying battery. Preserve it first, philosophically speaking.
9. Hash the ROM and check it against a No-Intro DAT. Run sha1sum (or your platform's equivalent) on the copied file. Rationale: a matching hash means your dump is byte-identical to a known-good reference — the single strongest signal that the dump is clean. A mismatch is not automatically failure (region and revision differences are real), but it demands investigation.
10. If the hash mismatches, reseat and re-dump. Eject, re-clean, press RESET (the lower button) to force a re-read, and hash again. Rationale: most mismatches are transient contact noise. Two independent dumps that produce the same hash as each other are trustworthy even if that hash isn't in the DAT (you may simply own an undocumented variant).
11. Swap the next cartridge and press RESET. Eject the old cart, insert the new one, and press the lower RESET button; the drive contents refresh to the new game. Rationale: the Retrode does not automatically re-scan on cartridge swap — it caches the mounted files. RESET is the explicit "look again" command. Forgetting it is the single most common beginner confusion, covered again in Pitfalls.
12. Rename, organize, and back up. Give each dump a clean No-Intro-style name, sort into per-system folders, and copy the whole set to a second location. Rationale: a dump that exists in exactly one place is not preserved, it is merely delayed. The point of this entire exercise was durability; one drive failure should never undo it.

Reading the Files: ROM, SRAM, Verify

The dump is only as good as your ability to confirm it. This section is about what you should actually see on that mounted drive, and how to prove the bytes are correct rather than merely present.

What the mounted drive looks like

When a SNES cartridge is seated and the Retrode has enumerated, the RETRODE volume looks roughly like the listing below. The ROM name is derived from the cartridge's internal header, which is why it arrives in ALL CAPS with the original developer's idiosyncratic spacing. This is expected output, not a bug:

$ ls -l /Volumes/RETRODE
total 1040
-rw-r--r--  1 user  staff  524288  SUPER MARIOWORLD.SFC
-rw-r--r--  1 user  staff    2048  SUPER MARIOWORLD.SRM
-rw-r--r--  1 user  staff     512  RETRODE.CFG

Three things to read off that listing. The .SFC file is the ROM (SNES dumps commonly land as .sfc or .smc; Genesis dumps as .bin/.gen/.md). The .SRM file is the battery-backed save — 2 KB here, which is typical for a game with a small save. And RETRODE.CFG is the on-device configuration file, always present, always editable, discussed in its own section. If the ROM file is 0 bytes, or the name is mojibake, you have a read problem, not a dump.

Checksums and No-Intro verification

Presence is not correctness. To prove a dump is byte-perfect, hash it and compare against the No-Intro reference database — the community-maintained catalog of known-good cartridge dumps. The workflow is trivial:

# Linux / macOS
sha1sum "SUPER MARIO WORLD.sfc"
# -> 6b47bb75...  SUPER MARIO WORLD.sfc

# Windows (PowerShell)
Get-FileHash "SUPER MARIO WORLD.sfc" -Algorithm SHA1

# Windows (cmd)
certutil -hashfile "SUPER MARIO WORLD.sfc" SHA1

Take the printed SHA-1 and search for it in a current No-Intro DAT (tools like Redump/No-Intro DAT viewers, or a ROM manager such as Retool or RomVault, do the matching for you). A hit means your dump is identical to a documented reference — done. A miss means one of three things: you have a legitimate but undocumented regional or revision variant, your cartridge has an enhancement chip the firmware mangled, or your contacts are dirty. Re-dump once; if two independent dumps agree with each other, trust them.

SRAM saves and writing them back

The .srm file is where the Retrode's write capability earns its keep. You can copy a save off, edit it in a save editor, or simply archive it — and on many cartridges you can copy a compatible .srm back onto the drive to restore it to the physical cart. This is the correct, sanctioned way to rescue a game whose battery is failing: dump the save now, and when the battery finally dies and you replace it, write the save back. It is also the bridge between physical and emulated play, because most emulators use the same .srm format for SNES saves. Two hard caveats: writes only work where the cartridge has actual battery-backed SRAM (not every game does), and you should never assume a save from one revision drops cleanly onto another. Back up the original before you overwrite anything.

RETRODE.CFG: Configuration

The Retrode carries its settings in a plain-text file on its own volume. It is a small, elegant idea — the device's brain is a file you can open in Notepad — and it is worth understanding even though most people never touch it.

Where the file lives and how it is parsed

Every time the Retrode mounts, RETRODE.CFG sits in the root of the RETRODE volume. The firmware generates it if it is missing, reads it at startup, and applies whatever valid settings it finds. To change behavior you open the file, edit a value, save, and either re-plug the device or press RESET so the firmware re-parses it. Because it is stored on the cartridge-facing side rather than in your OS, the settings travel with the Retrode — move it to another computer and your configuration comes along. The exact set of recognized keys is documented on the official Retrode documentation (the old retrode.org docs now redirect to retrode.com), and you should treat that page as canonical over any third-party example, including this one.

The options that matter

The configurable surface is intentionally small. Broadly, the file lets you influence how files are named and exposed and how the device reports itself — the sort of behavior you'd want to override for a specific dumping habit. Rather than assert a key list that may drift between firmware builds, the honest guidance is: read the version string the firmware writes into the file (that is your firmware-version source of truth), and change one setting at a time, re-reading after each so you can attribute any change in behavior to the edit you actually made. For the vast majority of users the defaults are correct and the right number of edits to this file is zero.

An illustrative config

The block below is illustrative of the format — a commented, key-per-line text file — not a spec. Use it to recognize the shape of the file, then consult the official docs for the exact, current key names before you change anything:

; RETRODE.CFG  (illustrative of format only)
; Lines beginning with ';' are comments.
; Consult retrode.com for the authoritative, firmware-current keys.

; Firmware writes its own version string here on generation:
;   FW_VERSION=0.18c

; The kinds of behavior exposed (names are illustrative):
;   force_region      = auto     ; auto | ntsc | pal
;   expose_sram       = on       ; on | off
;   filename_from     = header   ; header | slot
;   controller_mode   = on       ; expose gamepads as HID

; When unsure, delete this file; the firmware regenerates defaults.

If you ever corrupt the file beyond recognition, the recovery is stupid-simple: delete it. The firmware regenerates a default RETRODE.CFG on the next mount, which is exactly the kind of unbrickable behavior that makes the platform pleasant to live with.

Firmware Updates via DFU

The Retrode 2 runs updatable firmware on its AVR, and updating it is a rite of passage you will probably never need to perform. Here is why, and here is how, in that order.

Why you'd update — and why you probably won't

Be honest about the state of the platform: Retrode 2 firmware is effectively frozen. The last publicly distributed builds — 0.18c as the stable release and 0.18d beta 3 as the final beta — date to around 2016 (they remain mirrored on listing sites like Softpedia). There is no 2026 firmware, because the Retrode 2 does what it does and the development energy has moved to the Retrode 3. So the practical reasons to flash are narrow: you bought a used unit on an ancient build and want the last-known-good release, you want to test whether a beta improves a specific problem cartridge, or you are recovering a unit someone flashed badly. If your Retrode dumps clean carts correctly, updating gains you nothing. Leave it alone.

Entering DFU mode (HWB + RESET)

The AT90USB646 exposes Atmel's DFU (Device Firmware Update) bootloader, entered with a two-button dance. The buttons are HWB (the upper button) and RESET (the lower button, the same one you use to re-read a swapped cartridge). The sequence, straight from the documentation:

1. Hold down HWB (and keep holding it).
2. Press and release RESET while still holding HWB.
3. Release HWB.

# The device now enumerates as an Atmel DFU bootloader,
# NOT as the RETRODE mass-storage drive. This is expected:
# the RETRODE volume disappearing means you did it right.

The tell that you succeeded is that the RETRODE disk vanishes and a new USB device — an Atmel/Microchip DFU bootloader — appears instead. If the drive is still mounted, you are not in DFU mode; try the sequence again, deliberately.

Flashing with FLIP or dfu-programmer

Once in DFU mode, you push a .hex firmware image with either Atmel's GUI tool FLIP (Windows) or the command-line dfu-programmer (Linux/macOS). The command-line path is the one worth documenting because it is reproducible:

# Linux / macOS — dfu-programmer, target chip at90usb646
sudo dfu-programmer at90usb646 erase
sudo dfu-programmer at90usb646 flash retrode-0.18c.hex
sudo dfu-programmer at90usb646 reset

# Expected tail of a good flash:
#   Checking memory from 0x0 to 0x...  Empty.
#   Validating...  Success
#   0xXXXX bytes written into 0xXXXX bytes memory (NN.NN%).

On Windows with FLIP: launch it, choose the AT90USB646 device, open the USB connection, load the .hex, tick Erase/Program/Verify, run, then Start Application. Either way, after the reset the Retrode re-enumerates as the normal mass-storage drive and reports its new version in RETRODE.CFG. If a flash fails midway, do not panic — the device stays in DFU mode until a valid image lands, so you simply flash again. That is the "practically unbrickable" property working as intended.

Plug-in Adapters: N64, GB, SMS

The two built-in slots are only half the story. Three official plug-in adapters extend the Retrode 2 to more systems — and each comes with an asterisk about saves that you need to internalize before you buy. All three list at $39.99. The full compatibility matrix lives on the official plug-in adapters page.

N64 plug-in

The N64 adapter adds Nintendo 64 cartridge support plus up to two N64 controllers. Two rules define it. First, per the docs, controllers must be connected before USB is established, so plug your pads in, then plug in the Retrode. Second — and this is the big one — ROM dumping works, but saving does not, yet: SRAM, Flash, and EEPROM save support is listed as "firmware support pending," and given the frozen state of Retrode 2 firmware, "pending" should be read as "do not count on it." The N64 also runs at 3.3V, which the adapter handles, and cartridge insertion is auto-detected with an automatic filename. If your goal is archiving N64 games, it delivers; if your goal is rescuing an N64 save file, look elsewhere.

GBx plug-in (Game Boy / Color / Advance)

The GBx adapter is the most versatile of the three, handling "Game Boy cartridges of all generations (Classic, Color, Advance)." ROM reads work across every generation. Saves are where it splits: GB and GBC SRAM saves work, but GBA SRAM is "firmware support pending," and GBA Flash/EEPROM likewise. The voltage note matters if you care about the hardware: GB/GBC cartridges run at 5V, GBA at 3.3V, and the adapter switches accordingly. Insertion requires a manual reset (press RESET after seating the cart). For a Game Boy Color library this adapter is genuinely great; for a Game Boy Advance save-rescue mission, its GBA save gap is the same disappointment as the N64's.

SMS plug-in and the discontinued rest

The Sega Master System adapter reads SMS cartridge ROMs, auto-detects insertion, and — a small quirk — cannot always name the file from the game title because the note reads "Data missing in cartridge header," a reflection of the SMS's looser header conventions rather than a fault. SRAM support is, once more, "firmware support pending." It runs at 5V. Beyond these three, the official page is refreshingly candid that other adapters once existed but are no longer commercially available because "connectors can no longer be obtained" — a very Retrode sentence, and a reminder that this is a small-scale, parts-constrained operation, not a megacorp with an infinite BOM.

Playing Your Dumps

A verified dump is a means, not an end. Here is where the files go to become games again, across the three destinations that matter in 2026: software emulation, FPGA hardware, and handhelds.

RetroArch and the right cores

The default home for a fresh dump is RetroArch. Point it at your ROM folder, and match each system to a good core: Snes9x or the higher-accuracy bsnes/higan family for SNES, Genesis Plus GX for Genesis/Mega Drive and Master System, Mupen64Plus-Next for N64, and mGBA for Game Boy through GBA. Your Retrode .srm saves generally drop straight into RetroArch's save directory and just work, which is the entire payoff of dumping your own carts — your real saves, in the emulator, on your terms. If you are standing up RetroArch from scratch, our walkthrough on installing and configuring RetroArch cores in twelve steps covers core selection and the save-directory plumbing in detail. A minimal save-path config looks like this:

# retrode.cfg fragment for a clean RetroArch layout
savefile_directory = "~/Games/saves"
savestate_directory = "~/Games/states"
rgui_browser_directory = "~/Games/roms"
# drop your Retrode .srm files into savefile_directory,
# named to match the ROM, and RetroArch will load them.

MiSTer FPGA and Batocera

If software emulation's timing approximations bother you, your verified dumps also feed MiSTer FPGA, which reproduces the original console circuitry in programmable logic and loads ROMs straight off an SD card — a purist's endgame we covered when the MiSTer Multisystem 2 crossed 17,000 units. The same dumps also drop into a batteries-included front-end OS; if you'd rather boot straight into a polished library than assemble RetroArch by hand, our guide to installing Batocera v43.1 in about fifteen minutes gets you from image to game quickly. For N64 specifically, the arrival of dedicated FPGA hardware like the Analogue 3D and its rapid firmware cadence means your dumped N64 carts have a genuine hardware home now, not just an emulator.

Handhelds and the portable case

The last destination is your pocket. A dumped SNES or Genesis library is the ideal payload for a modern Linux handheld, and a verified, correctly-named ROM set copies over exactly as cleanly as it plays on a desktop. Whether that is a budget Miyoo-class device or a more powerful Retroid, the workflow is identical: dump, verify, name, copy. If you want the deeper libretro reference behind all three destinations — core options, save formats, and the compatibility notes for tricky chips — the official libretro documentation is the authority worth bookmarking.

Common Pitfalls & Fixes

Every one of these has cost someone an hour. Read them before your first dump and you get that hour back. Each is a symptom, a cause, and a fix.

1. Swapped the cart, still seeing the old game. Cause: the Retrode caches the mounted files and does not auto-rescan on cartridge swap. Fix: press the lower RESET button after every swap. This is the number-one confusion, and it is documented behavior, not a bug — RESET is literally the "re-read" command.
2. Dump hash never matches, and it's random each time. Cause: dirty or oxidized cartridge contacts producing bit noise. Fix: clean the edge connector with 90%+ isopropyl and a lint-free swab, reseat firmly, and re-dump. Two dumps that agree with each other are trustworthy even without a DAT match.
3. A specific SNES game dumps to garbage every single time. Cause: an unsupported enhancement chip — the FAQ names SA-1 and S-DD1 explicitly. Fix: there isn't one on a Retrode 2; the firmware never learned those chips and it's frozen. This is a hardware-scope limit, not a fault you can clean away.
4. Adapter reads the game but the save won't dump. Cause: N64, GBA, and SMS save support is "firmware support pending" — and pending is permanent on a frozen firmware. Fix: accept ROM-only for those systems, or use a dedicated cart-save tool for the save. GB/GBC saves, notably, do work.
5. Nothing mounts at all. Cause: insufficient bus power (unpowered front port or a weak hub) or a half-seated cartridge. Fix: move to a rear/motherboard USB port or a powered hub, reseat the cart fully, and reconnect. The device is bus-powered and old carts are power-hungry at the margins.
6. Wrote an SRAM save back and corrupted the cartridge save. Cause: pushing a save from a different region/revision, or onto a cart without true battery SRAM. Fix: always back up the original .srm before overwriting, and only restore saves you dumped from that same cartridge. When in doubt, don't write.

Troubleshooting Table

A denser lookup for when something specific breaks. Scan the symptom column, then work the fix.

The Retrode 3: Late 2026

Everything above is about a device from 2015 with firmware from 2016. That is not neglect — it is a platform that finished being what it was — and the reason the energy left is that its successor is genuinely different. The Retrode 3 is not a spec bump. It is a rethink.

MIPS, Debian, and a browser UI

Where the Retrode 2 is an 8-bit AVR pretending to be a flash drive, the Retrode 3 is a small computer. It runs Debian Linux on a MIPS processor, has built-in Wi-Fi, and — the clever part — presents itself to your machine as a USB-Ethernet device, so you operate the entire thing from a web browser with no drivers and no app on any modern OS. It is Made in Germany, fully open source in both hardware and software, and described as "practically unbrickable" because you can always reflash the image. The mass-storage-drive metaphor of the Retrode 2 is gone, replaced by a web UI that can expose far more control than a drag-and-drop volume ever could.

NES support and the OSCR merge

The headline hardware change: three cartridge slots — SNES/SFC, Mega Drive/Genesis, and, new to the line, NES — all reading ROM and SRAM. The headline software change is bigger. The Retrode 3 is built on Sanni's Open Source Cartridge Reader (OSCR), the same community cart-dumping project that powers a generation of DIY readers. The retrode3-oscr repository is "a Linux command line adaptation of OSCR" — over 2,000 commits, 93% C++, licensed GPLv3 for software and CC BY 4.0 for hardware — that wraps the OSCR firmware with a retrode.lib abstraction over Linux syscalls. Because both the Retrode 3 and upstream Sanni's cartreader share the OSCR core, fixes and new-system support can flow in both directions. That plugin lineage is why the Retrode 3 stands to escape the "firmware support pending" purgatory that froze the Retrode 2's adapters — the save-dumping code already exists upstream.

Price, timing, and the pre-order reality

Now the cold water. As of mid-2026 the Retrode 3 is not for sale. The target is availability by the end of 2026 at a price under €100 (roughly $108), but both the date and the price are explicitly not final, blamed on component lead times — the same supply reality that killed those legacy adapter connectors. You cannot order one; you can only sign up to be notified through DragonBox's pre-registration page. Treat "late 2026" as a hope, not a ship date, and treat the sub-€100 figure as a target, not a price tag. If you have carts to dump now, the Retrode 2 is the answer; if you can wait and you value NES support and a browser UI, the Retrode 3 is worth the notify-me click. The full backstory on that development is in our coverage of how long-running retro projects stall and stabilize — the Retrode 3 is, for once, a project moving in the right direction.

Advanced Tips & Full Config

You have the workflow. Here is how to make it faster, cleaner, and repeatable — and a complete reference setup to copy.

Batch dumping and scripting

If you are archiving a shelf, automate the boring part. The Retrode presents a normal filesystem, so you can copy-and-hash in one motion, then swap carts and re-run. A minimal Bash loop that copies whatever ROM is currently mounted, hashes it, and logs the result:

#!/usr/bin/env bash
# dump-one.sh — copy the current Retrode ROM, hash it, log it.
set -euo pipefail
SRC="/Volumes/RETRODE"          # macOS; Linux: /media/$USER/RETRODE
DEST="$HOME/Games/roms/incoming"
LOG="$HOME/Games/roms/dump.log"
mkdir -p "$DEST"

for rom in "$SRC"/*.SFC "$SRC"/*.BIN "$SRC"/*.SRM; do
  [ -e "$rom" ] || continue
  cp -v "$rom" "$DEST/"
  base="$(basename "$rom")"
  sha1sum "$DEST/$base" | tee -a "$LOG"
done
echo "Swap the next cartridge, press RESET, run again."

Run it once per cartridge: seat cart, press RESET, run dump-one.sh, swap, repeat. Your dump.log becomes a hash manifest you can later diff against a No-Intro DAT in bulk with a ROM manager.

Cleaning carts the right way

Contacts are everything, so do it properly. Use 90%+ isopropyl (not rubbing alcohol cut with water and additives), a lint-free swab or a folded coffee filter, and wipe along the contacts, not across them. Resist the old "blow into the cartridge" ritual — the moisture in your breath is precisely what oxidized these contacts over thirty years. For carts that resist cleaning, a plastic (never metal) contact-cleaning tool and a fresh swab beat brute force. If a cartridge shell is filthy inside, a gamebit screwdriver and a proper opening are cheaper than a hundred failed dumps. Clean once, dump forever.

A complete working reference setup

Finally, the whole thing as one copy-paste reference: a sane on-disk layout, the illustrative device config, and the verify pass. Adapt the paths; keep the structure.

# ---- Directory layout ----
~/Games/
  roms/
    snes/        # verified .sfc/.smc
    genesis/     # verified .bin/.md
    n64/         # verified .z64/.n64
    incoming/    # fresh dumps awaiting verification
  saves/         # .srm from Retrode + emulator saves
  states/        # emulator save states
  dump.log       # sha1 manifest of every dump

# ---- RETRODE.CFG (illustrative of format; see retrode.com) ----
; FW_VERSION written by firmware, e.g. 0.18c
; expose_sram      = on
; filename_from    = header
; controller_mode  = on

# ---- Verify pass: match incoming dumps to a No-Intro DAT ----
cd ~/Games/roms/incoming
for f in *; do
  echo "$(sha1sum "$f")"
done | tee ~/Games/roms/verify.txt
# Feed verify.txt into a ROM manager (Retool/RomVault) to match
# against a current No-Intro DAT, then sort verified files into
# their per-system folders. Anything unmatched: re-dump once.

That is the entire discipline: dump, verify against a known-good reference, name it properly, sort it, and back it up to a second location. The Retrode 2 is a modest little box that does exactly one thing and does it without drama — and in a hobby drowning in launchers, accounts, and DRM, a box that turns your plastic into files and then gets out of the way is worth every cent of its hundred dollars. The Retrode 3, when it lands, promises to do the same thing with a browser and an NES slot. Until then, clean your contacts and press RESET. For the authoritative reference on any of the above, the Retrode's documented history and specs and the manufacturer's own pages are where the facts live.