Retrode 2 in 2026: Dump a Cart in 12 Steps, 20 Min

The Retrode has always been a device with a single, unglamorous job: it turns a physical cartridge into a file on your computer, and a physical controller into a gamepad your computer already understands. It does not emulate anything. It does not upscale anything. It does not have opinions about your library. It reads silicon that was manufactured before most of its users were born and hands you the bytes, and then it gets out of the way.

That is worth stating plainly in 2026, because the internet has spent two years confusing this small brown box with a games console. It is not one. And the reason people keep talking about it right now is that the company has finally announced a successor — the Retrode 3, MIPS-based, running Linux, with Wi-Fi — and the successor cannot be ordered. What you can order is the Retrode 2, the device that exists, the device that dumps carts today. This tutorial is about that device. We will get one SNES cartridge from your shelf into a verified, byte-perfect ROM in twelve steps, and then we will do everything around that: firmware, saves, special chips, controllers, and the parts of the process that lie to you.

The clock matters. The lithium and alkaline cells that hold your save games were soldered in during the Clinton administration, and the copper contacts that carry your ROM data oxidize a little every year they sit in a humid drawer. A dump you make in 2026 is a dump; a dump you keep meaning to make is a coin flip against corrosion. Let us make the dump.

What the Retrode Actually Is

A USB mass-storage reader, not an emulator

The Retrode's own FAQ says it in one sentence: it is a USB interface for vintage video game cartridges and controllers, not an emulator. When you plug it into a computer, it enumerates as a USB Mass Storage device — the same class as a thumb drive — and the cartridge's ROM shows up as a file on a tiny virtual FAT volume. No driver. No installer. No account. The operating system already knows how to talk to a flash drive, and the Retrode simply pretends to be one whose contents happen to be a Super Nintendo game. You can read the primary sources yourself on the official Retrode FAQ and the Wikipedia entry, both of which describe it as a USB adapter that lets legacy cartridges and controllers work with emulators.

Cartridges as virtual files, controllers as HID

Two things appear when a cartridge is seated. First, the game data, exposed as one or more virtual files on the RETRODE volume — a .SFC for Super Nintendo, a .BIN or .GEN for Genesis/Mega Drive, plus a .SRM that mirrors the cartridge's battery-backed save RAM. Second, the controller ports built into the shell: the Retrode 2 carries two SNES-style ports and two Genesis-style ports, and it presents whatever you plug into them as standard USB HID-class gamepads. That means the same box that dumps Chrono Trigger also lets you play it with the actual SNES pad that shipped in the box in 1995, no adapter chain required.

The read-only reality

Here is the part people miss. The Retrode reads the cartridge; it does not, in the general case, rewrite it. The FAQ is blunt: it can read standard cartridge game data but it cannot replace the ROM unless the chip itself is physically swapped. Mask ROM is mask ROM. What it can write is the save memory — the SRAM that a coin-cell keeps alive — because that memory is designed to be written. So the mental model is: ROM out, saves in and out. The device also supports firmware updates and a plug-in system explicitly intended to extend its usable life, which is how a 2011-era design is still dumping cartridges in 2026 instead of sitting in the same landfill as everything else that shipped with a mini-USB port.

The Retrode 3 Question

MIPS, Linux, Wi-Fi, open hardware — the 2026 pitch

The reason you are reading about the Retrode at all this year is the announcement of the Retrode 3, and it is a genuine architectural leap on paper. Per the Retrode product page, the successor is built around a MIPS processor running Linux, with built-in Wi-Fi and fully open software and hardware. In other words, where the Retrode 2 is a dumb, brilliant USB peripheral that needs a host PC, the Retrode 3 is a small computer that can, in principle, dump a cart and push the file somewhere over the network without a laptop in the loop at all. That is the correct direction for a preservation tool.

"Hardware finished, software in progress"

Now the deflating part. As of 2026 the Retrode site says the hardware is finished and the team is working on the software. Anyone who has watched hardware ship knows that sentence is a mood, not a milestone. "Hardware done, software in progress" is the exact status a project occupies for anywhere between three months and the heat death of the roadmap. The Linux userland, the dumping stack, the mapper detection, the web UI, the update mechanism — that is the hard, unglamorous 80 percent, and it is the part that is not done.

Under EUR 100, end of 2026, DragonBox signup

