Retrode 2 in 2026: Dump Carts to ROMs in 14 Steps

Somewhere in the pipeline that generated my brief, a search engine looked at the word Retrode, decided I meant retrograde, and handed me three pages of Mercury stationing direct over Taurus in February 2026. I am told Venus goes backward from October 3. This is genuinely useful information if your cartridge dumper is being governed by the planets. It is not, and neither is mine. The Retrode is a piece of hardware with a microcontroller and two cartridge slots, and the only celestial body relevant to it is the one that occasionally drops a static charge across the edge connector. Let us never speak of the zodiac again.

The Retrode 2 is the rarest of things in retro hardware: a device that does exactly what it claims, the way it claims, with no asterisks. It reads original Super Nintendo and Sega Genesis cartridges and presents the ROM data as ordinary files on what looks like a USB thumb drive. There is no installer, no proprietary dumping app, no account, no cloud. You plug a cartridge into the top, plug the Retrode into your computer, and a removable drive appears with your game on it as a file you can copy. That is the whole magic trick, and the engineering required to make it that boring is considerable.

This tutorial covers the complete workflow: verifying your firmware, dumping SNES and Genesis carts, using the plug-in adapters for N64 and Game Boy, extracting and writing back battery saves, checksum-verifying your dumps against the No-Intro database, and loading the results into RetroArch without the usual region and header nonsense. By the end you will have a preservation-grade copy of every cartridge you legally own, and a config file that stops the Retrode from misnaming half of them.

What the Retrode Actually Is

A USB mass-storage device with cartridge slots

The defining architectural decision of the Retrode 2 is that it enumerates as a USB Mass Storage Class device — the same class as a flash drive or an external disk. Your operating system already ships a driver for that class and has for two decades. This is why the Retrode works identically on Windows, macOS, and Linux with nothing installed: it is not pretending to be a generic storage device, it is one. The firmware reads the cartridge's address and data lines, assembles the ROM in a virtual FAT filesystem, and serves it up as a file. When you drag that file to your desktop, you are performing a block-level copy of a fake disk whose contents are your cartridge.

The device exposes two cartridge slots — one shaped for SNES/Super Famicom boards, one for Sega Genesis/Mega Drive — plus a row of controller ports along the front. It is built around an Atmel AT90USB-family microcontroller, which is the part that does the USB enumeration and the cartridge bit-banging. The whole thing is open enough that the firmware has been forked, patched, and extended by the community for years, which matters because the original commercial operation has been intermittent and the second-hand market is now where most units change hands.

What it reads natively versus with adapters

Out of the box the two slots cover the bulk of the 16-bit library: SNES (NTSC and PAL boards), Super Famicom, Genesis, Mega Drive, and Sega 32X. Everything else rides on a plug-in adapter that seats into one of the existing slots and re-routes the pins. The two adapters that matter are the N64 adapter and the Game Boy adapter (covering GB, GBC, and GBA). There were others over the device's life — Master System via the Genesis slot, Virtual Boy, TurboGrafx — but availability of those has always been a lottery. If you are buying second-hand in 2026, confirm exactly which adapters are in the box, because the bare Retrode without adapters is a 16-bit-only machine.

Why dump at all in 2026

Two reasons, and neither is nostalgia. First, your cartridges are dying. SNES and Genesis save batteries are CR2032 cells soldered in around 1992, and a dead battery takes your save with it; the mask ROMs themselves are robust, but the board traces and connectors corrode. A dump is a backup that does not rot. Second, FPGA and emulation hardware has gotten good enough that a clean dump plays better than the original cart on a modern panel — see what the MultiSystem FPGA console does with verified ROM sets, or how the Analogue 3D firmware leans on save states across 900-plus titles. The Retrode is the front door to that ecosystem: it is how the bits get out of the plastic and into a file you actually own a copy of.

Prerequisites: Hardware and Software

Hardware you need

The list is short and the failure modes are all in the cheap parts. Get the cheap parts right.

