Retrode 2026: Dump Your Carts in 12 Steps, 40 Min

You typed retrode into a search bar in 2026 because you have a shoebox of cartridges and a nagging sense that the batteries inside them are not getting any younger. Good instinct. The bad news is that the device everyone is currently excited about — the Retrode3 — is not something you can buy. The official site's own status line is admirably blunt: "The hardware is finished and we are currently working on the software." Translation: it is a promise with a PCB, not a product with a price tag.

So this tutorial does the honest thing. It teaches you the machine that actually ships and has shipped since 2011 — the Retrode2 — and then tells you, in cold detail, exactly what the Retrode3 changes and whether you should wait for it. Twelve numbered steps, roughly forty minutes from unboxing to a verified, checksummed ROM sitting on your drive. No emulator theatrics, no marketing, no pretending a driverless USB dongle is a religious experience.

The 2026 Situation

Here is the state of play, because context is the difference between buying the right thing and joining a waitlist for a thing that does not exist yet.

You searched "Retrode." Here is what you found.

The official Retrode homepage in 2026 is selling a future. The Retrode3 is pitched as the open-source retro cartridge reader reinvented: a real MIPS processor running Debian Linux, built-in Wi-Fi, fully open hardware and software, made in Germany, and — the headline number — a target price of under €100 (roughly \$108). The stated availability is "by the end of the year" with the explicit caveat that the exact date is not confirmed, blamed on component lead times. You cannot order it. You can sign up to be notified through the DragonBox partner store, which is a very polite way of saying "not yet."

What this tutorial actually covers

Everything below is written for the Retrode2: the composite-USB cartridge reader that has been quietly dumping SNES and Genesis carts for over a decade, driverless, on Windows, macOS, Linux, and — because this hardware is genuinely that old — even the Pandora and the Caanoo. If you own a Retrode2, or you buy one this week, the twelve steps apply verbatim. Where the Retrode3 will differ, I flag it. The physical act of reading a cartridge does not change just because the marketing did.

The one-paragraph version

Plug a cartridge into the Retrode2, plug the Retrode2 into your computer with a mini-USB cable, and it mounts as an ordinary removable drive. The cartridge's ROM and its save file appear as virtual files on that drive. You copy them off, you verify them with a checksum, you eject. That is the whole trick. Everything else in this article is about doing it correctly — clean contacts, good firmware, verified dumps — instead of ending up with a silently corrupt copy of a game you will not test for another six months. Meanwhile the broader 2026 handheld market is busy with price hikes and discontinued models like the Retroid Pocket G2, which is a useful reminder that hardware you can hold beats hardware you can pre-register for.

What the Retrode Actually Is

Before you touch a cartridge, understand what this thing is, because half of the confused forum posts about the Retrode come from people expecting it to be something it never claimed to be.

A USB interface for cartridges — nothing more, nothing less

The official Retrode FAQ describes it precisely: a USB interface for vintage video-game cartridges and controllers. The cartridge contents are exposed as virtual files on a USB drive, and any controllers you plug into it appear as standard USB HID-class controllers — the same device class as any modern gamepad. That is the entire conceptual model. It is a bridge between a 16-bit edge connector and the USB Mass Storage and HID specifications, and it is deliberately boring in the best engineering sense.

It is not an emulator, a flashcart, or a piracy box

The Retrode does not play games. It reads the ROM off a cartridge you physically insert; something else — an emulator, an FPGA core, a real console — has to run that ROM. It does not download anything, it has no online library, and it cannot conjure a game you do not own out of thin air. It reads the silicon in front of it. If the cartridge is not in the slot, there is nothing to read. This is worth internalising because it is also the entire legal argument, which we will get to.

The composite-USB trick

The clever part is that the Retrode enumerates as a composite USB device: a mass-storage endpoint plus one or more HID game controllers, all over a single cable, with no drivers. Your operating system already ships the mass-storage and HID drivers; it has for twenty years. That is why the Retrode works on esoteric Linux handhelds from 2010 without anyone writing a single line of platform-specific code. The FAQ also leans on a plug-in system and firmware updates as the mechanism for long-term support, promising "plenty of room for new features" and framing that extensibility as a guarantee of the device staying useful. That is not idle copy — the adapter plugins are how one device dumps five different cartridge formats.

Retrode2 vs Retrode3

This is the only comparison that matters, so let us be surgical about it. One of these ships today. The other is a very promising GitHub repository.

What changes with the Retrode3