The company is aiming for availability by the end of 2026 at a target price under EUR 100, but it says plainly that the exact date and final price are still unconfirmed and that the Retrode 3 cannot be ordered yet — interested buyers are directed to sign up for notification through DragonBox, the shop that has carried the line for years. Read that as it is written: there is no product to buy, there is a mailing list. If you have cartridges to preserve, the responsible move is not to wait on a device whose software is admittedly unfinished. Buy the Retrode 2 that DragonBox still stocks, dump your shelf, and treat the Retrode 3 as an upgrade you get to evaluate when it is real. A dead save battery does not care about your preorder.

Prerequisites

The hardware you need

The irreducible kit is short. One Retrode 2 unit. One mini-USB cable — not micro, mini; the Retrode 2 predates the connector you have twelve of — and a host machine running Windows, macOS, or Linux. That is enough to dump SNES/Super Famicom and Genesis/Mega Drive cartridges, because those two slots are built into the shell. Everything else is a plug-in adapter that seats into the cartridge connector: the Game Boy / Game Boy Advance plug-in, the Nintendo 64 plug-in, and the Sega Master System plug-in are the common ones. If your goal is N64, budget for that adapter specifically; the base unit will not read a 64 cart without it.

The software stack

You need four things, and three of them are free. A file manager (you have one). An emulator front-end to actually play what you dump — RetroArch is the reference target, with the Snes9x and Genesis Plus GX cores. A checksum and DAT tool to prove your dump is correct — ClrMamePro, RomVault, or RomCenter, fed by the No-Intro DAT-o-MATIC databases. And, if you intend to update firmware, dfu-programmer (Linux/macOS) or Atmel FLIP (Windows), because the Retrode's brain is an 8-bit Atmel AT90USB1287 AVR and it flashes over the standard Atmel DFU bootloader.

Versions that matter

Pin these down before you start. Firmware: the stock shipping firmware dumps ordinary LoROM/HiROM SNES and standard Genesis carts fine, but community beta firmware in the v0.18d to v0.19 beta line widened mapper and special-chip handling. Treat those betas as community-maintenance builds rather than a formal official release — they are the difference between "my Super Street Fighter II dumped" and "why is this file half the size it should be," but they are maintained by the community, so read the thread before you flash. RetroArch: any current stable release is fine; the cores move faster than the front-end. No-Intro: always pull a fresh DAT, because the databases are revised and an old DAT will flag a good dump as unknown. Grab today's DAT the day you verify.

Dumping Your First Cartridge

Twelve steps, each with a reason. Do them in order the first time; after that they collapse into muscle memory and about ninety seconds per cart.

1. Clean the cartridge. Cotton swab, 99% isopropyl alcohol, along the edge connector until the swab comes away clean. Rationale: every misread you will ever have starts here. Oxidation on the contacts is the single largest cause of bad dumps, and no firmware fixes a dirty pin.
2. Clean the Retrode's slot too. A blast of compressed air, and if the slot has seen a decade of carts, a cleaning cartridge or a careful swab. Rationale: the contamination is symmetrical; a clean cart in a filthy slot is still a filthy connection.
3. Seat the cartridge fully in the correct slot. SNES/Super Famicom in the SNES slot, Genesis/Mega Drive in the Genesis slot. Push until it stops; do not force a region-mismatched shell. Rationale: a half-seated cart reads intermittently, which is worse than not reading at all because it produces a file that looks plausible and is wrong.
4. Connect the Retrode to the host with the mini-USB cable. Rationale: seat the cart first, then power up. Hot-swapping cartridges on a live bus is how you eventually corrupt a read mid-transfer.
5. Confirm it mounted. On Linux, watch the kernel log; on Windows/macOS, wait for the RETRODE volume to appear.

   $ dmesg | tail -n 6
   usb 1-2: new full-speed USB device number 7 using xhci_hcd
   usb 1-2: New USB device found
   usb-storage 1-2:1.0: USB Mass Storage device detected
   scsi host6: usb-storage 1-2:1.0
   sd 6:0:0:0: [sdb] Attached SCSI removable disk
   sd 6:0:0:0: [sdb] Attached: RETRODE

   Rationale: if no mass-storage device appears, stop — the problem is physical (steps 1–3), not software.