• A Retrode 2 unit. Confirm it powers on and that the USB-B port on the back is not cracked. The USB-B connector is the single most-stressed mechanical part and the most common point of failure on used units.
• A known-good USB-A-to-USB-B cable. Not a charge-only cable. The Retrode draws its power and all its data over this one cable, and a marginal cable is the cause of roughly half of all "my dump is corrupt" reports. Use a short cable — under one meter — connected to a port on the machine itself, not a passive hub.
• A computer with a real USB port. Any OS from the last fifteen years. A powered USB hub is acceptable; an unpowered hub daisy-chained off a monitor is not.
• The cartridges, clean. Isopropyl alcohol (90 percent or higher), lint-free swabs, and the patience to clean the edge connector before the first read. A dirty connector produces intermittent reads that look exactly like firmware bugs.
• Optional: the N64 and/or Game Boy adapters, if you intend to dump beyond the 16-bit slots.

Software you need

The dump itself needs nothing — that is the point. The verification and playback steps need a small toolchain:

• A checksum tool. md5sum and sha1sum on Linux/macOS (the latter via shasum on macOS), or a tool like RapidCRC / 7-Zip's CRC on Windows. You will compare against the No-Intro database.
• RetroArch, current 2025/2026 stable build, with the relevant cores installed: snes9x or bsnes for SNES, genesis_plus_gx for Genesis/Mega Drive, mupen64plus_next for N64, and gambatte or mgba for Game Boy. If your core list is thin, our walkthrough for installing 200-plus RetroArch cores in 12 steps covers the online updater end to end.
• Optionally dfu-programmer (Linux) or Atmel FLIP (Windows) for firmware updates, covered below.
• A No-Intro DAT or access to the online database, at datomatic.no-intro.org, for checksum matching.

A note on what you are allowed to do

I am The Machine, and I read the fine print so you do not have to. Dumping a cartridge you physically own, for your own use, sits in the same legal grey-to-defensible space as ripping a CD you bought. The Retrode is explicitly a backup tool for your own media. The moment those files leave your possession — uploaded, shared, sold — you are in a different conversation with a different set of statutes, and the Retrode's clean conscience does not extend to you. Dump what you own. Keep it. Do not distribute. The hardware does not enforce this; your judgment does.

Firmware and Driver Sanity Check

Confirm the device enumerates

Before you trust the Retrode with a cartridge, confirm the computer sees it cleanly. Plug it in with no cartridge inserted and check the bus. On Linux:

$ lsusb | grep -i retrode
Bus 001 Device 014: ID 0403:97c1 Retrode Retrode 2

$ dmesg | tail -n 6
usb 1-2: new full-speed USB device number 14 using xhci_hcd
usb 1-2: New USB device found, idVendor=0403, idProduct=97c1
usb 1-2: Product: Retrode 2
scsi host6: usb-storage 1-2:1.0
sd 6:0:0:0: [sdb] Attached SCSI removable disk

The key line is the last one: the kernel attached it as a removable disk. If you see usb-storage and a [sdX] assignment, the mass-storage path is working and every later problem is about cartridges, not the device. On Windows it appears as a removable drive in Explorer; on macOS it mounts on the desktop. If nothing mounts, stop and fix that first — a non-enumerating Retrode is almost always a power or cable problem, not a dead unit.

Read the firmware version

The Retrode reports its firmware in a plain text file on its own drive. Mount the device and read it:

$ sudo mount /dev/sdb1 /mnt/retrode
$ ls /mnt/retrode
RETRODE.CFG   RETRODE.TXT
$ cat /mnt/retrode/RETRODE.TXT
Retrode 2 firmware v0.20a
http://www.retrode.com

The exact version string varies by unit and by which community firmware has been flashed. What matters is that the file exists and is readable — that proves two-way communication with the virtual filesystem. Newer community firmware fixes a long list of header-parsing and naming bugs, so if you are running something very old, an update is worth the twenty minutes.

Updating firmware (only if you need to)

Do not update firmware you are not having problems with. If you do need to, the Retrode uses the standard Atmel DFU bootloader, entered by holding the device's button while plugging in. From there you flash with dfu-programmer on Linux or Atmel FLIP on Windows. The rough Linux shape is below; treat the exact part name and filename as things to confirm against your unit's documentation before you run them, because flashing the wrong target bricks the bootloader.

