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

There is a specific kind of person who owns a boxed copy of EarthBound that cost more than their monitor and who refuses, on principle, to download a ROM that somebody else dumped. The Retrode was built for that person. It is a small grey box with a SNES slot on top and a Genesis slot on the front, and when you plug it into a computer it does something quietly radical: it mounts as a USB drive and presents the silicon inside your cartridge as an ordinary file you can copy.

No ripping software. No drivers. No console in the loop. You drag a file off the drive and you hold a byte-for-byte dump of a game you legally own, pulled from the mask ROM you paid for. That is the entire pitch, and it has not meaningfully changed since Matthias Hullin prototyped the thing on a Pandora handheld forum in 2009 under the working title snega2usb. What has changed, in 2026, is that the ageing Retrode 2 is finally getting a successor — the Retrode 3 — and the two of them make a clean before-and-after for how cartridge preservation is supposed to work.

This is the long version of the tutorial: prerequisites with actual version numbers, twelve numbered steps from a filthy cartridge to a playable emulator, the pitfalls that eat first-timers alive, a troubleshooting table, and the advanced material nobody bothers to document. If you only want the fast path, we keep a focused 12-step, 20-minute Retrode 2 dump walkthrough for exactly that. This piece is the one that explains why each step exists — which is the part that stops you corrupting a save you can never get back.

What the Retrode Actually Is

Before you touch a cartridge, understand what this device does and — more usefully — what it does not do. Almost every support thread about the Retrode is somebody who assumed it was something it never claimed to be.

A USB drive that lies about being a cartridge

The Retrode is a composite USB device. In plain terms, it advertises itself to your computer as two things at once: a USB mass-storage endpoint (a drive) and one or several USB HID game controllers. Wikipedia describes it exactly that way — "a USB mass storage endpoint and one or several USB game controllers" — and that duality is the whole trick. The mass-storage half is where your ROM lives; the HID half is where your original joypads plug in.

When you insert a cartridge, the on-board firmware reads the cart's memory and wraps it into virtual files on that fake drive. A Super Nintendo game appears as GAMENAME.SFC. The battery-backed save appears next to it as GAMENAME.SRM. A Genesis game appears as GAMENAME.BIN with its own .SRM. There is no ripping utility to install, no dumper software, no console. The official line from retrode.com is blunt about it: "Driverless operation on any USB host, under any OS, using any emulator." That is not marketing gloss; it is a design decision that has kept a 2011-era product usable for fifteen years.

The critical consequence: the ROM file is read-only. The Retrode's own documentation answers the inevitable "can I write a game to a cart" question with the driest possible joke — ROM stands for Read Only Memory, hence, no. What is writable is the SRAM save file, provided you flip one config switch, which is the single most useful and most dangerous feature in the entire product. We will get there.

Retrode 2 versus Retrode 3: the 2026 split

As of July 2026 there are two devices under this name and they share almost nothing but the concept. The Retrode 2 is the shipping product: an 8-bit Atmel AVR microcontroller (the AT90USB646) running frozen firmware, built-in slots for SNES/SFC and Genesis/Mega Drive, driverless, and about as complicated as a USB memory stick. It costs roughly €64.90 direct from DragonBox in Germany, or $99.99 from a US reseller such as Stone Age Gamer, with plug-in adapters for other systems at €25 each (or a €65 three-pack) / $39.99 each. When Time Extension reviewed it back in January 2013 under the memorable headline "A Legal Way To Play ROMs," it sold for $89.99. It has crept up, not down.

The Retrode 3 is a different animal entirely — a MIPS-and-ARM Linux computer (Debian on an SD card) with built-in Wi-Fi that you drive from a web browser. It adds NES support out of the box and it can write flash carts. It is not for sale yet. We give it a full section near the end, because for most readers in 2026 the correct move is still to buy the Retrode 2 and learn the workflow — that workflow is what this guide teaches.

The legal position, stated precisely

I am not your lawyer, but I read the statutes so you do not have to, and the nuance matters here. The Retrode does not decrypt anything, does not bypass a copy-protection scheme, and does not touch a Technological Protection Measure. It reads unencrypted cartridge memory over the cart's own bus, the same way the console does. That is legally cleaner than a lot of ripping methods, because in the US the friction point in copyright law for game backups is the anti-circumvention clause (DMCA §1201), and there is no circumvention happening — nothing is locked to begin with.