6. Open the volume and read the file list. You should see a ROM file and a save file, both with the 8.3 FAT name the firmware derives from the cartridge's internal header, both timestamped 1980 because the device has no clock.

   $ ls -l /media/user/RETRODE/
   -rw-r--r-- 1 user user 4194304 Jan  1 1980 CHRONO~1.SFC
   -rw-r--r-- 1 user user    8192 Jan  1 1980 CHRONO~1.SRM

   Rationale: the size is your first sanity check. A 32 Mbit game is 4,194,304 bytes. If the ROM reads as 0 bytes or a suspiciously round fraction, the cart is not seated.
7. Copy the ROM off the device to real storage. Drag it, or cp it, to a working folder on your disk. Rationale: never verify or edit the file on the RETRODE volume — it is a live read of the cartridge, not a place to keep files.
8. Copy the save (.SRM) off as well. Rationale: this is your battery backup. The coin cell in that cartridge will die; the day it does, this file is the only thing standing between you and a wiped save. Back it up before you do anything else.
9. Safely eject, then remove the cartridge. Rationale: the FAT dirty bit matters. Yank the volume mid-write and the next mount may come up read-only, which blocks you from restoring saves later.
10. Check for a copier header. A raw SNES dump is a power-of-two-ish size; a stray 512 bytes on the front means an old-style header is present.

    # A clean SNES dump should be a multiple of 1024 bytes.
    # If (size mod 1024) == 512, a 512-byte copier header is attached.
    $ stat -c%s "Chrono Trigger (USA).sfc"
    4194304
    # 4194304 mod 1024 = 0  ->  headerless, correct.
    # If it read 4194816, strip the header like this:
    $ dd if=headered.smc of=clean.sfc bs=512 skip=1

    Rationale: No-Intro is headerless. A headered file fails verification even when the actual game data is perfect.
11. Verify against a checksum. Hash the file and compare it to the No-Intro database.

    $ sha1sum "Chrono Trigger (USA).sfc"
    [40-hex-digit digest]  Chrono Trigger (USA).sfc
    # Compare that digest to the No-Intro DAT entry for the title.
    # Match  = byte-perfect dump.
    # Mismatch = bad read, wrong header, or an unsupported special chip.

    Rationale: a dump you did not verify is a rumor. This is the step that separates preservation from hoarding.
12. Load it and confirm the controllers. Point RetroArch at the verified ROM, pick the core, and bind the Retrode's HID pads.

    $ retrarch="$HOME/.config/retroarch"
    $ retroarch -L "$retrarch/cores/snes9x_libretro.so" \
        "$HOME/roms/snes/Chrono Trigger (USA).sfc"

    Rationale: booting the game is the final proof that the dump is not just checksum-correct but actually runs, and it confirms your original pad works through the Retrode's HID interface at the same time.

That is the whole loop. The first cart takes fifteen to twenty minutes because you are reading a tutorial while you do it. The fiftieth takes ninety seconds.

Verifying Against No-Intro

Why checksums, not vibes

The Retrode reads a cartridge over a physical bus with physical contacts, which means every dump is a measurement, and measurements have error. A single flaky pin can flip bits in a way that boots fine, looks fine, and corrupts a texture or a text box forty hours into an RPG. The only defense is a cryptographic checksum compared against a known-good reference. The reference is No-Intro, whose DAT-o-MATIC publishes CRC32, MD5, and SHA-1 digests for the canonical dump of nearly every commercial cartridge. If your SHA-1 matches theirs, your file is bit-for-bit identical to the community's verified reference. If it does not match, something is wrong, and you want to know now, not in the second act.

Headered versus headerless — the 512-byte trap

The most common false failure is the copier header. In the floppy-disk-copier era, tools like the Super Wild Card prepended a 512-byte header to SNES ROMs. No-Intro standardized on headerless files, so a modern verified Chrono Trigger is exactly 4,194,304 bytes. If your dump is 4,194,816 — exactly 512 more — you have a header, and every checksum will fail even though the game data underneath is perfect. The dd if=headered.smc of=clean.sfc bs=512 skip=1 incantation from Step 10 removes it. Most Retrode firmware dumps headerless already; the check exists because "most" is not "all," and because ROMs you were handed by other people carry other people's headers.

The ClrMamePro / RomVault workflow