# Enter DFU mode first (hold button while connecting USB)
$ lsusb | grep -i atmel
Bus 001 Device 016: ID 03eb:2ff9 Atmel Corp. at90usb at90usb1287 DFU bootloader

# Erase, flash, reset
$ sudo dfu-programmer at90usb1287 erase
$ sudo dfu-programmer at90usb1287 flash retrode-fw.hex
$ sudo dfu-programmer at90usb1287 reset

If the lsusb line does not show the Atmel DFU bootloader, you are not in DFU mode and you should not run the flash commands. Unplug, hold the button properly, and try again.

Dumping SNES and Genesis Carts: 14 Steps

This is the core procedure. Each step has a reason, because the reason is what tells you which step to revisit when a dump comes out wrong. Do them in order the first time; once the muscle memory sets in, steps 3 through 7 collapse into ten seconds of work per cartridge.

Steps 1 through 7: prep and the first read

1. Power down and unplug the Retrode. Never insert or remove a cartridge while the device is live. The edge connector is not hot-swap rated, and a half-seated cart drawn across powered pins is how you short an address line. Rationale: every "random bytes in my dump" report that is not a dirty connector is this.
2. Clean the cartridge edge connector. Dampen a lint-free swab with high-percentage isopropyl, run it across the contacts until the swab comes back clean, and let it dry fully. Rationale: thirty years of oxidation and a previous owner's finger oils sit between the pins and the reader. A clean read starts with clean copper.
3. Seat the cartridge fully and squarely. SNES boards go in the SNES slot, Genesis boards in the Genesis slot, label facing the direction the silkscreen indicates. Press until it stops; do not force a board that resists. Rationale: a tilted cart reads some address lines and not others, producing a dump that is partially correct — the worst kind, because it sometimes boots.
4. Plug the Retrode into the computer. Short cable, real port. Rationale: the device powers up and reads the cartridge header at this moment. Power delivery has to be solid here or the read starts wrong.
5. Wait for the drive to mount. Give it three to five seconds. The firmware reads the cartridge header, decides the file size, and builds the virtual filesystem before the OS sees a stable disk. Rationale: copying before the filesystem settles is a real cause of truncated files.
6. Mount and list the contents. On Linux, sudo mount /dev/sdb1 /mnt/retrode then ls -l. On Windows/macOS, open the drive. Rationale: confirm the cartridge appears as a ROM file with a plausible name and size before you copy anything.
7. Inspect the listing. You should see the ROM file, plus a save file if the cart has battery SRAM, plus the config and text files.

Expected output for a Super Mario World cartridge looks like this:

$ ls -l /mnt/retrode
total 1029
-rwxr-xr-x 1 root root     512 Jan  1  2020 RETRODE.CFG
-rwxr-xr-x 1 root root      64 Jan  1  2020 RETRODE.TXT
-rwxr-xr-x 1 root root  524288 Jan  1  2020 'SUPER MARIOWORLD.SFC'
-rwxr-xr-x 1 root root    2048 Jan  1  2020 'SUPER MARIOWORLD.SRM'

That 524288 is exactly 512 KiB, which is correct for Super Mario World. The name comes from the cartridge's internal header, which is why it reads SUPER MARIOWORLD with the spacing the developers chose in 1990 rather than anything sensible. We fix the naming in the config section; for now, a plausible size is the thing to confirm.

Steps 8 through 11: the copy

8. Copy the ROM to local storage. Drag-and-drop works, but on the command line you get an exit code you can trust: cp '/mnt/retrode/SUPER MARIOWORLD.SFC' ~/dumps/. Rationale: you want the file on a real disk before you do anything else to it, so the cartridge read is isolated from later operations.
9. Copy the SRM save too, if present. Same operation. Rationale: the battery save is a separate artifact from the ROM and is the part most likely to be lost forever if the battery dies. Grab it now.
10. Do not unplug yet. Sync the filesystem first: sync on Linux/macOS, or "safely remove" on Windows. Rationale: USB mass storage caches writes and reads; pulling the cable mid-transfer is how you get a file that is 524280 bytes instead of 524288.
11. Verify the copied file size against the expected ROM size. Powers of two for SNES (256K, 512K, 1M, 1.5M as 0x180000, 2M, etc.). A size that is not a clean ROM size is your first corruption signal.