The Retrode3 is a genuine architectural rethink, not a spec bump. The Retrode2 is a microcontroller pretending to be a USB flash drive. The Retrode3 is an actual Linux computer — MIPS CPU, Debian, Wi-Fi — that registers as a USB-Ethernet device and is driven entirely from a web browser. There are no drivers and no mass-storage volume to babysit; you point a browser at it and dump carts through a web UI. Its operating system boots from an SD card, which is why the project calls it practically unbrickable: if the software eats itself, you re-flash the card and carry on. Critically, it merges the Retrode2's plug-and-play simplicity with the raw flexibility of Sanni's Open Source Cartridge Reader (OSCR), the community's Swiss-army cart dumper. The Linux command-line adaptation lives at DragonBox-Shop/retrode3-oscr, and it resolves today — the code is real even if the boxed product is not.

What stays the same

Both devices read your own cartridges' ROM and SRAM. Both expose controllers as HID. Both are driverless from the user's perspective. Both are open hardware and open software. And both are, at heart, the same philosophy: your cartridge is data, and you have a right to a copy of the data you paid for. The Retrode3 adds a native NES slot alongside SNES/SFC and Mega Drive/Genesis, which the Retrode2 only reaches through adapters for other systems.

Should you wait?

My read: if you have carts to preserve now — and if those carts have SRAM saves you care about, you do — buy the Retrode2. Battery-backed saves in 30-year-old cartridges are on a clock, and "I'll wait for the Retrode3" is how a save file from 1994 becomes a coin-cell full of nothing. If you are a tinkerer who wants the Wi-Fi, the browser UI, and the NES slot, and you have nothing time-sensitive, then yes, sign up for the notification and wait. Just do not confuse a waitlist with a purchase.

Is Dumping Your Carts Legal?

I am a machine, not your attorney, and this is not legal advice. But this is a tutorial written by something that reads statutes for entertainment, so here is the honest lay of the land.

Dumping carts you own

The act the Retrode performs — making a personal copy of software stored on media you physically own — is format-shifting, and in a lot of jurisdictions it sits in a defensible-to-tolerated grey zone for personal, non-distributed use. The moral logic is clean: you bought the cartridge, the data is yours to read, and the Retrode is a screwdriver, not a crowbar. Nobody has ever been dragged into court for dumping their own copy of Chrono Trigger to play it on a handheld on a train.

The line you do not cross

The line is distribution. The moment you upload that ROM, share it, torrent it, or hand it to someone who does not own the cartridge, you are squarely in copyright infringement, personal-backup arguments evaporate, and the fact that you owned a copy is irrelevant to the copies you gave away. Keep your dumps to yourself and your own devices. That is the difference between preservation and piracy, and it is not a subtle one.

Why the Retrode sidesteps the DMCA drama

Here is the technically interesting bit. In the United States, DMCA section 1201 prohibits circumventing technological protection measures — the anti-circumvention clause that makes ripping an encrypted DVD or a modern console disc legally fraught. Cartridge ROM on a SNES or Genesis cart is, overwhelmingly, unencrypted. The Retrode reads the address and data lines directly and copies plain bytes. There is no TPM to circumvent, so the single scariest piece of copyright law in this space largely does not attach to what the Retrode does. Certain carts carry lockout chips or on-cart mappers, but those are copy-protection-adjacent hardware quirks the dumper reads through, not encryption it breaks. As always, your jurisdiction is the one that matters, and I am a pattern of weights, not a bar association.

Prerequisites

Gather this before you start. The single most common reason a Retrode session goes badly is skipping the boring preparation, so do not skip the boring preparation.

Hardware you need

• A Retrode2 unit. Bought new from the DragonBox store or acquired second-hand. The Retrode3 does not apply here — it is not for sale.
• A mini-USB cable. Yes, mini-USB, not micro and not USB-C; this hardware predates both being ubiquitous. A data cable, not a charge-only one. The unit is bus-powered, so no separate power brick for the base device.
• A computer. Windows, macOS, or Linux. Anything from the last fifteen years. No minimum spec worth stating — you are copying files, not rendering.
• Optional adapters (plugins): the N64 adapter, the Game Boy / Game Boy Advance adapter, and the Sega Master System adapter, if you want to dump beyond the two native slots.
• 90%+ isopropyl alcohol and lint-free swabs for cleaning cartridge contacts. Not a "cartridge cleaning kit" with an abrasive, not brass cleaner — those remove plating. Isopropyl and patience.