Dumping a cartridge you personally own, for your personal use, is the defensible-backup end of a genuinely grey area. The line you do not cross is distribution: the moment you hand that .SFC to someone else, or seed it, you are no longer making a personal backup, you are infringing, and no cartridge dumper changes that. The Retrode is a preservation tool for your own shelf. Treat it that way and the ethics are easy; the law is at least on speaking terms with you.

Prerequisites: Hardware & Software

Gather everything before you start. Half the failed first attempts in the support forums are somebody discovering mid-dump that their USB cable is a charge-only cable, or that their cartridge contacts look like they were stored in a chip-fryer.

The hardware you need

• A Retrode 2 (€64.90 DragonBox / $99.99 Stone Age Gamer). The box ships with the unit, a USB cable, and a single-sheet instruction card — that is the entire kit.
• A data-capable USB cable. The bundled one is the safe choice. The Retrode uses a Mini-USB Type-B port; a charge-only cable will power the LED and fool you into thinking it works while no drive ever mounts.
• The cartridges themselves, cleaned. SNES/SFC and Genesis/Mega Drive work in the built-in slots. Region does not matter to the dumper — a PAL cart and an NTSC cart both read fine; region is an emulator concern, not a Retrode concern.
• 99% isopropyl alcohol and cotton swabs, plus a bright light. Not 70% (too much water), not vodka, not a pencil eraser (abrasive; it strips the contact plating over time).
• Optional plug-in adapters at €25 / $39.99 each: Nintendo 64, Game Boy / Color / Advance, and Sega Master System. Note the caveats — the N64 adapter dumps ROM fine but save support is listed as "firmware support pending," and the SMS adapter cannot read a header title, so files come out generically named.

The software stack

You need an emulator and, if you plan to touch firmware, a flashing tool. Concrete, current versions:

• RetroArch (any 2024+ build) with the right cores — Snes9x or bsnes for SNES, Genesis Plus GX for Mega Drive. If you have never set cores up, our RetroArch cores walkthrough covers installing and updating them; the libretro documentation at docs.libretro.com is the authoritative reference for per-core behaviour. Standalone Snes9x or BizHawk are fine alternatives.
• Atmel FLIP (Windows) or dfu-programmer (Linux/macOS) — only if you intend to reflash firmware in Step 11. You do not need these to dump games.
• A checksum tool — sha1sum on Linux/macOS, CertUtil or 7-Zip's CRC on Windows — to verify dumps against a No-Intro database.
• Optional: a prebuilt emulation OS. If you would rather not manage cores by hand, a box running Batocera will happily consume Retrode dumps once you copy them over.

Firmware versions that matter

The Retrode 2's firmware is frozen, and you should know the numbers so you do not go hunting for a phantom update. The last builds are 0.18c (stable) and 0.18d beta 3, both from around 2016. The firmware is built on Dean Camera's LUFA USB stack and runs on the AT90USB646. There is no v0.20, no v0.22, no "enhanced cart support" update — if a forum post or a product listing claims one, it is wrong or it is confusing the Retrode with the Retrode 3's entirely separate software. The editable configuration file feature (RETRODE.CFG) has existed since firmware 0.17g, so anything on the 0.18 line supports it.

Steps 1-6: Connect and Dump

Twelve steps, each with the reasoning attached, because the reasoning is what lets you improvise when your particular cartridge does something weird. This first block gets a clean dump onto your disk.

Steps 1-2: acquire and clean

Step 1 — Get the correct unit from a real source. Buy the Retrode 2 from DragonBox (dragonbox.de) or an authorised reseller like Stone Age Gamer. Rationale: "Retrode" gets used loosely for any cart dumper, and eBay is full of bundles, clones, and "Retrode 1" units with older firmware and fewer fixed bugs. The version you want is the second hardware revision, produced under OpenPandora GmbH from March 2015 onward and sold today through DragonBox. Starting from the right hardware removes an entire category of problems.

