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

If you typed "retrode" into a search bar and arrived here expecting to be told which planet is about to ruin your fortnight, close the tab. Mercury's retrograde is astrology; the Retrode is hardware. The two words differ by a single letter and roughly four centuries of epistemology, and somewhere in 2025 the search engines quietly decided they were the same thing. They are not. The Retrode is a USB cartridge reader — a small grey box into which you slot an original Super Nintendo or Sega Mega Drive cartridge, and off which your computer copies the game as a plain file. No soldering, no chip-off desoldering, no drivers. It has done this, essentially unchanged, since 2010.

This is a tutorial for people who own old cartridges and want honest, verifiable copies of what those cartridges contain: the ROM, and where a cartridge carries a battery, the save data too. We will walk the entire process in twelve numbered steps — call it thirty minutes from unboxing to a checksummed dump — and then keep going, because the interesting failures happen after step twelve. The config file. The save-write-back trap that quietly eats people's childhood save games. The plug-in adapters and their asterisks. And the long-promised Retrode 3, which DragonBox has been shipping "by the end of the year" for long enough that the phrase has acquired a certain patina.

One point of lore before the box. Dumping a cartridge you own, for your own use, occupies the same grey, widely-tolerated corner as ripping a CD you paid for: format-shifting personal property. Distributing the resulting ROM does not occupy that corner at all; that is plain copyright infringement, and the site's notional lawyers would like it on the record that they said so. The Machine is not your attorney and this is not legal advice. Now, the hardware.

What a Retrode Actually Is

A USB cartridge reader, not a flashcart or an emulator

The Retrode belongs to a category people constantly confuse with two adjacent ones. It is not a flashcart — it does not put ROMs onto a cartridge to play on real hardware (the Retrode 2 reads only; the Retrode 3 finally adds flash writing, more on that below). It is not an emulator — it runs no games and renders no frames. It is a bridge. Plug a cartridge into the top, plug a USB cable into your PC, and the cartridge's contents appear as files. The elegance is that it does this by pretending to be things your operating system already understands: on the Retrode 2, a USB mass-storage device (a thumb drive, essentially) plus a pair of USB HID gamepads, so the controller ports on the unit register as ordinary game controllers.

Because it impersonates a thumb drive, there are no drivers to install on Windows, macOS or Linux — and, historically, none on the Pandora or Caanoo handhelds it was born alongside. You open the drive, you see your game as a file, you copy it. The Wikipedia entry on the Retrode puts the mechanism plainly: cartridge contents — typically a ROM chip and, optionally, a battery-backed SRAM — are exposed as files on a USB medium. That is the whole trick, and it has aged extraordinarily well precisely because it leans on standards nobody is going to break.

Read Only Memory means, regrettably, read only

The Retrode 2's own documentation contains the driest joke in the hobby: ROM stands for Read Only Memory, hence, no — you cannot write a game back to a mask-ROM cartridge, because the silicon physically cannot be rewritten. What is writable on many carts is the SRAM: the little battery-backed chip that holds your saved games. The Retrode exposes that as a separate .srm file, and by default it write-protects it so you cannot clobber a thirty-year-old save by dragging a file into the wrong window. We will spend a whole section on that later, because the default is the correct default and the people who change it without reading are the people who write in asking where their save went.

The astrology detour, briefly

Since it must be said: no, this device has nothing to do with Mercury, Venus, or the apparent backward motion of the outer planets. The naming collision is genuinely unfortunate for a niche of retro-hardware people who now share a search namespace with the entire astrology internet. If you have arrived by accident, the closest thing this article offers to a horoscope is the following prediction: if you hot-swap a cartridge without ejecting first, your save game will end badly. That is not written in the stars. It is written in the user guide.

Prerequisites: Hardware, Software, and Versions

The hardware you actually need

The shopping list is short and, mercifully, cheap by 2026 standards. You need a Retrode 2 unit; it is the shipping product and has been for years. In the United States, Stone Age Gamer lists it at US$99.99; direct from the manufacturer, DragonBox sells the Retrode 2 for €64.90. In the box: the unit, a USB cable, and an instruction sheet — that is all it has ever come with. You supply the cartridges. You will also want a bottle of 99% isopropyl alcohol and a few cotton swabs, because the single most common reason a dump fails is filthy cartridge contacts, and thirty-year-old edge connectors are filthy by default.