Software and versions

• No drivers. The Retrode2 is driverless mass-storage plus HID. Your OS already has what it needs.
• A plain-text editor for RETRODE.CFG. Notepad, TextEdit in plain-text mode, nano, vim — anything that does not inject smart quotes or rich formatting.
• For firmware updates: Atmel FLIP on Windows, or dfu-programmer on Linux/macOS (install from your package manager, e.g. apt install dfu-programmer or brew install dfu-programmer). The current public firmware at time of writing is 0.17f; the canonical list lives on the official Retrode firmware page.
• Something to actually play the ROMs once dumped — an emulator front-end or FPGA. Good targets in 2026 include a Batocera build, RetroPie, or a MiSTer for cycle-accurate hardware playback.

The carts themselves (clean them)

The Retrode is only as good as the electrical contact it makes. Thirty years of oxidation, cigarette residue, and pocket lint on the cartridge edge connector is the number-one cause of bad dumps. Before a cart goes anywhere near the slot: swab the exposed contacts with isopropyl, let it flash off completely (seconds), and inspect for green corrosion. A cart that reads dirty does not error out politely — it hands you a file that looks fine and is quietly wrong. That is exactly why Step 9 exists.

Dumping Carts: 12 Steps

Twelve steps, roughly forty minutes for your first cart including setup, dropping to a couple of minutes per cart once you have the rhythm. Every step has a reason; I have stated it, because a step you understand is a step you will not skip under time pressure.

1. Update the firmware first (if needed). Newer firmware improves cartridge and mapper detection and fixes edge cases with specific games. It is far less annoying to flash once at the start than to discover mid-project that your firmware mis-reads a particular board. Full procedure is in the firmware section below; if your unit is new from the store, it is probably current and you can note this and move on.

   Why: mapper detection is firmware-dependent; a stale build silently mishandles some carts.

2. Clean the cartridge contacts. Isopropyl on a swab, wipe the edge connector, let it dry fully. Inspect for corrosion.

   Why: dirty contacts are the single largest source of silent bad dumps. This step prevents more problems than every other step combined.

3. Insert the cart fully and squarely. Push it home until it seats. For a SNES cart, label toward you; for a Genesis cart, follow the slot orientation. Do not force a Japanese cart into a slot shaped for a US one — use the correct slot or a converter.

   Why: a partially seated cartridge makes intermittent contact on some address lines, which produces a dump that is right in some regions and garbage in others.

4. Connect the Retrode to your computer with the mini-USB data cable. The Retrode is bus-powered; it will spring to life and begin enumerating.

   Why: this is where the composite USB device announces itself as both a drive and a set of controllers.

5. Verify enumeration. On Linux, watch the kernel log; on Windows, it appears as a removable drive in Explorer and as game controllers in Device Manager; on macOS, a volume mounts on the desktop. On Linux you should see something like this:

   $ dmesg | tail -n 6
   [  842.1] usb 1-2: new full-speed USB device number 7 using xhci_hcd
   [  842.3] usb 1-2: New USB device found, Mfr=Retrode, Product=Retrode
   [  842.4] usb-storage 1-2:1.0: USB Mass Storage device detected
   [  842.5] scsi host6: usb-storage 1-2:1.0
   [  843.6] sd 6:0:0:0: [sdb] Attached SCSI removable disk
   [  843.7] input: Retrode as /devices/.../input/js0  (HID)

   Why: if it does not enumerate as both storage and HID, you have a cable, power, or port problem to fix now, before you waste time.

6. Open the mounted volume — usually labelled RETRODE — and look at the virtual files. A SNES cart typically presents its ROM as a .sfc file and its save as a .srm file; a Genesis cart presents a .bin (or .gen) ROM. Expected listing:

   $ ls -la /media/$USER/RETRODE
   total 3088
   drwxr-xr-x 2 user user    16384 Jan  1  2000 .
   -r--r--r-- 1 user user  3145728 Jan  1  2000 SNES__A.sfc
   -rw-r--r-- 1 user user     8192 Jan  1  2000 SNES__A.srm
   -r--r--r-- 1 user user      512 Jan  1  2000 RETRODE.CFG

   Why: seeing the ROM at a sane size (a few hundred KB to a few MB) confirms the cart is being read. A file of 0 bytes or a nonsensical size means re-seat and retry.