Step 2 — Clean the cartridge contacts. Dampen a swab with 99% isopropyl, run it along the edge connector until the swab stops coming away grey, and let it flash-dry (seconds). Rationale: the Retrode reads the cart electrically over that edge connector; oxidation and grime are the number-one cause of truncated or garbage dumps. A cartridge that boots fine on real hardware can still dump badly, because the console's connector wipes the contacts on insertion and the Retrode's does so far more gently. Clean contacts are non-negotiable for a trustworthy dump.

Steps 3-4: connect and detect

Step 3 — Connect the Retrode and confirm the drive mounts. Plug the Retrode into the computer with a data cable before inserting a cart, and verify a volume named RETRODE appears. Rationale: this proves the firmware is alive and the cable carries data before you introduce any cartridge variables. If the volume never shows, you have a cable or firmware problem, not a cartridge problem, and you have just saved yourself an hour of blaming the wrong thing.

# Linux
lsblk -o NAME,LABEL,SIZE,MOUNTPOINT | grep -i retrode

# macOS
diskutil list | grep -i RETRODE
ls -la /Volumes/RETRODE

# Windows (PowerShell)
Get-Volume | Where-Object FileSystemLabel -eq 'RETRODE'

Step 4 — Insert the cartridge fully, then refresh the mount. Seat the cart firmly in the correct slot — the wide upper slot is SNES/SFC, the shorter lower slot is Genesis/Mega Drive — and press the RESET button (the lower of the two buttons) to force the Retrode to re-read and rebuild the virtual files. Rationale: the drive contents are generated at detection time. If you hot-swap a cart without remounting, your OS may still be showing the previous cartridge's cached files, which is how people end up "dumping" the wrong game. The Retrode's own user guide is explicit that hot-swapping is "possible, but it can potentially damage on-cartridge savegames," and advises you "prefer to eject/unplug the Retrode first." Take that seriously.

Steps 5-6: read and verify

Step 5 — Copy the ROM file off the drive. Do not point your emulator at the file on the RETRODE volume; copy it to real storage first. Rationale: the file on the Retrode is a live window into the cartridge, streamed on demand over USB. It is slow, and it vanishes the instant you unplug the cart. Copying it to disk gives you an actual, persistent dump you own. Expect an SNES game to land as NAME.SFC and its save as NAME.SRM.

$ ls -la /media/you/RETRODE
-r-xr-xr-x 1 you you 3145728 Jan  1  1970 SUPERMET.SFC
-r-xr-xr-x 1 you you    8192 Jan  1  1970 SUPERMET.SRM
-rwxr-xr-x 1 you you     231 Jan  1  1970 RETRODE.CFG

$ cp /media/you/RETRODE/SUPERMET.SFC ~/roms/
$ cp /media/you/RETRODE/SUPERMET.SRM ~/roms/

Note the permissions in that listing: the ROM and SRM are read-only (r-x) while RETRODE.CFG is writable (rwx). That is the read-only-ROM design showing through at the filesystem level, and the epoch timestamp (1970) is normal — the Retrode has no real-time clock.

Step 6 — Verify the dump. Hash the copied file and compare it against a No-Intro reference. Rationale: a dump that is the right size can still be subtly wrong if a contact flaked mid-read. A checksum is the only way to know you got a bit-perfect copy rather than a plausible-looking corruption. A 24-megabit game such as Super Metroid should be exactly 3,145,728 bytes; if yours is smaller, the read failed.

$ sha1sum ~/roms/SUPERMET.SFC
# You get a 40-character hex string. Paste it into a No-Intro
# lookup; a match means a verified good dump. A mismatch means
# re-clean the contacts (Step 2) and dump again.
3a1f...c9d2  SUPERMET.SFC

Steps 7-9: Saves, Emulator, Pads

A ROM on disk is half the value. The other half is your saves — the level-99 file, the completed Pokédex, the twenty-year-old Chrono Trigger playthrough sitting on a battery that is slowly dying — and the ability to play with the actual controller in your hand.

Step 7: back up your SRAM save