Optionally, the plug-in adapters, sold separately: N64, Game Boy (the "GBx" adapter covering GB/GBC/GBA), and Master System. These run US$39.99 each at Stone Age Gamer, or €25 each from DragonBox, with an all-three €65 plug-in bundle. We will cover what they can and cannot do in their own section, because "reads the ROM" and "backs up the save" are two different promises and the adapters keep only one of them cleanly.

Firmware and drivers — there are none to install

Two facts that trip up newcomers. First: there is no driver. The Retrode 2 is a standards-compliant USB mass-storage-plus-HID composite device, so Windows, macOS and Linux mount it the way they mount any flash drive, with nothing to download. Second: the firmware is frozen and that is fine. The last builds are 0.18c (stable) and 0.18d beta 3, both from roughly 2016, and the mirrored listing at Softpedia's Retrode 0.18c page confirms the version. Firmware 0.18 itself was a meaningful release: it improved N64 and GBA size detection, updated the underlying LUFA USB stack by Dean Camera, fixed a Master System plug-in bug, and added Master System SRAM reading. You do not need to flash anything to dump a standard SNES or Genesis cartridge; a factory unit does that out of the box. Firmware only becomes relevant for edge cases and DFU recovery, covered under Advanced Tips.

Software on the host

You need a file manager, which you already have. Everything past that is optional but recommended if you care about preservation rather than merely having a file that boots. Get a hashing tool — sha1sum ships with Linux and macOS, and Windows has certutil -hashfile. Get a No-Intro DAT for the systems you are dumping and a verifier that reads it (RomVault or clrmamepro); that is how you prove a dump matches the known-good database rather than merely hoping. And get an emulator to test with — RetroArch and the libretro cores are the obvious choice, and we cover setting them up separately. To confirm the unit mounted on Linux, plug it in and check the kernel log; you are looking for a mass-storage device, not a specific vendor ID:

$ lsusb | grep -i retrode
Bus 001 Device 007: ID <vendor>:<product>  Retrode2

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

Note the placeholder vendor/product ID: the exact numbers vary and are not worth asserting. What matters is the phrase USB Mass Storage device detected and a new removable disk appearing. If you get that, you are ready.

Retrode 2 vs Retrode 3: What You're Actually Buying

The Retrode 2 — the one you can buy today

Everything in the step-by-step below is written for the Retrode 2, because it is the unit that exists, ships, and sits on a shelf. Its design is deliberately conservative: an Atmel AT90USB646 AVR microcontroller, the LUFA firmware, mass-storage emulation, and two-plus-two controller passthrough. It does one job — expose cartridge contents as files — and it does that job on any operating system without ceremony. The trade-off is that it reads only, its co-processor support has hard limits, and its save handling on the adapters is partial. Those are known quantities, which is exactly why people still buy it in 2026.

The Retrode 3 — MIPS, ARM, or whatever the page says today

The successor has been imminent for a while. The DragonBox Retrode 3 page describes a genuinely different machine: a full Linux system-on-chip running Debian, presenting itself to your PC as a USB-Ethernet device so the entire interface is a web browser at a local address — no drivers, no mass-storage window, just a page. It has built-in Wi-Fi, so you can dump wirelessly and push ROMs to a server. It adds an NES slot alongside SNES and Mega Drive. And crucially it can write flash carts: MegaDrive (via DragonDrive) works now, with SNES and Lynx flashing promised "when the Retrode 3 ships."

A note in the spirit of technical precision, because the site's readers expect it: the manufacturer's own page cannot decide what CPU it is. The opening blurb says "MIPS processor"; further down, the same page says the hardware has "its own ARM processor and a Linux operating system (Debian)." Pick your favourite architecture; either way it is a Linux SoC, and the marketing copy contradicting itself is a fair preview of the general state of the project. The important, verifiable claims are less ambiguous: target price under €100, availability "by the end of the year," currently out of stock with only a "notify me" list, and — a genuinely nice property — the OS lives on an SD card and is, in their words, "practically unbrickable – just flash a new image." The whole thing is "fully open source and therefore future-proof," built atop Sanni's open Cart Reader, with source split across the retrode3-oscr and companion repositories.