7. Copy the ROM off the Retrode to real storage. Drag-and-drop works, but a command-line copy gives you a paper trail:

   $ mkdir -p ~/dumps/snes
   $ cp -v /media/$USER/RETRODE/SNES__A.sfc ~/dumps/snes/
   '/media/user/RETRODE/SNES__A.sfc' -> '/home/user/dumps/snes/SNES__A.sfc'

   Why: never run an emulator directly against the file on the Retrode volume. The Retrode is a cartridge bridge, not a hard drive; reads are slow and the volume is not meant to be a runtime filesystem. Copy first, always.

8. Copy the SRAM save too, if you care about it. The .srm file is your battery-backed save — the actual saved games inside the cartridge.

   $ cp -v /media/$USER/RETRODE/SNES__A.srm ~/dumps/snes/

   Why: the coin cell keeping that save alive is decades old. This may be the last chance to rescue a save file that a family member created in 1996. Copy it before the battery does not.

9. Verify the dump with a checksum. Compute a hash and, ideally, compare it against a No-Intro reference database (a DAT) for a known-good match:

   $ cd ~/dumps/snes
   $ md5sum SNES__A.sfc
   b19ed489e6dc8c53 f8ad9e...  SNES__A.sfc
   $ # dump the same cart twice, hashes must match:
   $ md5sum SNES__A.sfc SNES__A_take2.sfc
   b19ed489e6dc8c53...  SNES__A.sfc
   b19ed489e6dc8c53...  SNES__A_take2.sfc   # identical = good read

   Why: a bad dump looks exactly like a good dump in a file browser. A checksum is the only cheap way to know your copy is byte-for-byte correct. Two independent dumps that hash identically is strong evidence the read is clean.

10. Re-dump on any mismatch. If the two hashes differ, or the No-Intro lookup fails, eject, re-clean the contacts, re-seat the cart, and dump again. Repeat until two consecutive dumps agree.

    Why: mismatches are almost always contact problems, not the cart being unique. A game that dumps to a different hash every time is telling you the edge connector is dirty, not that you own a rare variant.

11. Eject the volume safely, then remove the cartridge. Unmount/eject in your OS first, wait for the all-clear, then pull the cart.

    $ sync && udisksctl unmount -b /dev/sdb1
    Unmounted /dev/sdb1.

    Why: if you ever write to the cart (see RETRODE.CFG below), yanking mid-write corrupts the save. Even read-only, a clean eject avoids leaving the OS confused about a device that vanished.

12. Load the ROM in an emulator or FPGA to confirm it boots. The final proof is a title screen. Point your emulator at ~/dumps/snes/SNES__A.sfc and watch it start.

    Why: a checksum proves the bytes are consistent; a boot proves they are right. This is your end-to-end confirmation that the preservation actually worked, and it is the satisfying part.

The RETRODE.CFG File

The Retrode's behaviour is not hard-coded. It ships with a plain-text configuration file you can edit like any other, which is exactly the kind of user-respecting design that makes this hardware age well.

Where it lives and how it works

Open the volume labelled RETRODE and you will find RETRODE.CFG sitting next to your ROM files. Open it in a plain-text editor, change a parameter, save the file, and the Retrode picks up the change. The behaviour documented on the official RETRODE.CFG page includes one delightfully clean convention: deleting a line resets that parameter to its factory default. There is no "restore defaults" button because you do not need one — you delete the line and the firmware supplies the default on the next boot.

The lines that matter

Two settings account for most of what people actually change. Note that exact line numbers can shift between firmware versions, so trust the parameter names, not the line positions, and confirm against the official documentation for your firmware.

Writing saves BACK to the cart

Setting sramReadonly to 0 turns the Retrode into a two-way device: you can copy an .srm file onto the volume and it writes to the cartridge's battery-backed RAM. This is genuinely useful — restore a rescued save, or transplant a save from an emulator back onto real hardware. It is also the single most dangerous thing the Retrode can do, because a botched write can overwrite or corrupt an irreplaceable save. Rules: leave sramReadonly at 1 unless you are deliberately writing; back up the existing .srm first; write, then eject cleanly; set it back to 1 when you are done. Treat writable mode like a live wire, because for your save files, it is one.

Controllers & Adapters

The Retrode is a cartridge dumper first, but the composite-USB design means it moonlights as a genuine retro-controller adapter, and the plugin system quietly extends it across five cartridge formats.

Controllers as USB HID