For one cartridge, a manual sha1sum is fine. For a shelf, use a ROM manager. Load the current SNES and Genesis DATs into ClrMamePro or RomVault, point it at your folder of dumps, and let it scan. It will rename correct files to their canonical No-Intro names, flag mismatches, and tell you exactly which titles failed. A green scan across your whole library is the receipt that says the job is done. This is also where you catch the subtle failures — the cart that dumped a valid-looking file that is nonetheless a byte off because a contact was marginal. Reclean, reseat, redump, rescan. The database does not get tired of being right.

Flashing the v0.19 Firmware

Why update at all

If your carts are ordinary — standard LoROM and HiROM SNES games, standard Genesis games — the shipping firmware is fine and you can skip this entire section. You update firmware for exactly one reason: wider mapper and special-chip support. The community betas in the v0.18d and v0.19 beta line improved detection and reads for a number of carts the stock firmware handled poorly or not at all. Note the word community: these are maintained by the enthusiast base, not signed off as an official release, and the Retrode forums — still tracking press and firmware in mid-2026, per an active "Retrode in the news!" thread dated June 2026 — are where you confirm which build is current and what it fixes. Read the thread before you flash. Flash for a reason, not for the version number.

Bootloader mode and dfu-programmer

The Retrode's microcontroller is an Atmel AT90USB1287, an 8-bit AVR with native USB, and it exposes the standard Atmel DFU bootloader. Put it into bootloader mode (hold the on-board button while connecting USB), confirm the AVR enumerates as a DFU device, then erase, flash, and reset with dfu-programmer.

# With the Retrode in DFU/bootloader mode, confirm the AVR is present:
$ lsusb | grep -i atmel
Bus 001 Device 009: ID 03eb:2ffb Atmel Corp. atmega/at90usb DFU bootloader

$ sudo dfu-programmer at90usb1287 erase
$ sudo dfu-programmer at90usb1287 flash retrode-0.19beta.hex
$ sudo dfu-programmer at90usb1287 reset

The VID:PID 03eb:2ffb is Atmel's DFU bootloader identity; if you do not see it, the device is not in bootloader mode — disconnect, hold the button, reconnect. Windows users do the same thing through Atmel FLIP with the same .hex file.

The RETRODE.CFG config file

The Retrode reads a plain-text configuration file, RETRODE.CFG, from its own volume. This is where you override auto-detection when a cart fools it — forcing a mapper, forcing a ROM or SRAM size, toggling the controller pass-through. The exact keys depend on your firmware revision, and the canonical list lives in the Retrode wiki, but a representative file reads like this:

; RETRODE.CFG - representative; confirm keys against your firmware's wiki page

[General]
autodetect = 1        ; 1 = detect cartridge type automatically

[SNES]
mapper = auto         ; auto | lorom | hirom  (override if a dump is wrong)
force_rom_kb = 0      ; force ROM size in KB when detection guesses wrong (0=auto)
force_sram_kb = 0     ; force save-RAM size in KB (0=auto)

[Genesis]
save_passthrough = 1  ; expose cart SRAM/EEPROM as a writable .SRM

[Controllers]
snes_pads = 1         ; expose SNES ports as USB HID gamepads
genesis_pads = 1      ; expose Genesis ports as USB HID gamepads
genesis_6button = 1   ; report 6-button pads when detected

Edit it on the device, safely eject, reconnect, and the new settings take effect on the next read. When a stubborn cart dumps the wrong size, forcing the ROM length here is often the fix.

Special Chips That Fight Back

SNES coprocessors