Which one, and should you wait?

The honest answer: if you have cartridges to dump this month, buy the Retrode 2. It works, the workflow below is complete, and the price has been stable. If your wish-list is specifically flash-cart writing, an NES slot, or wireless dumping, the Retrode 3 is the machine you want — but "end of year" has been the answer through several ends of several years, and DragonBox's own social posts frame the project as having "10 fully working prototypes" and "looking for developers," which is the language of a thing that is close but not shipping. Here is the comparison, without the marketing gloss:

Dumping a Cartridge in 12 Steps

Before you start — clean the contacts

Ninety percent of "my Retrode isn't working" is a dirty cartridge. Before the first plug-in, dampen a cotton swab with 99% isopropyl alcohol — not the 70% chemist-shop stuff, which is mostly water and leaves residue — and run it firmly across the edge connector until the swab stops coming away grey. Let it flash off for a minute; alcohol evaporates fast but the connector should be bone-dry before it meets the reader. Do not use Brasso, toothpaste, or any of the abrasive "retro cleaning" folk remedies that circulate on forums; they remove the gold plating along with the grime and shorten the cartridge's life. Clean, dry contacts are the single highest-leverage thing you can do, and it takes ninety seconds.

The twelve steps

1. Insert the cartridge, powered off. SNES/SFC goes in the wide upper slot, Mega Drive/Genesis in the shorter lower slot. Seat it fully and squarely. Rationale: the Retrode reads the cartridge edge connector directly; a half-seated cart reads as garbage or not at all.
2. Connect the USB cable to the Retrode first, then to the PC. Rationale: letting the cartridge settle in the slot before the bus enumerates avoids a mount that races the physical connection — the same reason the adapters insist on being attached before USB.
3. Wait for the drive to mount. The unit appears as a removable disk labelled RETRODE. On Linux, confirm with the dmesg output shown earlier. Rationale: if it never mounts, nothing downstream will work; stop and troubleshoot the connection, not the software.
4. Open the drive and read the file listing. You should see one ROM file named after the cartridge's internal header, plus RETRODE.CFG, plus an .SRM if the cart has battery-backed save memory. Rationale: the filename comes from the cartridge header, so a sensible name is your first confirmation the read is clean.
5. Check the ROM's reported size. A Super Nintendo game is typically 512 KB to 4 MB; a Mega Drive game similar. Rationale: a 0 KB or absurdly small file means a bad contact or an unsupported mapper — catch it now, before you copy.
6. Copy the ROM file to your computer. Drag it off, or use the shell. Rationale: you are reading from a slow embedded device; copy once to fast local storage and work from there rather than hammering the cartridge with repeated reads.
7. Copy the .SRM save file too, if present. Rationale: the battery that backs that SRAM is decades old and dying; the copy you make today may outlive the cell in the cartridge.
8. Do not hot-swap. When you want a different cartridge, eject the drive and unplug the Retrode, or press the RESET button (the lower of the two buttons) to force a clean re-mount. Rationale: the official user guide is explicit that swapping live "can potentially damage on-cartridge savegames"; a truncated dump is annoying, a corrupted save is permanent.
9. Insert the next cartridge and press RESET. Rationale: RESET re-reads the header and re-mounts; without it the drive may still show the previous cartridge's files.
10. Watch the LED. It lights during ROM and RAM access and blinks when the config file is written. Rationale: the LED is your only real-time feedback; a light that never comes on during a copy means the read never happened.
11. Verify the checksum. Hash the ROM and compare it against a No-Intro DAT entry for the same title. Rationale: a file that opens is not the same as a file that is correct; only the checksum proves it.
12. Eject cleanly and file the results. Unmount the drive before unplugging, and store the ROM plus its .SRM together under a sane naming scheme. Rationale: an orphaned save with no matching ROM is a puzzle you will curse in two years.

What a clean run looks like (expected output)

After a good dump of a cartridge with battery save, the drive listing looks like this — ROM, save, and config, all present and sensibly sized:

/media/you/RETRODE/
├── THE LEGEND OF ZELDA.SFC     1,024 KB
├── THE LEGEND OF ZELDA.SRM         8 KB
└── RETRODE.CFG                     1 KB

A cartridge with no battery save — an early Sonic, say — shows the ROM and the config only, with no .SRM, which is correct and not a fault:

/media/you/RETRODE/
├── SONIC THE HEDGEHOG.BIN        512 KB
└── RETRODE.CFG                     1 KB

Copying off is then whatever your platform prefers; on Linux or macOS the shell is fastest:

# Copy your dumps off the Retrode
mkdir -p ~/roms/snes
cp "/media/you/RETRODE/THE LEGEND OF ZELDA.SFC" ~/roms/snes/
cp "/media/you/RETRODE/THE LEGEND OF ZELDA.SRM" ~/roms/snes/

The RETRODE.CFG File, Explained

How the config works

The Retrode is configured not through an app but through a text file that lives on the drive it presents. Open RETRODE.CFG in any text editor, change a value, save, and the unit blinks its LED to acknowledge that it wrote the new configuration. This user-editable config has been a feature since firmware 0.17g, and it is how you coax the reader through cartridges that don't announce themselves cleanly. There is no other UI; the file is the UI.

A caveat on documentation, delivered in the interest of not sending you somewhere dead: the historical canonical reference for these keys lived at retrode.org, and as of mid-2026 that address 302-redirects to retrode.com's front page — the detailed CFG documentation is effectively offline. The key names below are confirmed from the firmware and from the surviving guide text, but treat the example as illustrative of the format rather than a copy of a live doc, and cross-check against the current official Retrode FAQ if a key behaves unexpectedly.

The keys that matter

A handful of parameters carry almost all the practical weight. sramReadonly (0 or 1) is the write-protect on your save files and defaults to 1 — leave it there unless you are deliberately restoring a save. segaSram16bit (0 or 1) tells the reader to pack Sega SRAM as 16-bit words, which some Mega Drive carts need for the save to come out the right size. filenameChksum appends a checksum to the generated filename, handy for batch verification. detectionDelay adds a pause before the cartridge is read, which rescues flaky carts that mount before they have electrically settled. Here is the format:

# RETRODE.CFG — edit on the mounted drive, then save
sramReadonly    1        # 1 = write-protect saves (default, safe)
segaSram16bit   0        # 1 = pack Sega SRAM as 16-bit words
filenameChksum  0        # 1 = append a checksum to the filename
detectionDelay  0        # raise if a cart mounts before it settles
forceSystem     auto     # auto | SNES | MD | GG | SMS
forceSize       0        # 0 = auto-detect ROM size
forceMapper     0        # 0 = auto; override only for oddball carts

forceSystem, forceSize, forceMapper for stubborn carts

The three force* keys are your escape hatch. forceSystem overrides the auto-detected platform; it exists because some cartridges — Game Gear read through the Master System adapter is the classic case — are not identified correctly on their own. (Firmware 0.18d beta 3 specifically fixed a "forceSystem GG not recognized" bug, so if you are wrangling Game Gear carts, that beta is the one to run.) forceSize lets you hard-set a ROM size in kilobytes when detection guesses wrong, and forceMapper overrides the memory mapper. The discipline here is to leave everything on auto until a specific cartridge misbehaves, then change exactly one key, re-dump, and verify — not to pre-emptively "tune" a config that was working fine.

Backing Up Saves: SRAM, Write-Protection, and .SRM

Why saves are read-only by default

The Retrode treats your on-cartridge save data as something to protect from you, and it is right to. By default sramReadonly is 1, meaning the .SRM file the reader exposes is write-protected — you can copy it off, but you cannot overwrite the cartridge's SRAM by fumbling a file operation. The archived user guide is blunt about the risk of the alternative: RAM files are "by default write-protected," and hot-swapping is "possible, but it can potentially damage on-cartridge savegames," with the guide's own advice being to "prefer to eject/unplug the Retrode first." The battery-backed save on a 1994 cartridge is, by definition, irreplaceable original data. Copy it early, copy it often, and treat the cartridge's copy as the thing you are trying not to touch.

Writing a save back to the cart