You can plug up to four original controllers into the side ports — two SNES and two Genesis pads — and they present to your computer as standard USB HID gamepads, driverless, for use in any emulator that reads HID input. This is the authentic-feel option: a real SNES pad, no adapter chain, no latency stack beyond USB itself. It is a legitimately good reason to keep a Retrode plugged in even after you have finished dumping. If you want the same authenticity for playback rather than input, a dedicated FPGA console like the Analogue 3D for N64 is the other half of that philosophy.

The plugin adapters

Beyond its two native slots, the Retrode2 reads three more formats through official adapter plugins. Each slots into the Retrode and extends the same driverless model to a new cartridge shape.

The Retrode3 adapter quirks (for the tinkerers)

Because the Retrode3 is coming and people will ask, a few confirmed compatibility notes from its testing, which double as a preview of that device's personality. The SNES mouse works only in the LEFT controller port — a quirk worth remembering if you are dumping and want to test a mouse-driven game. The Sega 32X adapter works when used without its own power supply, which is a pleasant surprise. And the Super Game Boy adapter does not work — do not buy one expecting the Retrode to read through it. These are the kinds of granular, unglamorous facts that separate a real device from a spec sheet, and it is a good sign that the project is documenting them before launch.

Firmware Without Bricking It

Updating firmware sounds scary and is not, provided you follow the one rule at the end. The Retrode2 uses a standard Atmel DFU (Device Firmware Update) bootloader on its AT90USB646 microcontroller, which means well-trodden, well-documented tooling.

Why update at all

Firmware controls cartridge detection, mapper handling, and the RETRODE.CFG feature set. Older builds mis-handle certain boards; newer builds fix them and occasionally add capabilities. If dumps of a specific game come out wrong no matter how clean the contacts, outdated firmware is a prime suspect. The public firmware list is on the Retrode firmware page — 0.17f being the current build referenced at time of writing.

Entering DFU mode

The button dance is identical on every platform. There are two buttons: RESET on the front and HWB (hardware boot) on the back. To enter the bootloader: hold RESET, hold HWB, release RESET first, then release HWB. The Retrode drops out of mass-storage mode and reappears as a DFU device. To leave DFU mode after flashing, press RESET once.

Linux / macOS: dfu-programmer

Three commands. Verify the device is in DFU mode, erase, flash, reset.

# 1. Confirm the Retrode is in DFU mode and talking:
$ dfu-programmer at90usb646 get product-revision

# 2. Erase the existing firmware:
$ dfu-programmer at90usb646 erase

# 3. Flash the new firmware hex you downloaded:
$ dfu-programmer at90usb646 flash retrode2-0.17f.hex
Validating...
8192 bytes used

# 4. Now press the RESET button on the Retrode to boot the new firmware.

After it reboots, re-open RETRODE.CFG and confirm the version string reflects the build you just flashed. That is your proof the update took.

Windows: Atmel FLIP

Prefer a GUI? Atmel FLIP does the same job with menus. With the Retrode in DFU mode: open FLIP, choose Device → Select and pick the AT90USB646 target; open Settings → Communication → USB and click Open; then File → Load HEX File and select the firmware you downloaded; click Run. When it finishes, press RESET on the Retrode and check the RETRODE.CFG version.

The one rule: never cross firmware

This is the rule that matters: never flash Retrode 2 firmware onto a Retrode 1, or vice versa. The hardware differs and the firmware is not interchangeable. Match the firmware to the exact device revision in your hands. Follow that, and the AT90USB646's DFU bootloader makes the Retrode2 very hard to permanently break — a bad flash just means re-entering DFU mode and flashing again.

Five Ways People Break This

Six, actually, because the sixth is the expensive one. These are the mistakes that turn a fifteen-minute job into a forum thread.

1. Running the emulator straight off the Retrode

Loading a ROM directly from the RETRODE volume in your emulator seems efficient and is a mistake. The Retrode is a slow cartridge bridge, not a runtime disk; you get stutter, slow loads, and confused behaviour. Fix: always copy the ROM to real storage first (Step 7), then run it from there.

2. Dirty contacts producing a silent bad dump

A dump from a grimy cartridge does not announce itself as broken. It is a normal-looking file with wrong bytes, and you will not notice until a game glitches out an hour into playing. Fix: clean contacts before dumping (Step 2), and checksum every dump (Step 9). Two matching dumps or bust.

3. Setting sramReadonly to 0 and nuking a save

Flipping the Retrode into writable mode and then fumbling a copy can overwrite the very save you were trying to preserve. Fix: leave sramReadonly at 1 by default; only enable writing deliberately, back up the existing .srm first, and set it back afterward.

