Build a Flipper Zero Game Boy Cartridge Dumper and ROM Reader Add-On

Dedicated cartridge dumpers like the GBxCart RW exist specifically because reading a Game Boy cartridge properly is more involved than it looks — the cartridge's parallel address/data bus runs at 5V logic, needs 16 address lines and 8 data lines addressed correctly to read ROM banks (and more for MBC-equipped cartridges with bank switching), and the Flipper Zero's GPIO header exposes far fewer pins than that at native 3.3V logic. This project builds a Flipper-based cartridge reader add-on anyway, as a genuinely educational exercise in bus-level hardware interfacing — and a working, if more involved, alternative to a purpose-bought dumper for anyone who wants to understand what's actually happening on that cartridge bus rather than just using a black box.

The Core Problem: Not Enough Pins, Wrong Voltage

Two separate problems need solving before any data comes off a cartridge:

• Voltage mismatch. Game Boy cartridges run their address/data/control lines at 5V logic. The Flipper's GPIO is 3.3V and is not rated to tolerate 5V inputs safely — driving 5V directly into Flipper GPIO risks damaging the pin or the whole board. Every line that touches the cartridge edge connector needs level shifting in both directions: 3.3V-to-5V going out (address lines, control signals) and 5V-to-3.3V coming back (data lines read from the cartridge).
• Not enough GPIO. A full parallel read needs roughly 16 address lines, 8 data lines, and a handful of control lines (chip select, read/write strobe) — well beyond what the Flipper's header exposes directly. The standard workaround, and the one this build uses, is shift registers: a pair of 74HC595s latch out a full 16-bit address using just 3 Flipper GPIO pins (data, clock, latch) rather than needing 16 dedicated lines, at the cost of added latency per address change versus direct parallel addressing.

Build Approach

1. Prototype the level-shifted bus on a breadboard first. Before committing to a final board, verify each level-shifter IC and shift register stage independently with a multimeter and, ideally, a logic analyzer — bus timing issues are far easier to diagnose on an open breadboard than after everything's soldered onto perfboard.
2. Wire the shift registers to drive the address bus. The 74HC595 pair shifts out a 16-bit address value; their parallel outputs connect (through level shifting) to the cartridge's address lines A0–A15.
3. Wire the data bus back through a level-shifting buffer. The cartridge's 8 data lines (D0–D7) run through a 5V-to-3.3V buffer (a 74HCT245-family bidirectional buffer works well here, since the data bus needs to be read, not just written) before reaching Flipper GPIO pins.
4. Handle control lines. Chip select and output-enable lines on the cartridge connector need to be driven low/high in the right sequence to actually trigger a read cycle — get the cartridge's datasheet-level timing right here or you'll read garbage or nothing at all, regardless of whether the address/data bus wiring is correct.
5. Write or adapt a Flipper app to sequence through addresses (via the shift registers), trigger reads, and stream the resulting bytes back over USB/UART to a PC, where they're assembled into a .gb/.gbc ROM file. The Flipper's official app catalog and community app repositories are worth checking first — custom GPIO-based cartridge readers are a known project category in the Flipper community, and an existing open-source app may save you from writing bus-sequencing logic from scratch.
6. Handle bank switching for larger cartridges. Cartridges above 32KB use a memory bank controller (MBC) chip on the cartridge itself and need specific control-line sequences to switch ROM banks into the addressable window — a basic 32KB-max reader is a reasonable first milestone before adding MBC bank-switching support.

Testing and Debugging

If reads come back as all-zero, all-0xFF, or repeating garbage, work the problem in this order: confirm power and ground are solid at the cartridge connector first (a loose connection here produces exactly these symptoms), then verify address lines are actually toggling correctly with a multimeter or logic probe on a few address bits while stepping through test addresses, then check that the control line timing (chip select/output enable sequencing) matches what the cartridge actually needs. A logic analyzer, if you have access to one, turns this from a frustrating guess-and-check process into a straightforward "look at the actual waveform" process — genuinely worth borrowing or buying a cheap one if you're doing much parallel-bus hardware debugging beyond this one project.

Legality Note

Dumping ROM data from a cartridge you physically own, for personal backup/archival purposes, follows the same reasoning covered in our Raspberry Pi retro-emulation ROM legality discussion — it's generally treated as a defensible personal format-shifting activity, distinct from downloading ROM files for cartridges you don't own. This project is about reading your own cartridges, not a tool for distributing copyrighted ROM data.

This is not the fastest or cheapest way to get a cartridge dumped — a dedicated GBxCart RW or similar purpose-built dumper will do it more reliably with none of the bus-timing debugging. The value in building this version is entirely in understanding how a parallel cartridge bus actually works at the signal level, using a tool (the Flipper) and skills (shift-register GPIO expansion, logic-level shifting) that transfer directly to plenty of other hardware-hacking projects beyond just this one cartridge format.