Sometimes you do want to write — to restore a save you backed up before the battery died, or to move a save between two copies of a game. To do that you set sramReadonly 0 in the config, at which point the .SRM on the drive becomes writable and copying a save file onto it commits to the cartridge's SRAM. This is a genuinely useful capability and also the single easiest way to destroy a save, because now every drag-and-drop is live. Back up the existing save first, change the key, do the one operation you intended, and set the key back to 1 immediately. The people who lose saves are the people who left write-protect off "for convenience" and then reorganised a folder.

Sega's 16-bit SRAM quirk

Mega Drive saves have a wrinkle that SNES saves do not. Some Sega cartridges store SRAM in a byte layout that comes out wrong-sized or byte-swapped unless the reader packs it as 16-bit words — that is what segaSram16bit exists for. If a Genesis save dumps at half or double the size you expect, or an emulator refuses to load it, flip segaSram16bit and re-dump the save. This is also why a save that round-trips perfectly on SNES can be maddening on Sega: the platforms genuinely differ, and the config has a key for exactly this reason.

Plug-In Adapters: N64, Game Boy, Master System

What each adapter reads — and doesn't save

Three adapters extend the Retrode 2 beyond its two built-in slots, and the official plug-in adapters page is refreshingly candid about their limits. The N64 adapter reads ROMs fine, runs at 3.3V, supports up to two controllers, and must be connected before USB — but save support is listed as "firmware support pending," which after this many years should be read as "do not count on it." The GBx (Game Boy) adapter reads Game Boy, Game Boy Color and Game Boy Advance ROMs, and reads GB/GBC SRAM saves cleanly; GBA SRAM and flash saves are, again, "pending." It runs GB/GBC at 5V and GBA at 3.3V, which it handles automatically. The Master System adapter reads ROMs, and firmware 0.18 added SMS SRAM reading — though SMS cartridges frequently lack a header title field, so expect generic filenames you will have to rename by hand.

The 'pending' save-support reality

Notice the pattern: ROM reading is solid across all three adapters, but save support carries an asterisk on N64, GBA, and historically SMS. "Firmware support pending" on a product whose firmware froze around 2016 is a polite way of saying it is not coming to the Retrode 2. If your goal is specifically N64 or GBA save backup, the Retrode is the wrong tool and you want a dedicated cart reader — which is, not coincidentally, exactly the gap the Retrode 3 and Sanni's Cart Reader project aim to close. Buy the adapters for what they reliably do (ROMs, plus GB/GBC and SNES/Genesis saves), not for the pending line items.

32X yes, Super Game Boy no — and the co-processor carts