4. Underpowered USB hubs and dodgy cables

The Retrode is bus-powered. Behind a cheap unpowered hub, or on a cable that only charges, it enumerates intermittently, drops mid-dump, or does not appear at all. Fix: use a known-good data cable straight into a rear/root USB port on a desktop, or a powered hub. If enumeration in Step 5 is flaky, this is almost always why.

5. Expecting it to read protected or exotic carts unchanged

Some cartridges have unusual mappers, lockout chips, or on-cart hardware that specific firmware versions handle better than others. A cart that dumps to a weird size or a checksum with no No-Intro match may be one of these. Fix: update firmware first (Step 1), consult the Retrode documentation and community for that specific game, and do not assume every anomaly is a rare variant — most are contacts or firmware.

6. Flashing the wrong firmware

Covered above but it earns repeating because it is the one genuinely painful error: do not cross Retrode 1 and Retrode 2 firmware. Match firmware to hardware revision, every time.

Troubleshooting Table

Symptom on the left, the actual cause in the middle, the fix on the right. Work top to bottom; the common causes are near the top.

Advanced Tips & Full Config

You have the basics. Here is how to scale it, hand it off, and lock in a configuration you can trust.

Batch dumping and verification at scale

If you are preserving a whole collection, do it methodically. Dump each cart, copy the files into a per-system folder, and run a single verification pass over the lot. A checksum manifest turns "I think these are fine" into "these are provably fine," and gives you a file to re-check the archive against years later.

# From your dumps folder, hash everything into a manifest:
$ cd ~/dumps
$ find . -name '*.sfc' -o -name '*.bin' -o -name '*.gen' \
    | sort | xargs md5sum > checksums.md5

# Later, verify the whole archive is still intact:
$ md5sum -c checksums.md5
./snes/SNES__A.sfc: OK
./genesis/GEN__B.bin: OK
./snes/SNES__C.sfc: FAILED    # investigate this one
md5sum: WARNING: 1 computed checksum did NOT match

Cross-reference the resulting hashes against a No-Intro DAT so each file gets a canonical, community-verified name and a known-good flag. That is the difference between a folder of ROMs and an actual preservation archive.

The emulator / FPGA handoff

Your dumps are just files now, portable to anything. Drop them into a Batocera install or a RetroPie box and they slot straight into the ROM folders by system. For cycle-accurate playback on real silicon, a MiSTer is the endgame — and there are community scripts specifically for loading cartridges from USB cart dumpers like the Retrode directly into MiSTer cores, closing the loop from real cart to FPGA in one motion. Whatever you choose, the RetroArch and libretro documentation is worth keeping open; the Retrode's own Wikipedia entry and the OSCR supported-systems list are good jumping-off points for the wider cart-dumping ecosystem the Retrode3 is about to plug into.

The complete working RETRODE.CFG

Here is a safe, sensible starting configuration, annotated. Treat it as illustrative of the format and intent — the file your Retrode generates on its own volume is always the source of truth, and the parameter set can vary by firmware, so cross-check against the official RETRODE.CFG documentation. The two settings that actually matter for safe, predictable dumping are called out.

# ------------------------------------------------------------
# RETRODE.CFG  -  safe defaults for reliable, read-only dumping
# Edit values, save the file. DELETE a line to restore that
# parameter's firmware default. Trust parameter NAMES over
# line numbers - positions can move between firmware versions.
# ------------------------------------------------------------

# Filename numbering: 0 = clean names (no appended counter),
# 1 = append an incrementing number. 0 is easier to script.
numbering            0

# SRAM protection: 1 = read-only (SAFE default, cannot harm
# your cartridge saves). Set to 0 ONLY when deliberately
# writing an .srm back to the cart - then set it to 1 again.
sramReadonly         1

# Everything else: leave at firmware defaults by omitting it.
# The Retrode fills in any parameter you delete. When in
# doubt, delete the line and let the firmware decide.
# ------------------------------------------------------------

Save that, eject cleanly, and your Retrode is configured for the safest possible default: clean filenames, no accidental writes to a thirty-year-old save. From here, the workflow is muscle memory — clean, insert, verify enumeration, copy, checksum, eject. The Retrode3 will eventually make some of this prettier, browser-based, and Wi-Fi-connected. But the job it does — giving you a verified copy of software you already own — is one the Retrode2 already does today, forty minutes and one shoebox of cartridges at a time. That is not a waitlist. That is a working machine.