The Super Nintendo's cartridge slot was a bus, and Nintendo let publishers hang extra silicon off it. That silicon is why some of the best games on the system are the hardest to dump. The SuperFX (Star Fox, Yoshi's Island, Stunt Race FX, Doom) and the SA-1 (Kirby Super Star, Super Mario RPG, Kirby's Dream Land 3) are the notorious ones, because the coprocessor sits between the console and the ROM and mediates every access. A generic bus read cannot always orchestrate a chip that expects to be driven a specific way. The S-DD1 (Star Ocean, Street Fighter Alpha 2), SPC7110, CX4 (Mega Man X2/X3), and the DSP family (Super Mario Kart, Pilotwings) each add their own quirks. Newer beta firmware handles more of these than the stock build did, but manage your expectations: some special-chip titles have never dumped cleanly on a Retrode, and the honest answer for those is a different dumping method. Verify these especially hard against No-Intro — a partial special-chip read is exactly the kind of file that boots and then betrays you. For the games that resist, this is where a cycle-accurate FPGA solution like the MiSTer Multisystem 2 earns its keep, because it runs the original mapper logic rather than trying to read around it.

Genesis oddballs

Sega's side has its own landmines. The SVP chip in Virtua Racing is effectively a small DSP on the cart and does not dump conventionally. Large bank-switched ROMs — Super Street Fighter II at 40 Mbit is the poster child — need firmware that understands the mapper, or you get a truncated file. And the EEPROM save games (several sports titles, Wonder Boy in Monster World, some Codemasters carts) store saves differently from plain battery SRAM, so the .SRM pass-through can behave unexpectedly. As always: dump, then verify the size and checksum against No-Intro before you trust it.

Plug-ins: Game Boy, N64, Master System

The plug-in adapters turn the two-system box into a small fleet. The GB/GBA adapter reads handheld carts and their saves; the Master System adapter handles Sega's 8-bit library; and the N64 adapter reads cartridge ROM and the various N64 save types. If your endgame is a 64 collection, the plug-in is mandatory, and once dumped, those ROMs feed straight into hardware built for them — an FPGA cartridge console like the Analogue 3D for N64, or any of the software emulators. The dumped file does not know or care what plays it; it is just correct bytes.

Common Pitfalls

The ones that produce silent bad files

Trusting a single dump without a checksum. The most expensive mistake, because it is invisible. A marginal contact produces a file that boots and is wrong. Fix: verify every dump against No-Intro, no exceptions. The 512-byte header confusion. A perfect game-data dump fails verification because a copier header is attached, and a novice concludes the cart is bad. Fix: check size mod 1024, strip 512 bytes with dd if present. Assuming special-chip carts will dump. You slot Yoshi's Island, get a file, and never check it. Fix: treat every SuperFX/SA-1/DSP/SVP title as guilty until the checksum proves it innocent, and update firmware first.

The physical and geometric ones

Dirty contacts. Still the number-one cause of every category of failure. Fix: clean the cart and the slot with 99% IPA before you blame anything else. Region tabs and slot geometry. Some cartridge shells have region tabs that resist insertion; forcing a cart bends pins. Fix: seat gently, and if a shell will not go, confirm you are not fighting a region-locked plastic notch rather than mashing harder.

The save and legal ones

Confusing RetroArch's .srm with raw cartridge SRAM. The emulator's save file layout does not always match the raw memory the Retrode writes back, so a save copied off in RetroArch may not restore to the cart, and vice versa, if sizes or padding differ. Fix: match the exact SRAM size and write the raw save through the RETRODE volume; do not assume cross-compatibility. The "I own the cart so I can download the ROM" pitfall. This is a legal error, not a technical one. Owning a cartridge does not make downloading someone else's ROM lawful — distribution is infringement regardless of what is on your shelf. Fix: dump your cartridge. That is the entire point of the device.

Troubleshooting

Symptoms, causes, and fixes for the failures you will actually hit.

Advanced Tips

Script the verification

Once you are dumping a shelf, hashing files one at a time is a waste of a computer. Write the digests to a manifest and let a ROM manager diff the manifest against a DAT.

#!/usr/bin/env bash
# verify-dumps.sh - hash every dump into a manifest for DAT comparison
set -euo pipefail
shopt -s nullglob
out="checksums.sha1"
: > "$out"
for f in *.sfc *.smc *.bin *.gen *.md; do
  printf '%s  %s\n' "$(sha1sum "$f" | cut -d' ' -f1)" "$f" >> "$out"
done
echo "Wrote $(grep -c . "$out") digests to $out"

Run it in your dump folder, then feed checksums.sha1 and the No-Intro DAT to RomVault. Any file not accounted for is a file you need to look at.

Save management and .srm parity

The subtle art is keeping cartridge saves and emulator saves in sync. When you dump a cart, the .SRM the Retrode gives you is the raw battery memory. RetroArch will happily use a matching raw SRAM, but its own save format can differ in padding or size for some systems, so treat the Retrode's .SRM as the source of truth for the physical cartridge and keep a separate copy for the emulator. If you later want to push emulator progress back to the cart, verify the byte sizes match before you write — a size mismatch written to a battery-backed cart is how you wipe a real save. The full input-mapping and core details are in the RetroArch documentation.

Where your dumps belong

A verified ROM is portable by definition, which is the whole reason to make one. The same file plays on a frozen-in-amber RetroPie build, on a pocket emulator like the Retroid Pocket 6, or on a curated micro-console like the Miyoo Mini Plus. The destination software is mature and boring in the good way — the open-source retro scene spent early 2026 in quiet consolidation, with projects like RetroDECK reporting, in their January 2026 update, a post-0.10.0b period of minor patches and "no new announcements." Boring is what you want under your one-time-only cartridge dumps. Make the file correct once; play it everywhere for the next twenty years.

The Complete Configuration

RETRODE.CFG reference

The working configuration you can drop onto the device. Keys are representative — confirm against your firmware's wiki page — but this is a sane baseline that leaves auto-detection on and exposes both cartridge and controller functions.

; RETRODE.CFG - working baseline

[General]
autodetect = 1

[SNES]
mapper = auto
force_rom_kb = 0
force_sram_kb = 0
use_cart_title = 1     ; name files from the cartridge header (8.3 FAT)

[Genesis]
save_passthrough = 1

[Controllers]
snes_pads = 1
genesis_pads = 1
genesis_6button = 1

RetroArch core and input

The host side. Point the extensions at the right cores and let RetroArch autoconfigure the Retrode's HID pads.

# ~/.config/retroarch/retroarch.cfg (relevant lines)
input_autodetect_enable = "true"
input_joypad_driver = "udev"

# Core mapping (paths vary by platform / Flatpak):
#   SNES     -> snes9x_libretro.so     (accuracy: bsnes_libretro.so)
#   Genesis  -> genesis_plus_gx_libretro.so
#
# Load a verified dump from the command line:
#   retroarch -L cores/snes9x_libretro.so "roms/snes/Game (USA).sfc"

The verification one-liner you will actually reuse

And the check you run after every single dump, which is the only line in this article you are not allowed to skip.

# Hash a dump and eyeball it against the No-Intro DAT entry.
$ sha1sum "Super Metroid (Japan, USA).sfc"
[40-hex-digit digest]  Super Metroid (Japan, USA).sfc
# Match against No-Intro = keep it. Mismatch = clean, reseat, redump.

The Verdict

Who should buy a Retrode 2 in 2026

Anyone with a shelf of SNES, Super Famicom, Genesis, or Mega Drive cartridges and a batter of save games worth keeping. The Retrode 2 is not the fastest dumper ever made and it is not the cheapest, but it is the most legible: it mounts as a flash drive, it hands you a file, and it lets you play through the cartridge's own controller ports on the same device. There is no lock-in, no cloud, no account, and no emulation happening inside the box to argue about. It does one job and does it in a way you can fully inspect. In an ecosystem drowning in handhelds that ship with 28,000 ROMs of dubious provenance, a tool that produces your own verified dumps is the honest end of the hobby.

The legal line

Here is where The Machine reads the statute so you do not have to guess. Dumping a cartridge you physically own is a grey area that leans defensible: 17 U.S.C. §117 has long been read to permit an archival copy of a computer program by its owner, and a bare SNES or Genesis cartridge has no encryption or access control on its bus, so the DMCA's §1201 anti-circumvention provisions are simply not implicated — you are not "circumventing" anything, you are reading unprotected memory. What that does not license is downloading someone else's ROM because you happen to own the cart, and it does not license sharing your dump. Owning the object and owning the right to distribute the software on it are different things. Dump your carts. Keep the files. Do not hand them out.

What to watch for the Retrode 3

Keep the DragonBox notification signup, and keep your expectations calibrated. The Retrode 3's MIPS-and-Linux, Wi-Fi, fully-open-hardware pitch at a target under EUR 100 is the right design, and "hardware finished" is real progress. But "software in progress" with an unconfirmed date and price, aiming vaguely at the end of 2026, is not a product you can plan around — it is a promising project. The move is not to wait. Buy the device that dumps cartridges today, preserve the fragile things while they are still readable, and evaluate the Retrode 3 the day it is something you can put in a cart, not just an email address. The successor will still be there when it ships. Your save batteries might not be.