Two folklore facts worth stating plainly. The Sega 32X adapter works with the Retrode without its external power supply attached; the Super Game Boy adapter does not work, because it is effectively a whole console front-end rather than a cartridge pass-through. And the co-processor question, which people get wrong constantly: cartridges with a Super FX or DSP1 chip (Star Fox, Super Mario Kart) dump fine — the chip lives on the cartridge and your emulator handles it. What the Retrode cannot read are cartridges using SA-1 (Super Mario RPG, Kirby Super Star, Kirby's Dream Land 3), S-DD1 (Star Ocean, Street Fighter Alpha 2), or the Sega Virtua Processor (Virtua Racing). Do not lump Super FX in with that unsupported set — it is the mistake that makes people think their working unit is broken. If you need those SA-1 carts, that is a Sanni Cart Reader or Retrode 3 job.

Five Common Pitfalls (and the Fixes)

Hot-swapping and the truncated-file / dead-save combo

The first and worst pitfall is swapping cartridges on a live unit. It produces two failure modes at once: a truncated or garbage ROM (because the read caught the connector mid-change) and, far worse, a corrupted on-cartridge save (because the SRAM was mid-access). Fix: eject the drive and unplug the Retrode between cartridges, or at minimum press RESET and wait for the re-mount before touching anything. This is the pitfall the user guide warns about by name, and it is the one most likely to cost you something you cannot get back.

Filename faith and the co-processor carts

The second pitfall is trusting the generated filename as proof of a good dump. The filename comes from the cartridge header; a header can read cleanly while the ROM body is subtly wrong, and Master System carts frequently produce no title at all. Fix: never trust the name — hash the ROM and check it against a No-Intro DAT. The third pitfall is adjacent: assuming every cartridge will dump. The SA-1, S-DD1, and Virtua Processor carts listed above will not read correctly on a Retrode 2, no matter how clean the contacts. Fix: know your co-processors before you blame the hardware, and route those specific carts to a different reader.

Save write-protection and contact-cleaning myths

The fourth pitfall is turning off sramReadonly and then treating the drive like a normal folder — one careless file operation and a decades-old save is gone. Fix: leave write-protect on (value 1) except for the single deliberate moment you are restoring a save, and back up first. The fifth pitfall is cleaning contacts with the wrong thing: Brasso, toothpaste, and pencil erasers all abrade the gold plating and do long-term harm for short-term shine. Fix: 99% isopropyl alcohol on a cotton swab, nothing more aggressive. A sixth, for completeness: buying a discontinued adapter off a marketplace expecting full save support. The obscure adapters were discontinued because their connectors became unobtainable, and their save support was "pending" even when new. Manage expectations accordingly.

Troubleshooting Table

Reading the symptoms

Most Retrode faults are mechanical, not digital: a bad contact, a half-seated cartridge, a live swap. The table below maps the symptom to the likely cause and the fix in the order you should try them — cleaning and reseating before you ever touch the config file, because it is nearly always the contacts.

The table

When it's the cart, not the Retrode

If one cartridge fails but every other cartridge dumps perfectly, the fault is the cartridge, not the reader — a corroded connector, a dead save battery, or an unsupported co-processor. Conversely, if every cartridge fails, suspect the reader, the cable, or the USB port. This one distinction — is it this cart or all carts — resolves most support questions before they are asked, and it costs nothing but a second known-good cartridge to test.

Advanced Tips: Firmware, DFU, and Flash Carts

Reflashing firmware over DFU

You will rarely need to reflash a Retrode 2 — the firmware is frozen and factory units ship working — but if you want the 0.18d beta 3 fixes (the Game Gear detection fix, chiefly) or you have somehow corrupted the firmware, DFU is how. Enter the bootloader mechanically: hold the HWB button, press and release RESET, then release HWB. The unit now enumerates as an Atmel DFU device (the well-documented 03eb:2ff9 bootloader for the AT90USB646). On Windows, Atmel's FLIP tool does the flashing; on Linux or macOS, dfu-programmer does:

# Enter DFU: hold HWB, tap RESET, release HWB. Then:
sudo dfu-programmer at90usb646 erase
sudo dfu-programmer at90usb646 flash retrode2-0.18c.hex
sudo dfu-programmer at90usb646 reset

Because DFU lives in a separate bootloader region, a failed flash does not brick the unit — you simply re-enter DFU and try again. That is by design and it is why the procedure is safe to attempt.

Batch dumping and No-Intro verification

If you are dumping a shelf rather than a single cartridge, build verification into the workflow from the start rather than bolting it on later. Hash every ROM as you go and keep the hashes alongside the files, then run the collection against a No-Intro DAT in RomVault or clrmamepro. A single ROM's hash looks like this:

$ sha1sum "THE LEGEND OF ZELDA.SFC"
d81c1e64...  THE LEGEND OF ZELDA.SFC
# Compare against the No-Intro DAT entry for the same title.

A matching hash means your dump is bit-identical to the community's known-good reference — the difference between "I have a file" and "I have the file." For a collection of any size this is not optional; it is the entire point of dumping properly rather than downloading.

The Retrode 3 / Sanni OSCR frontier

The forward-looking tip: the Retrode 3's software is a Linux CLI adaptation of Sanni's Open Source Cart Reader, and the plug-in ecosystem is cross-compatible in both directions — a plug-in written for one can generally work on the other. If you are technically inclined and impatient for the Retrode 3, the retrode3-oscr repository and the upstream sanni/cartreader project are where the actual development happens, released under GPLv3 for software and open hardware licences for the boards. It is a real, active, open project, which is more than can be said for most of what "retrode" surfaces in a 2026 search.

Playing and Verifying Your Dumps

Load them in an emulator

A verified ROM plus its .SRM drops straight into an emulator. The path of least resistance is RetroArch with the appropriate libretro core — Snes9x or bsnes for SNES, Genesis Plus GX for Mega Drive — and if you have never set that up, our walkthrough of getting the right RetroArch cores installed covers exactly which core to pick and why. Put the .SRM in the core's save directory next to the ROM and your original save resumes where the cartridge left off, which is a genuinely uncanny thing to see the first time. If you would rather run everything from a dedicated box, the same ROMs feed a RetroPie build without modification.

Real hardware: FPGA and flashcarts

Dumps are not only for emulators. Load a verified ROM onto a flashcart and it runs on the original console, or feed it to an FPGA recreation for cycle-accurate playback without the original silicon. If that is your interest, the MiSTer Multisystem 2 is the current reference FPGA platform, and for N64 specifically the Analogue 3D's firmware story is worth reading before you spend. Dumping your own cartridges is what makes all of this legitimate: the ROM came off hardware you own, verified against a public database, rather than off a stranger's server.

Verify before you trust

The recurring theme, one last time: verify. A dump that boots is not a dump that is correct, and the gap between the two is precisely the errors a checksum catches — a flipped bit from a marginal contact, a truncation from a rushed read. Hash it, match it against No-Intro, and only then file it as done. If you are building a handheld library from these dumps — a Miyoo Mini Plus loadout, say — verified files are what keep a 27,000-file collection from being 27,000 potential heartbreaks. Verification is cheap; re-dumping a cartridge you sold last year is impossible.

The Complete Working Configuration

A full RETRODE.CFG

Here is a complete, commented RETRODE.CFG covering the confirmed keys, ready to drop onto the Retrode's virtual drive root. It ships defaults that are safe for dumping — write-protect on, everything on auto — with the overrides documented inline so you can flip exactly what a stubborn cartridge needs. Again: the exact key set is confirmed from firmware and the surviving guide text, but with the retrode.org doc offline, treat this as an authoritative format reference and confirm behaviour against the official FAQ if a cartridge surprises you.

# ============================================
#  RETRODE.CFG  —  complete working reference
#  Place at the root of the Retrode's drive.
#  Lines beginning with # are comments.
# ============================================

# --- Saves (SRAM) ---
sramReadonly    1        # 1 = protect on-cart saves (recommended)
segaSram16bit   0        # Sega only: 1 = 16-bit word packing
sramExt         srm      # extension used for save files

# --- ROM output ---
snesRomExt      sfc      # SNES / SFC ROM extension
segaRomExt      bin      # Mega Drive / Genesis ROM extension
filenameChksum  0        # 1 = append a checksum to filenames

# --- Detection / mapping ---
forceSystem     auto     # auto | SNES | MD | SMS | GG
forceSize       0        # 0 = auto-detect ROM size
forceMapper     0        # 0 = auto (override at your own risk)
detectionDelay  0        # raise for flaky / intermittent mounts

A repeatable dump-and-verify workflow

And the workflow that ties the whole tutorial together: copy every fresh dump off the unit and hash it in one pass, so verification is never a step you forget. Save this as a shell script and run it after each cartridge:

#!/bin/sh
# dump-and-file.sh — copy a Retrode dump and hash it
SRC="/media/you/RETRODE"
DST="$HOME/roms/snes"
mkdir -p "$DST"
for f in "$SRC"/*.SFC "$SRC"/*.SRM; do
  [ -e "$f" ] || continue
  cp -v "$f" "$DST/"
done
cd "$DST" && sha1sum *.SFC > checksums.sha1
echo "Done. Verify checksums.sha1 against a No-Intro DAT."

Where the authoritative docs live

Finally, the sources worth bookmarking, because the Retrode's documentation is scattered and half of it redirects. The official FAQ is the current front door for supported chips and behaviour; the full original user guide survives as scanned text at the Internet Archive's Retrode guide, which is the primary source for the hot-swap and write-protection warnings quoted above. For the preservation rationale — why any of this matters beyond nostalgia — the University of Maryland's MITH writeup on preserving SNES games makes the institutional case. And for the future, the Retrode 3 page and its open-source repositories are where the next chapter is being written — slowly, contradicting itself about its own CPU, but in the open. Dump your carts. Verify your dumps. And ignore the horoscope; the only thing in retrograde here is the shipping date.