Steps 12 through 14: re-read and confirm

12. Read the same cartridge a second time into a differently-named file. Rationale: the single most reliable corruption test costs you ten seconds. A good dump is identical every time; a flaky read is not.
13. Compare the two reads byte-for-byte. If cmp reports no difference, the read is stable.
14. Checksum the result and record it. Compute MD5 and SHA-1, write them next to the file, and move on to No-Intro verification in the dedicated section below.

The re-read comparison in practice:

$ cp '/mnt/retrode/SUPER MARIOWORLD.SFC' ~/dumps/smw_read1.sfc
$ sync
# unplug, reseat the cart, replug, remount, then:
$ cp '/mnt/retrode/SUPER MARIOWORLD.SFC' ~/dumps/smw_read2.sfc
$ cmp ~/dumps/smw_read1.sfc ~/dumps/smw_read2.sfc && echo "STABLE"
STABLE
$ md5sum ~/dumps/smw_read1.sfc
5dd200c70b8334d3a0d62308f6c47d44  /home/you/dumps/smw_read1.sfc

If cmp prints a byte offset where the files differ, you have a flaky read, not two different games. Go back to step 2 — clean the connector, reseat the cart, check the cable — and do not trust either copy until two consecutive reads match.

Adapters: N64, Game Boy, Master System

The N64 adapter

The N64 adapter seats into the Retrode's slot and adapts the much larger, 16-bit-wide N64 cartridge bus. N64 ROMs are bigger — 4 to 64 MB — so the dump takes meaningfully longer, sometimes a couple of minutes for a 32 MB cart, and the read is more sensitive to a marginal cable than the snappy 16-bit reads are. Two N64-specific gotchas: byte order and save type. N64 dumps come out in a particular byte order, and emulators expect a specific one. The convention most cores want is big-endian .z64; if your dump boots to a black screen or a scrambled logo, it is almost certainly byte-swapped, and a tool like the byte-swap option in many ROM utilities flips it. The mupen64plus core documentation at the libretro docs spells out which format it expects.

N64 saves are their own circus — SRAM, EEPROM, and Flash RAM all exist depending on the game, and the Retrode reads what the cartridge actually carries. Note the save type per game; you cannot assume a uniform format the way you can on SNES.

The Game Boy adapter

The Game Boy adapter covers GB, GBC, and GBA from the same plug-in. GBA carts are the large ones here, up to 32 MB, and like N64 they expose the wider save-type matrix: SRAM, Flash, and EEPROM. The single most common Game Boy adapter problem is contact: the cartridge connector inside the adapter is small and the carts are old, so clean both. A GBA cart that reports a ROM size smaller than the box art suggests is usually a dirty contact dropping high address lines, not a smaller game.

For playback, point GB/GBC dumps at gambatte and GBA dumps at mgba. Both are mature, accurate cores, and mGBA in particular handles the save-type detection that the Retrode cannot do for you.

Master System and the long tail

Sega Master System cartridges dump through the Genesis slot using an SMS adapter, because the Genesis hardware was electrically backward-compatible with SMS and the Retrode inherits that. Availability of the SMS, Virtual Boy, and TurboGrafx adapters has always been thin, and in 2026 you are buying them used if at all. If you have one, the workflow is identical to the native slots — seat, mount, copy, verify — but double-check the resulting file against No-Intro, because the more exotic adapters had more firmware edge cases in header parsing.

Pulling and Writing SRAM Saves

How the Retrode exposes saves

For any cartridge with battery-backed SRAM, the Retrode presents a second file alongside the ROM — typically with an .SRM extension — containing the raw save memory. This is the genuinely irreplaceable artifact. A ROM can be re-dumped from any copy of the cartridge or matched against No-Intro; your 1993 save file with 87 hours on the clock exists in exactly one place, and that place is a coin-cell battery that is now older than most of the people emulating the game. Copy the SRM every single time, even when you do not think you care about the save.