Step 7 — Copy the .SRM save file. The battery-backed cartridge save appears next to the ROM as NAME.SRM; copy it off exactly like the ROM. Rationale: this is the single most important thing the Retrode does that a downloaded ROM cannot. Cartridge saves live in SRAM kept alive by a CR2032 coin cell soldered onto the board, and those cells are now three decades old. Every one of them is a countdown timer. Pulling the .SRM is a permanent, emulator-compatible backup of a save that will otherwise evaporate the day that battery finally quits — silently, with no warning, taking your childhood file with it. Do this before the battery decides for you.

By default those RAM files are, in the documentation's words, "write-protected," which is a deliberate safety measure — read Step 10 before you ever try to write one back.

Step 8: load the ROM in an emulator

Step 8 — Open the dump in the matching core. In RetroArch, load the SNES core (Snes9x or bsnes) and then load your .SFC; for Genesis, use Genesis Plus GX with the .BIN. Rationale: the Retrode is not an emulator — it never was and never claimed to be. It hands you a standard ROM image, and a standard image needs standard emulation. Match the core to the system and the dump behaves like any other legally sourced ROM. Point RetroArch's save directory at the same folder as your Retrode .SRM and the cartridge save loads straight into the emulated game — continue your real save on your PC, on a handheld, on whatever you like. If your goal is portable play, those verified dumps drop cleanly onto a device like the Miyoo Mini Plus.

Step 9: use your original controllers as USB pads

Step 9 — Plug original controllers into the Retrode's ports. The Retrode has 2×2 controller ports — two SNES, two Sega — and exposes them as USB HID gamepads. Rationale: that HID half of the composite device means an authentic SNES or Sega pad works as a plug-and-play controller with no adapter dongle in between. Standard SNES pads and Sega 3- and 6-button pads are all recognised. One quirk to memorise: the SNES mouse works only in the left SNES controller port. Combine all four ports and you have genuine four-player local input running on the real pads, straight into your emulator.

Steps 10-12: Config and Firmware

The last three steps are the ones that separate someone who owns a Retrode from someone who has actually mastered it: bending its behaviour with a config file, keeping its firmware current, and knowing which cartridges it will simply refuse to read correctly.

Step 10: edit RETRODE.CFG

Step 10 — Open RETRODE.CFG and configure edge cases. The RETRODE.CFG file on the drive is a plain text config you edit in place; it controls save writability, forced system detection, forced sizes and mappers, and file extensions. Rationale: defaults are conservative and correct for most carts, but some cartridges need a nudge — a Game Gear cart that is not auto-detected, a save you actually want to write back, a mapper the firmware guesses wrong. The most consequential key is sramReadonly: it ships at 1 (saves are read-only, safe), and setting it to 0 lets you write a .SRM back onto the cartridge. That is how you restore a save — and also how you overwrite the wrong game's memory if you are careless. The known-good keys, confirmed against the Retrode configuration documentation, are:

sramReadonly 0      # 0 lets you WRITE saves back; 1 = safe read-only
forceSystem auto    # e.g. GG to force Game Gear if auto-detect fails
forceSize 0         # override the detected ROM size; 0 = auto
forceMapper auto    # override mapper guess for stubborn carts
filenameChksum 1    # append a checksum to generated filenames
detectionDelay 0    # add delay before read on flaky contacts
segaSram16bit 0     # handle 16-bit-wide Sega SRAM layouts
sramExt srm         # extension used for the save file
snesRomExt sfc      # extension used for SNES ROM dumps
segaRomExt bin      # extension used for Sega ROM dumps

Save the file directly to the RETRODE volume. The board's LED blinks to acknowledge that the config was written — a small, welcome bit of feedback from a device that otherwise never talks back.

Step 11: update firmware via DFU

Step 11 — Flash firmware only if you have a reason to. To update, enter DFU mode — hold the HWB button (the upper button, button 7), tap and release RESET (button 8) while still holding HWB, then release HWB — and flash a .hex with Atmel FLIP or dfu-programmer. Rationale: firmware is frozen at 0.18c / 0.18d beta 3, so you are not chasing features; you flash to recover a bricked unit, to move from an old 0.17 build to fix a specific bug, or to try the beta's Game Gear detection fix. In DFU mode the chip enumerates as the Atmel bootloader, VID:PID 03eb:2ff9 — a clean way to confirm you are in the right state before you write anything:

# Confirm the board is in DFU mode (Linux/macOS):
$ lsusb | grep -i 03eb
Bus 001 Device 014: ID 03eb:2ff9 Atmel Corp. atmega/at90 DFU

# Flash with dfu-programmer (Linux/macOS):
sudo dfu-programmer at90usb646 erase
sudo dfu-programmer at90usb646 flash retrode_0.18c.hex
sudo dfu-programmer at90usb646 reset

Windows users running FLIP: pick AT90USB646 from the Device menu, press Ctrl+U to open the USB connection, Ctrl+L to load the hex, then Run. One infamous gotcha — FLIP cannot handle file paths containing accented or special characters, so keep your hex somewhere plain like C:\retrode\.

Step 12: special chips and adapters

Step 12 — Know what will not read, and why. The Retrode's AVR reads standard cartridge memory maps; a handful of enhancement chips fall outside what it handles. Rationale: if you own one of these carts, you want to know before you conclude your dump is broken. Per the official FAQ: Super FX (Star Fox, Yoshi's Island) and DSP1 (Super Mario Kart, Pilotwings) games dump fine and are handled by the emulator — those are supported. What is not supported: SA-1 titles (Super Mario RPG, Kirby Super Star, Kirby's Dream Land 3), S-DD1 titles (Star Ocean, Street Fighter Alpha 2), and the Sega Virtua Processor (Virtua Racing). Do not waste an afternoon trying to force an SA-1 dump; the mapping is not there.

On adapters: the Sega 32X cartridge works in the Retrode (without its power brick), but any adapter that contains a whole console — the Super Game Boy, the RetroPort/RetroDuo pass-throughs — does not, because those are active systems, not passive carts. If you want authentic hardware behaviour for those enhancement chips rather than emulation, that is the argument for FPGA gear like the MiSTer Multisystem — a fundamentally different tool from a dumper.

Five Ways People Break This

Every one of these shows up in the support forums weekly. Reading them now costs you two minutes; hitting them cold costs you an evening and, occasionally, a save file.

Contacts, clones, and copying the live file

Pitfall 1: dirty contacts producing plausible garbage. The worst failures are not the obvious ones — a totally dead cart is easy to diagnose. The insidious failure is a cart that dumps to the right size but with a few flipped bits from a momentary bad contact, giving you a ROM that mostly works and then crashes at a specific boss. The fix is the discipline of Step 6: hash every dump. If it does not match No-Intro, re-clean and re-dump. Never trust a dump you have not verified.

Pitfall 2: buying the wrong hardware. A "Retrode 1" or an unbranded clone off a marketplace will have older firmware, unpatched detection bugs, and no support path. Buy the current Retrode 2 from DragonBox or Stone Age Gamer. The €10 you "save" on a grey-market unit buys you a week of intermittent problems.

Pitfall 3: pointing the emulator at the Retrode drive. The virtual file is slow, on-demand, and disappears when you unplug the cart. Load from it once to test and you will conclude "emulation is laggy." It is not — you are streaming a ROM over a 2011 USB link from an 8-bit MCU. Copy to disk first, every time (Step 5).

Special chips and forbidden adapters

Pitfall 4: assuming everything dumps. People try to dump Super Mario RPG, get a bad read, and file a bug. It is not a bug — SA-1 is unsupported, along with S-DD1 and the Sega Virtua Processor. Super FX and DSP1, by contrast, are fine. Memorise which list your favourite cart is on before you panic.

FLIP's fragile little heart, and the hot-swap trap

Pitfall 5: the firmware-flash foot-guns. Two classic ways to waste an hour in Step 11: FLIP silently failing because your .hex sits in a folder with an accented character in the path, and the device "not appearing" because you never actually entered DFU mode (the HWB-hold, RESET-tap, HWB-release dance is fiddly — do it deliberately). And the bonus trap that spans the whole workflow: hot-swapping cartridges without ejecting first. The user guide warns it "can potentially damage on-cartridge savegames." Eject or unplug between carts. A dead Ocarina of Time save is not worth the ten seconds you saved.

Troubleshooting Table

Symptom on the left, the actual cause in the middle, the fix on the right. If your problem is not here, it is almost always contacts (re-read Step 2) or the wrong core (re-read Step 8).

Detection and dump failures

Controller and firmware failures

Advanced: Batch, SRAM, OSCR

Once the basic loop is muscle memory, here is where the Retrode earns its keep for a serious collection — and where the Retrode 3's open-source software starts to matter.

Batch dumping and verification

If you are archiving a shelf, script the tedium. Insert a cart, remount, run one command that copies the ROM and save off the drive and immediately hashes the ROM, then move to the next cart. The script below takes the mounted Retrode path and a destination folder, grabs the standard file types, and writes a checksum manifest you can diff against No-Intro in one pass. It is deliberately dumb and portable — POSIX sh, no dependencies beyond sha1sum.

#!/bin/sh
# dump-and-verify.sh — copy Retrode virtual files to disk and hash them.
# Usage: ./dump-and-verify.sh /media/you/RETRODE ~/roms

SRC="$1"; DST="$2"
mkdir -p "$DST"
for f in "$SRC"/*.SFC "$SRC"/*.BIN "$SRC"/*.SRM; do
  [ -e "$f" ] || continue
  cp -v "$f" "$DST"/
done
cd "$DST" || exit 1
sha1sum *.SFC *.BIN 2>/dev/null | tee dumps.sha1
echo "Compare the hashes in dumps.sha1 against a No-Intro DAT."

Writing saves back to the cartridge

The reverse operation — pushing an emulator save onto the physical cart — is the Retrode's power-user feature and its sharpest edge. Set sramReadonly 0, insert the correct cartridge, confirm three times that it is the correct cartridge, then copy your .SRM onto the RETRODE volume over the existing save file. This lets you continue a PC or handheld playthrough on original hardware, or clone a save between two copies of a game. The danger is obvious and total: write the wrong .SRM, or write while the wrong cart is inserted, and you have irreversibly overwritten a battery save. There is no undo. Back up the existing .SRM (Step 7) before you write a new one — always.

Building the Retrode 3 OSCR command-line tool

The Retrode 3's software is fully open source, and you can read — and build — it today even without the hardware. The core is retrode3-oscr, described as a "Linux command line adaptation of OSCR" — a fork of Sanni's Cart Reader (sanni/cartreader) plus a retrode.lib that reaches the cartridge slots through Linux syscalls instead of the original's hardware buttons and OLED. It is C++ under GPLv3, with a Makefile in the Cart_Reader directory:

# Build the Retrode 3 OSCR command-line tool on Linux.
git clone https://github.com/DragonBox-Shop/retrode3-oscr.git
cd retrode3-oscr/Cart_Reader
make            # produces the CLI; C++, GPLv3

# Read the README for the exact binary name and usage,
# which can shift between revisions.
less README.md

Reading that source is the best possible preparation for the Retrode 3, because it shows you exactly which systems the underlying Cart Reader engine already understands — NES, SNES, N64, Game Boy, GBA, Mega Drive, Master System, and a long tail of others via plugins.

The Retrode 3, Late 2026

Everything above is about a fifteen-year-old device that still does its one job well. The Retrode 3 is the first real reinvention of the concept, and it changes the shape of the workflow — though not yet the shopping decision.

MIPS, Linux, and a browser

Where the Retrode 2 is an 8-bit AVR pretending to be a USB stick, the Retrode 3 is a small Linux computer — a MIPS/ARM system running Debian from an SD card. DragonBox calls the SD-card approach "practically unbrickable": if the software ever dies, you flash a fresh image and carry on. It has built-in Wi-Fi and registers as a USB-Ethernet device, so you operate the whole thing from a web browser on Windows, macOS, or Linux with no drivers and no host software at all. The entire dump-and-save workflow you just learned collapses into a web UI. DragonBox describes it as "fully open source and therefore future-proof," and the source lives across four public repositories — retrode3-oscr, retrode3-kernel, retrode3 (the Debian userspace), and retrode3-hardware (the board design itself).

Flash carts and NES support

Two genuinely new capabilities. First, NES cartridges are supported in the built-in slots for the first time — the Retrode 2 never read NES carts without workarounds. More systems are planned via plugins, including the Atari Lynx. Second, and more interesting, the Retrode 3 can write flash carts, not just read: Mega Drive flashing (via the DragonDrive cart) works, with SNES and Lynx flashing slated to arrive at launch. That turns the device from a one-way archiver into a two-way tool — dump your library and reassemble it onto modern flash carts for real-hardware play.

Should you wait?

No — not if you have cartridges to dump now. As of July 2026 the Retrode 3 is not for sale; DragonBox lists it as out of stock with a "notify me" sign-up, targets availability "by the end of the year," and a target price "under 100 EUR" (~$108). A DragonBox post described having "10 fully working prototypes" and openly asked for developers to help finish the software — which is exciting and also a clear signal that this is pre-release. If you want to preserve saves off dying batteries, the Retrode 2 does that today for €64.90. Buy the 2, learn the workflow in this guide, and treat the 3 as a future upgrade for NES support and flash-writing rather than a reason to leave your cartridges un-dumped for another six months. Batteries do not wait for product launches.

The Complete Configuration

Everything assembled into one reference. This is the working setup I would leave on a machine dedicated to cartridge archiving: a safe-by-default RETRODE.CFG, the verification script, and the RetroArch wiring that keeps cartridge and emulator saves in sync.

RETRODE.CFG, annotated

This ships saves as read-only on purpose. Flip sramReadonly to 0 only for the specific session where you intend to write a save back, then set it straight back to 1. Edit this file directly on the RETRODE volume; the LED blinks when the write lands.

# RETRODE.CFG — safe archiving defaults for Retrode 2 (fw 0.18c)
sramReadonly 1       # read-only saves; set 0 ONLY to write a save back
forceSystem auto     # auto-detect; set GG/SMS etc. only if detection fails
forceSize 0          # trust the cart header for ROM size
forceMapper auto     # trust the detected mapper
filenameChksum 1     # checksum in filename — handy for verification
detectionDelay 0     # raise this only for marginal/flaky contacts
segaSram16bit 0      # set 1 only for 16-bit-wide Sega SRAM carts
sramExt srm          # emulator-standard save extension
snesRomExt sfc       # SNES ROM extension
segaRomExt bin       # Sega ROM extension

The dump-and-verify script

Copy this once, keep it on the archiving machine, run it after each cartridge. It turns "insert cart, remount" into a single reproducible command and leaves a checksum manifest behind for auditing your collection later.

#!/bin/sh
# dump-and-verify.sh — Retrode 2 archival helper.
# Usage: ./dump-and-verify.sh /media/you/RETRODE ~/roms/incoming

SRC="$1"; DST="$2"
[ -d "$SRC" ] || { echo "No RETRODE volume at $SRC"; exit 1; }
mkdir -p "$DST"
for f in "$SRC"/*.SFC "$SRC"/*.BIN "$SRC"/*.SRM; do
  [ -e "$f" ] || continue
  cp -v "$f" "$DST"/
done
cd "$DST" || exit 1
sha1sum *.SFC *.BIN 2>/dev/null | tee -a dumps.sha1
echo "Done. Verify dumps.sha1 against a No-Intro DAT before you trust these."

RetroArch wiring

Finally, point RetroArch at your dump folder for saves so the cartridge .SRM and the emulator save are the same file. Load the correct core, load the ROM, and your real cartridge save is already there.

# RetroArch: match core to system, share the save directory
# Load Core     -> Nintendo - SNES/SFC (Snes9x) or (bsnes)
# Load Content  -> ~/roms/SUPERMET.SFC
# Genesis/MD    -> Sega - MD/Genesis (Genesis Plus GX)
#
# In retroarch.cfg, keep emulator saves next to the Retrode .SRM
# so cartridge and emulator stay in sync:
savefile_directory = "~/roms"

That is the whole discipline: clean the contacts, verify every dump, back up the save before you touch it, and never write with the wrong cart in the slot. The Retrode 2 is a fifteen-year-old device that does exactly one thing and does it honestly — it hands you your own games, as files, with no lock and no lecture. The Retrode 3 will do more, later this year. Neither one waits for the coin cell in your Pokémon cart, which is the actual clock you are racing. For the deeper archival rabbit hole, the Wikipedia entry and the official adapter documentation are the two references worth bookmarking.