Free tools Windows power users keep installed
One-click scans. No signup required.
Tuna is an open-hardware Famicom cartridge bus interface built around a Raspberry Pi Pico and RP2040. It is designed to let a computer communicate with compatible cartridges for reading, dumping, writing, and development—not to play games or emulate a Famicom. Its Kazzo-compatible approach makes it interesting to preservationists and hardware hackers, but sparse build guidance and acknowledged timing differences mean it is not a turnkey or universally compatible dumper.
What Tuna does—and what it does not
A Famicom cartridge contains memory and, depending on the game, mapper logic that a console accesses over a cartridge bus. Tuna provides a way for host software to access that cartridge-side interface without using an original console. The Pico runs firmware that handles bus activity and USB communication; desktop software sends requests and receives data.
That makes Tuna a bus-level tool, not a console. It does not execute game code, display games, or function as an emulator. Nor is it a universal adapter for every Nintendo cartridge format: this project is intended for Famicom cartridge work.
The project repository includes Pico firmware, schematic and board-design files, and a desktop debugger named tuna_can. Hackster describes the design as replacing the Kazzo’s Microchip ATmega164P controller with a Raspberry Pi Pico and RP2040. The Pico is only one part of the build; the dedicated interface PCB and its supporting components are also required. Tuna’s project repository and the Hackster project overview describe the design and its purpose.
Recommended Free Tools
#1 Best Overall
- RP2040 microcontroller chip designed by Raspberry Pi in the United Kingdom
- Dual-core Arm Cortex M0+ processor, flexible clock running up to 133 MHz
- 264KB of SRAM, and 2MB of on-board Flash memory
- Castellated module allows soldering direct to carrier boards
- 26 × multi-function GPIO pins
How Tuna relates to Kazzo
Kazzo is an earlier USB-oriented Famicom cartridge bus simulator associated with cartridge ROM dumping. Tuna is presented as a Kazzo-compatible redesign using a newer controller platform. That compatibility is useful because it connects Tuna to an existing workflow, including cartridge-specific scripts, but it should not be read as a guarantee that every Kazzo script, cartridge, or timing-sensitive mapper will work without adjustment.
| Aspect | Kazzo | Tuna |
|---|---|---|
| Role | Famicom cartridge bus simulator | Kazzo-compatible Famicom cartridge bus simulator |
| Main controller | ATmega164P, as described by Hackster | Raspberry Pi Pico with RP2040, as described by Hackster |
| Host workflow | USB-connected computer workflow | USB-connected computer workflow |
| Design files | Not stated in the Tuna project sources | Repository includes firmware and hardware design files |
| Timing evidence | Not stated in the Tuna project sources | The project’s technical note reports approximately 1.48 MHz PHI2 cycle timing and approximately 16 ns PHI2-to-ROMSEL delay; these are project observations, not independent certification |
The comparison is about the stated design relationship, not a full engineering test of the two devices. Tuna’s own note says its bus behavior is not exactly identical to a real Famicom.
Rank #2
- The Raspberry Pi Pico is a beginner-friendly microcontroller board that uses MicroPython to give you a taste of the Internet of Things and microcontrollers. The RP2040 is a well-designed microprocessor that can be utilized in almost any Internet of Things project. It has enough power to complete the task quickly.
- 【Raspberry Pi RP2040 Microcontroller】Raspberry Pi Pico features Dual-core ARM Cortex M0+ processor, flexible clock running up to 133 MHz. With 264KB of SRAM, and 2MB of on-board Flash memory.Supports up to 16 MB of off chip flash memory via a dedicated QSPI bus
- 【Multiple Software Support】Pico has rich and complete software support, it comes with a complete Rasberry Pi official C/C++ SDK, Micropython SDK.The programming and burning of Pico need to be carried out on the computer. Supported operating systems and computers include:Raspberry Pie with Raspberry Pi OS,Other platforms equipped with Debian based Linux system Computer with MacOS, Computers with Windows, etc.
- 【Rich Hardware Interface】Raspberry Pi Pico has 30 GPIO pins, 4 pins for analog signal input and 26 × multi-function GPIO pins, 2 × SPI, 2 × I2C, 2 × UART, 3 × 12-bit ADC, 16 × controllable PWM channels.USB 1.1 supported by host and device, The installation mode can be flexibly selected by users to facilitate welding with other development boards.
- 【Build Project in Tiny Size】Only 2.1cm*5.1cm ( as small as your thumb). Pico has been designed to use either soldered 0.1" pin-headers or can be used as a surface-mountable 'module'.
What the hardware and software include
The board
The repository’s schematic directory contains KiCad-related schematic and PCB files, Gerbers for fabrication, a bill of materials spreadsheet, and custom symbols and footprints. Those files make self-fabrication possible in principle, but the project sources do not establish that assembled Tuna boards are currently sold.
Pico firmware
The firmware directory contains a CMake configuration, bus simulation and USB-related code, flash-memory and request-handling components, and the Pico SDK as a Git submodule. The project’s English build note points readers to Raspberry Pi’s Pico getting-started material but deliberately omits a complete environment setup. It says the SDK is included as a submodule; it does not provide a verified, end-to-end command sequence or identify a tested firmware image and flashing procedure.
Rank #3
- with pre-soldered header Raspberry Pi Pico. RP2040 microcontroller chip designed by Raspberry Pi in the United Kingdom
- Dual-core Arm Cortex M0+ processor, flexible clock running up to 133 MHz. 264KB of SRAM, and 2MB of on-board Flash memory.
- Castellated module allows soldering direct to carrier boards. USB 1.1 with device and host support. Low-power sleep and dormant modes. Drag-and-drop programming using mass storage over USB. 26 × multi-function GPIO pins.
- 2 × SPI, 2 × I2C, 2 × UART, 3 × 12-bit ADC, 16 × controllable PWM channels.Accurate clock and timer on-chip.Temperature sensor.
- Accelerated floating-point libraries on-chip.8 × Programmable I/O (PIO) state machines for custom peripheral support
tuna_can and cartridge scripts
tuna_can is a desktop debugger for cartridges used with Tuna or Kazzo. Its README documents reading, writing, and dumping data at appropriate addresses, as well as helping develop anago scripts. It also reports command history of up to 64 entries. The same README documents Visual Studio Community 2019 as a build environment, which is a project-era instruction—not confirmation that current compilers or operating systems will work unchanged. The README does not provide a complete command reference in its rendered documentation. See the tuna_can README.
What building Tuna involves
Tuna is most realistic for someone comfortable with PCB assembly, Pico firmware, and desktop development. The published material supplies design assets, but not a beginner-ready assembly and installation walkthrough. A prospective builder should plan to resolve component sourcing, board fabrication and assembly, SDK and compiler setup, USB behavior, firmware flashing, and host-tool compatibility.
Rank #4
- New Flexible Microcontroller Board --- Raspberry Pi Pico is a tiny, fast, and versatile board. It's based on RP2040 chip, which features a dual-core Arm Cortex-M0+ processor with 264KB internal RAM and support for up to 16MB of off-chip Flash, flexible clock running up to 133 MHz.
- Multi-Function GPIO Pins---It has 26 multifunction GPIO pins, including 3 analogue inputs, 2 × UART, 2 × SPI controllers, 2 × I2C controllers, 16 × PWM channels.
- Rich Peripheral Set---A wide range of flexible I/O options includes I2C, SPI, and — uniquely —8 × Programmable I/O (PIO) state machines for custom peripheral support.
- Multiple Software Support---Raspberry Pi Pico has rich and complete software support and community resources. Programmable in C and MicroPython. Drag-and-drop programming using mass storage over USB.
- Low-power sleep and dormant modes; Accurate on-chip clock; Temperature sensor; Accelerated integer and floating-point libraries on-chip
- Review the design first. Inspect the schematic, PCB, Gerbers, and bill of materials. Confirm the board revision and components before ordering or assembling hardware.
- Assemble the interface. Fit a Raspberry Pi Pico and the other components specified by the design. Do not assume a Pico alone can connect a cartridge safely.
- Prepare the firmware environment. The repository provides CMake-based firmware and the Pico SDK submodule, but omits a complete setup recipe. Follow the applicable Pico SDK documentation and verify the project’s build requirements rather than relying on an untested command sequence.
- Build and flash the firmware. The available project notes do not establish a current, verified build-and-flash procedure or a guaranteed output filename.
- Set up the host tool. Build or run
tuna_canaccording to its project files. Visual Studio Community 2019 is the version cited by its README; newer environments may require adjustments. - Start with a known, expendable cartridge. Confirm the connection and read workflow before attempting writes or using valuable hardware.
The repository describes itself as provided “as is” and says the author does not provide explanations or answer questions. Builders should treat the project as source material for an informed hardware project, not as a supported consumer product.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Dumping, writing, and validating cartridge data
The project documents software functions for reading, dumping, and writing, but a debugger’s ability to issue a write request does not make every cartridge writable. Read support and write support are separate questions: a cartridge may contain mask ROM, battery-backed RAM, flash, EEPROM, or a board-specific combination, and its mapper and address decoding affect what the interface can access.
Best Value
- Raspberry Pi Pico: A tiny, fast, and versatile board built using dual-core Arm Cortex-M0+ processor (Comes with pinout card and stickers)
- Detailed Tutorial: Provides step-by-step guide with MicroPython, C and Processing (Java) Code (The download link can be found on the product box) (No paper tutorial)
- Example Projects: Each project has schematics, wiring diagrams, complete code and detailed explanations (Need extra items)
- Easy to Use: Just connect the board to your computer (installed IDE) with the USB cable to program it
- Get Support: Our technical support team is always ready to answer your questions
- For preservation dumps: make repeated reads, retain logs and any failed or partial outputs, record the cartridge board and mapper information, and compare hashes of repeated files. Matching hashes are useful evidence of repeatability, though they do not alone prove a dump is historically correct.
- For writes: confirm the memory technology, voltage requirements, erase procedure, address mapping, script support, and write protection before proceeding. Use expendable or legally owned hardware that you can afford to damage, and keep verified backups where applicable.
- For contact problems: inspect and appropriately clean cartridge contacts, reseat the cartridge, and repeat reads. Intermittent connections can produce plausible-looking but corrupted files.
These are prudent preservation practices, not a validation protocol supplied by Tuna’s developers. Making a dump also does not grant permission to distribute copyrighted game data; follow the law that applies where you live.
Compatibility and timing: the important caveat
The project does not publish a comprehensive tested-cartridge, mapper, or board compatibility matrix in the available documentation. Actual results can depend on cartridge wiring, mapper behavior, memory type, voltage requirements, the script used, and bus timing. Verify support for the specific cartridge before connecting it, and do not infer universal compatibility from the Kazzo-compatible description.
The project’s technical note says Tuna is not completely identical to a real machine. It reports an approximately 1.48 MHz PHI2 cycle and an approximately 16 ns delay from PHI2 to ROMSEL, with the delay measured by the project author using an oscilloscope. The note says repeated access patterns can approach real hardware behavior. These figures are the author’s reported observations; they do not certify electrical or timing equivalence across cartridges. A mapper or cartridge that is sensitive to timing may behave differently on Tuna than in an original Famicom.
Who should build or use Tuna?
- A good fit: hardware hackers who want an open design, can assemble a board and compile firmware, and are willing to adapt or develop cartridge scripts.
- A cautious fit: preservationists who can validate repeated dumps and accept that cartridge support and timing are not comprehensively documented.
- A poor fit: anyone seeking a polished plug-and-play dumper, vendor support, a current compatibility database, or a device that simply plays cartridge games.
If convenience and support matter more than modifying an open design, a currently supported commercial dumper may be a better category to investigate—but Tuna’s available documentation does not provide a verified product-by-product comparison. An emulator or FPGA console is not automatically an alternative: running a game and accessing cartridge data for dumping or writing are different jobs.
Is Tuna practical in 2026?
Tuna remains a technically interesting route to a Pico-based, Kazzo-compatible Famicom cartridge interface for builders who can work from hardware files and source code. Its practical appeal is openness and the possibility of experimenting with a familiar cartridge-bus workflow. Its constraints are equally clear: build steps are incomplete, current toolchain compatibility is not established, cartridge support is undocumented as a full matrix, and the project itself reports differences from real-console timing. Treat it as a hardware-development project that may support preservation—not as a ready-made, guaranteed solution for an irreplaceable cartridge.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