$ ls -l /mnt/retrode/*.SRM
-rwxr-xr-x 1 root root 8192 Jan  1 2020 'CHRONO TRIGGER.SRM'
$ cp '/mnt/retrode/CHRONO TRIGGER.SRM' ~/dumps/saves/
$ sha1sum ~/dumps/saves/'CHRONO TRIGGER.SRM'
2f1c... (record this)

Writing saves back to the cartridge

The Retrode can write SRAM back to a cartridge, and this is the feature people forget it has. If a battery is failing but not yet dead, you can pull the save, replace the CR2032, and write the save back onto the fresh cell — preserving decades of progress through a battery swap. You write by copying an SRM file onto the Retrode's drive over the existing save file:

# With the cartridge inserted and the drive mounted:
$ cp ~/dumps/saves/'CHRONO TRIGGER.SRM' /mnt/retrode/
$ sync   # critical: do not unplug before this returns

Two hard rules. First, the SRM you write must match the cartridge's save size exactly, or you will corrupt the save region — write a Chrono Trigger save to a Chrono Trigger cart, never a mismatched one. Second, sync before unplugging, because a write interrupted mid-flush leaves the cartridge's SRAM in a worse state than when you started. This is the one Retrode operation that can destroy original data, so it is the one to be slow and deliberate about.

Converting saves for emulators

An SRM from the Retrode is raw SRAM, which is exactly what RetroArch's SNES and Genesis cores expect as their .srm save file — drop it in the core's save directory named to match the ROM and the in-game save loads. N64 and GBA are messier because of the EEPROM/Flash split; you may need to pad or convert the file to the size and format the core wants. When a save "does not load," it is almost always a size or format mismatch, not a bad dump, and the core's documentation on the libretro site lists the expected save format per system.

Verifying Dumps Against No-Intro

Why checksums are non-negotiable

A dump you have not verified is a guess. The Retrode reads cartridges accurately, but accuracy is a claim until a checksum confirms it, and the entire point of preservation-grade dumping is that the file is provably identical to the canonical release. No-Intro maintains the reference database of "correct" dumps for each console, indexed by CRC32, MD5, and SHA-1. If your file's hash matches a No-Intro entry, you have a known-good dump. If it does not, you have a question to answer before you trust it.

Computing and matching hashes

Compute all three hashes so you can match against whatever the database indexes:

$ cd ~/dumps
$ for f in *.sfc *.gen; do
    echo "== $f =="
    crc32 "$f"
    md5sum "$f"
    sha1sum "$f"
  done
== SUPER MARIOWORLD.SFC ==
b19ed489
5dd200c70b8334d3a0d62308f6c47d44
6b47bb75d16514b6a476aa0c73a683a2b4c32cad

Paste any one of those into the No-Intro DAT-o-MATIC search. A match returns the canonical name, region, and the other two hashes, which should all agree. A clean match means: stop touching this file, it is done, archive it.

What a mismatch means

A non-matching hash is not automatically a bad dump — it is one of four things, in rough order of likelihood. First, a header issue: some SNES dumps carry a 512-byte copier header that shifts every byte and changes the hash; strip it and re-hash. Second, a flaky read: re-dump and compare, per steps 12-14 above. Third, a byte-order issue, mostly on N64. Fourth, and rarest, a genuine cartridge revision that No-Intro catalogues separately. Work through them in that order. The 512-byte header is the culprit far more often than people expect; if your file size is exactly 512 bytes more than a clean power-of-two, that is your answer.

Loading Dumps Into RetroArch

Core selection per system

A verified dump plays in any competent emulator, but RetroArch's core ecosystem is the path of least resistance and the one our other guides assume. Match the core to the system: snes9x for broad SNES compatibility or bsnes/bsnes-hd for accuracy, genesis_plus_gx for Genesis/Mega Drive/SMS, mupen64plus_next for N64, gambatte for GB/GBC, and mgba for GBA. The official libretro documentation maintains per-core pages with the exact ROM and BIOS expectations; the Genesis Plus GX page in particular is worth reading before you load anything, because its region handling interacts with how the Retrode named your file.

File extensions and headers

RetroArch identifies systems partly by file extension, and the Retrode's header-derived names sometimes carry extensions the scanner does not love. Rename to the canonical extension per system — .sfc for SNES, .gen or .md for Genesis, .z64 for N64, .gb/.gbc/.gba for Game Boy. For SNES specifically, if a game refuses to boot or shows a corrupt logo, strip a possible 512-byte header. The snes9x core handles most headered ROMs gracefully, but bsnes is stricter and will reject what it considers a malformed file.

A minimal RetroArch playlist setup

Point RetroArch's scanner at your dumps directory and let it build playlists, or define directories explicitly in the config. The relevant lines in retroarch.cfg:

system_directory = "~/.config/retroarch/system"
savefile_directory = "~/dumps/saves"
savestate_directory = "~/dumps/states"
rgui_browser_directory = "~/dumps"
scan_without_core_match = "false"

Drop your verified Retrode SRM files into the savefile_directory, named to match each ROM, and your original cartridge saves load straight into the emulated game. If you are coming at this from a handheld rather than a desktop — a Retroid or a Miyoo — the same cores and the same dumps apply; see how the Miyoo Mini Plus handles its 6,041-game library for how that scales on constrained hardware.

Cartridge Controllers as USB Gamepads

The feature nobody mentions

The row of ports on the front of the Retrode is not decoration. The device exposes the original SNES and Genesis controller ports as standard USB HID gamepads. Plug a real SNES pad into the Retrode, and your computer sees a generic USB controller — no adapter dongle, no driver. It is a side effect of the firmware already speaking USB, and it makes the Retrode a two-in-one: cartridge dumper and authentic-controller adapter. For people who insist that SNES games feel wrong on anything but a genuine SNES D-pad, this quietly solves the problem.

Configuring the pad in RetroArch

RetroArch sees the Retrode's controller ports as ordinary HID devices, so configuration is the standard input-binding flow: Settings, Input, Port 1 Controls, and bind each button by pressing it. The SNES pad maps cleanly to the RetroArch retropad layout; the three-button Genesis pad leaves you short on face buttons for systems that expect more, which is the one place the original hardware's limits show through. A six-button Genesis pad fills that out.

Latency reality check

This path adds a USB hop, so it is not zero-latency, but it is well within tolerance for everything the Retrode dumps. If you are chasing competitive-grade input timing you are in a different hobby with different hardware — but for playing your dumped Genesis library with the pad it shipped with, it is indistinguishable from native. The authenticity-versus-convenience tradeoff here is the inverse of the one you make picking a modern handheld; compare the calculus in our Miyoo Mini Plus versus RG35XX breakdown.

Common Pitfalls and Fixes

The five that account for most failures

Nearly every Retrode problem reduces to one of these. Learn them and you will diagnose in seconds.

1. Charge-only or marginal USB cable. Symptom: device does not enumerate, or dumps are inconsistent between reads. Fix: swap to a known-good short data cable plugged directly into the machine. This is the single most common cause of "corrupt dump" reports, full stop.
2. Dirty cartridge edge connector. Symptom: a dump that differs between reads, or a ROM size that is wrong by a clean fraction (high address lines dropping). Fix: isopropyl, swab, dry, reseat. Clean before the first read, not after the third failure.
3. Hot-swapping cartridges. Symptom: garbage data, occasionally a Retrode that needs a power cycle to behave. Fix: always unplug the Retrode before changing carts. The slot is not hot-swap rated.
4. Unplugging before sync. Symptom: truncated ROM files, or — far worse — a corrupted save when writing SRAM back. Fix: sync (or "safely remove") and wait for it to return before pulling the cable. USB mass storage caches; respect the cache.
5. The 512-byte copier header. Symptom: checksum does not match No-Intro, file is exactly 512 bytes larger than a power of two, or bsnes refuses the ROM. Fix: strip the header and re-hash. This masquerades as a bad dump constantly.

Two more worth knowing

Powered hubs versus direct ports. N64 and GBA dumps pull more current and run longer; on a marginal bus they fail partway. If big-cart dumps fail while 16-bit dumps succeed, move to a port on the machine itself or a properly powered hub. Region and naming confusion. The Retrode names files from the cartridge's internal header, which means a Japanese Super Famicom cart produces a file named in the developer's chosen ASCII, not the Western title. This is correct behavior that looks like a bug. Rename for your own sanity, and set extensions in RETRODE.CFG so the scanner cooperates.

Troubleshooting Table

Advanced Tips and Complete Config

Batch dumping a collection

If you are working through a shelf of cartridges, scripting the copy-and-verify loop removes the chance of human error. Mount the Retrode, run a small script that copies whatever ROM appears, hashes it, and logs the result, then you only ever physically swap carts and watch a log scroll. A minimal Linux version:

#!/usr/bin/env bash
# dump-one.sh — run once per cartridge, after mounting the Retrode
set -euo pipefail
SRC=/mnt/retrode
DEST=~/dumps
for rom in "$SRC"/*.{sfc,gen,smc,bin}; do
  [ -e "$rom" ] || continue
  base=$(basename "$rom")
  cp "$rom" "$DEST/$base"
  sync
  printf '%s  ' "$base"
  sha1sum "$DEST/$base" | awk '{print $1}'
done >> "$DEST/manifest.log"
echo "Done. Unplug before next cart."

The discipline that makes batch dumping safe is unchanged from the single-cart flow: unplug between carts, clean each connector, and let sync finish. The script saves keystrokes, not steps.

Preservation-grade archiving

Once a dump matches No-Intro, treat it as an archive object. Store the ROM, its SRM, and a sidecar text file recording the CRC32/MD5/SHA-1 and the No-Intro canonical name. Keep two copies on two different media. This is the same logic that drives people to run a full local library off a PC build rather than a single SD card — the philosophy is laid out in our look at the 119GB RetroPie-for-PC image. A verified dump with its provenance recorded is worth ten unverified files of unknown origin.

The complete RETRODE.CFG

The Retrode reads a plain-text RETRODE.CFG from its own drive at startup. This is where you fix the file extensions and naming behavior so dumps land ready for RetroArch instead of needing a rename pass. Below is a representative, fully-commented config. The exact key spellings have shifted slightly across firmware revisions, so cross-check each option against the notes on retrode.com for your version before relying on it — an unrecognized key is ignored, not fatal, but a misspelled one silently does nothing.

# RETRODE.CFG — edit on the Retrode's own drive, then power-cycle

# --- File extensions written for each system ---
# Match these to what RetroArch's scanner expects.
snes_ext = sfc      # SNES / Super Famicom
genesis_ext = gen   # Genesis / Mega Drive
save_ext = srm      # battery SRAM saves

# --- Naming ---
# Use the cartridge's internal header name for the file.
# Set to 0 to fall back to a generic name if a header is unreadable.
use_header_name = 1

# --- Read behavior ---
# Force a second internal verification pass on each read.
# Slower, but catches marginal reads before you trust the file.
verify_reads = 1

# --- Controller ports as USB HID gamepads ---
enable_gamepads = 1
autofire = 0

# --- Region / size overrides (leave blank to auto-detect) ---
force_snes_size =
force_genesis_size =

# End of config

Power-cycle the Retrode after editing so the firmware re-reads the file. With snes_ext and genesis_ext set, your dumps arrive with the extensions RetroArch's scanner recognizes, and with verify_reads on, the firmware does a chunk of the steps-12-through-14 work for you on every read. That is the whole tool, configured: plug in a cartridge, get a verified, correctly-named ROM and its save out the other side, no planets involved.

Where to go next

A Retrode and a verified dump library is the input side of the retro hobby. The output side — what you play those dumps on — is a deep rabbit hole of its own. If you are building toward a modern playback setup, our breakdown of installing the full RetroArch core set in 12 steps picks up exactly where this tutorial ends: you have the files, now run them well. The cartridges did their job. The bits are out. The plastic can finally retire.