# pico-infonesPlus: an NES emulator with SD card menus on a Raspberry Pi Pico

> pico-infonesPlus is a C++ NES emulator for RP2040 and RP2350 microcontrollers that runs ROMs from an SD card, with an on-screen menu, a recently played list, USB drive mode, save states and Famicom Disk System support. It is a port of InfoNES extended with SD card integration and a menu system.

**PicoPlus-devel/pico-infonesPlus** — NES Emulator with SD card and menu support for the Raspberry PI Pico, Pico 2 and other RP2040/RP2350  based microcontrollers. Play your games from SD card on a HDMI display.

- Repository: https://github.com/PicoPlus-devel/pico-infonesPlus
- Stars: 534 · Forks: 56
- Language: C++
- License: GPL-3.0
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/picoplus-devel-pico-infonesplus

## What the project is and where it came from

pico-infonesPlus is a NES (Nintendo Entertainment System) emulator for Raspberry Pi Pico, Pico 2, and other RP2040/RP2350-based microcontrollers. It provides NES emulation with SD card support, an integrated menu system, and HDMI video output, enabling users to build compact, affordable retro gaming systems.

The lineage is stated in the README and matters for judging the code. The project is based on InfoNES by Jay Kumogata, ported to Raspberry Pi Pico by Shuichi Takano, and this implementation extends the core emulator with comprehensive SD card integration, menu functionality, and additional enhancements.

So there are three layers. InfoNES is the emulator core. The Pico port is the part that made it run on RP2040 at all. And this repository is the part that makes it a usable appliance: the SD card filesystem, the menu, the recently played list, the USB drive mode and the rest.

That division shows in the repository layout. There is an infones/ directory for the upstream emulator, a main.cpp and splash.cpp for the application entry point, a rom_selector.h which is the menu, state.cpp and state.h for save states, zapper.cpp and zapper.h for the light gun support, nes_palettes.cpp for the colour palettes, and PCB/ for the custom board designs. There is also a hosttest/ directory, a pico_lib and pico_shared directory, and a tusb_xinput directory for the XInput controller handling.

The primary language is C++, the licence is GPL-3.0, the default branch is main, and the recent releases are v0.54 from 2026-10-09, v0.53 from 2026-10-04 and v0.52 from 2026-09-25. The last push was on 2026-10-09, so the work is current.

The project also documents a build system with CMakeLists.txt, a cmake/ directory, bld.sh and buildAll.sh, plus buildAll_with_pio_usb.sh for the variant that uses the RP2040 PIO for USB, and pio_usb.md to explain it.

## Preparing the SD card, which is the whole user experience

The setup sequence is short and it is entirely about the SD card, because for the person holding the finished console that is the only interface there is.

```bash
1. Prepare an SD card formatted as FAT32 or exFAT
2. Transfer NES ROM files to the card. The file browser starts in `/roms/NES`, so this is the recommended location. If that folder does not exist, the browser falls back to the root of the card. Subfolders are supported.
3. Optionally include [metadata files](#using-metadata) for game information
4. Insert the SD card into the device
5. Use the menu to browse, select, and play games. Save data is automatically persisted to the SD card.
```

Two details in step 2 are worth separating. The file browser starts in /roms/NES, so that is where files should go, and if the folder does not exist the browser falls back to the root of the card rather than failing. And subfolders are supported, so a card can hold a library organised into directories rather than a flat list.

FAT32 and exFAT are the accepted formats, which is the practical constraint to plan around. exFAT handles files above 4 GB, which matters because a large NES collection is not hard to exceed the FAT32 limit, and the fallback to the card root means a card set up without the folder structure still works.

Step 5 contains the sentence that answers the most common question about this kind of device: save data is automatically persisted to the SD card. There is no separate save mechanism for battery-backed cartridges in the base configuration, because there is no cartridge.

The metadata files mentioned in step 3 are optional and are for game information, which is how a menu displays a title, a cover image and details about a game rather than the raw filename. The README links to a using-metadata section for the format.

For the Famicom Disk System, which is a separate storage format rather than a cartridge, the README gives a two-step procedure: copy the FDS BIOS file to the /bios directory on your SD card and name the file fds-bios.rom, after which FDS ROM images appear alongside NES ROMs in the menu. The BIOS is user-supplied, which is the same legal shape as supplying your own ROMs.

## The feature set, and which parts are conditional

The features list is long, and several entries carry conditions that matter more than the headline.

Execute NES ROM files directly from an SD card. Browse and launch games from an on-screen menu interface. And a recently played list holding the last 20 games you started, one button press away in the menu.

The USB Drive Mode is the feature that changes the hardware story. It presents the SD card to a computer as a USB drive from the settings menu, so games can be added or removed without taking the card out. On a device built into a case, that is the difference between a pleasant update experience and a disassembly.

There is dual controller support for two simultaneous controllers for multiplayer gameplay, and NES Zapper light gun support in beta, in controller port 2 of the custom PCB, using LCD-lag-corrected ROM patches and a third-party gun such as the Tomee Zapp Gun.

Save state management is automatic battery-backed SRAM persistence plus manual save states. The FDS support requires a user-supplied BIOS. Multi-region support covers NTSC, PAL and Dendy.

Colour palettes give a choice of nine NES palettes, selectable in the settings menu or with START plus LEFT or RIGHT during play.

Two more playback formats extend beyond cartridges. NSF Audio Playback plays NES music files with a visual VU-meter overlay, and WAV Audio Playback plays WAV files in the menu, which the README marks as RP2350 only.

And the multi-emulator console mode can run under pico-bootLoader alongside other emulators and Doom, selectable from an on-screen menu, also RP2350 only.

The hardware flexibility runs through compatible with standard DVI/HDMI breakout boards, with optional custom PCB and a 3D-printed case.

Three of the RP2350-only labels are worth noting as a pattern: the extra CPU headroom of the newer chip is what makes WAV playback, the multi-emulator boot menu and native-speed PAL feasible. The RP2040 does the same job, just with less.

## Regional timing, and why PAL is slower on an RP2040

The regional support table is the clearest statement of the hardware constraint in the project.

| Platform | NTSC | PAL | Dendy |
|----------|------|-----|-------|
| RP2350 | yes | yes (native speed) | yes (native speed, untested) |
| RP2040 | yes | yes (60Hz) | yes (60Hz, untested) |

The note underneath explains the difference: RP2040 boards operate PAL/Dendy games at 60Hz instead of 50Hz due to hardware constraints.

That is a real and unavoidable trade-off, not a setting you can change. PAL NES games run at 50 Hz because the video standard they were designed for was 50 Hz, and running them at 60 Hz changes the timing the game logic sees. Some PAL titles are tolerant of that, some are not, and the ones that are not will run fast, run slow, or break in ways that are hard to diagnose from the symptom.

The RP2350 handles PAL and Dendy at native speed, so a board with the newer chip gives you correct timing for those regions. The Dendy entries are marked untested on both platforms in the table, and the note says the same, so Dendy compatibility is a claim to verify rather than a guarantee.

The two chips differ in what else they can do. The RP2350 runs at native speed for 50 Hz content and gains the WAV playback, the pico-bootLoader menu and the ability to run under it alongside other emulators, all of which are marked RP2350 only. The RP2040 runs the NES part of the job well and the extras are absent.

So the board choice is a decision about which region set you care about and which extras you want, and it is worth making before you solder anything.

## Hardware options, and the soldering you are signing up for

The Possible configurations section lists several ways to build this, and the differences between them are mostly about how much work you want to do.

The first is a custom printed circuit board designed by johnedgarpark, which requires soldering. Up to two NES controller ports can be added to this PCB, and it can also be used with a USB game controller. You can 3D print your own NES-like case for it. The current design, v2.6, has through-holes, so besides a Raspberry Pi Pico or Pico 2 you can also use a Pimoroni Pico Plus 2, as long as it has soldered male headers.

The second is an additional PCB design for the Waveshare RP2040 and RP2350 Zero including a case design by DynaMight1124, based around cheaper but harder to solder components, and it also allows the design to be smaller.

The third is a further PCB design for the new Waveshare RP2350 USB A board, which allows a very small PicoNES console to be made using USB control pads only, and the README describes it as by far the most challenging to solder.

There is also the option of no PCB at all. The Adafruit Feather RP2040 with DVI HDMI Output Port can be used with a USB game controller, up to two legacy NES controllers, or a Wii Classic controller, with add-ons including a breadboard and an SD reader.

The same theme runs through the family of related projects the README points at. There are emulator ports for the Sega Master System and Game Gear, the Nintendo DMG Game Boy and Game Boy Color, and the Sega Mega Drive and Genesis, plus retroJam for the Adafruit Fruit Jam which plays NES, Game Boy, Game Boy Color, Sega Master System, Sega Game Gear and Sega Genesis.

That list is the best evidence of what this project is for. These are all RP2040 and RP2350 handheld builds, and the common ingredient is a microcontroller with a video output and no operating system. The hardware page in the README also links to the Adafruit tutorial for an NES emulator for RP2040 DVI boards, which is the reference for the wiring if you are starting from a breakout board rather than a custom PCB.

## Where this emulator is the wrong choice

There are three limits, and the first is about what an emulator on a microcontroller can be.

The first is that this is a hardware project with a software component, not the other way round. The emulator is the easy part. The work is the DVI output on a board that has no display output, the SD card wiring, the controller ports, the case, and the soldering. The README says as much when it calls the custom PCB the flagship path and describes the Waveshare designs in terms of how hard they are to solder. Anyone evaluating this as a software project is evaluating the wrong half.

The second is that the accuracy bar is set by the hardware, and the hardware sets it low. The Zapper support is in beta and depends on LCD-lag-corrected ROM patches, which is an admission that the timing is not exact. The PAL and Dendy region handling on an RP2040 runs at 60 Hz rather than the correct 50 Hz. And the PAL and Dendy entries in the support table are marked untested. None of that matters for the games people mostly play on these devices, but it does mean this is not an emulator to judge a NES game's timing behaviour against.

The third is the scope of the emulator itself. This is a NES emulator, and the README mentions NES ROM files, NSF music files and WAV files, with the FDS support requiring a user-supplied BIOS. There is no mapper support listed beyond what a NES title needs, no mention of an arcade or MSX mode, and no indication of the accuracy level against reference test suites. If you want a NES emulator to be your primary way of playing, a desktop emulator running on hardware you already own will be faster, more accurate and easier to get working, and this project makes no claim to compete on those terms.

The honest alternative depends on the goal. For playing NES games well, a desktop emulator is the better answer and costs nothing extra, since the Pico cannot play games the desktop cannot. For building a portable console, a different microcontroller emulator family, or the same author's multi-emulator retroJam and pico-bootLoader projects if you want more than one system on one board, is the better comparison. The USB drive mode and the multi-emulator boot menu are the two features that distinguish this from a plain ROM loader, and both of them are about the experience of owning the device rather than about emulation quality.

What the project delivers is a complete, well-specified appliance: a menu, a library on a card, save data that persists, and a way to add games without opening the case. The emulator is a component of that, and it is not the part that should decide whether you want it.

## Conclusion

Adopt pico-infonesPlus if you want to build a small standalone NES console around a Raspberry Pi Pico or a similar RP2040 or RP2350 board, since it handles the SD card, the menu and the HDMI output as one firmware. Do not adopt it if you need a fast NES emulator on a desktop, because the design trades accuracy headroom for a microcontroller's budget. Before you build, check that your board has a DVI or HDMI output and decide which controller option you will use, and note the last push was on 2026-10-09 with release v0.54 the same day.

## FAQ

### What is pico-infonesPlus and which hardware does it run on?

It is a NES emulator for Raspberry Pi Pico, Pico 2 and other RP2040 or RP2350-based microcontrollers, with SD card support, an integrated menu system and HDMI video output. It is based on InfoNES by Jay Kumogata, ported to the Pico by Shuichi Takano, and extended with SD card integration and the menu.

### How do I set up the SD card for pico-infonesPlus?

Format a card as FAT32 or exFAT, copy NES ROM files to it, and optionally add metadata files for game information. The file browser starts in /roms/NES and falls back to the root of the card if that folder is missing, and subfolders are supported. Insert the card and browse from the menu, with save data persisted automatically.

### Does pico-infonesPlus support PAL and Dendy games?

The RP2350 runs PAL and Dendy at native speed, while the RP2040 runs them at 60Hz instead of 50Hz due to hardware constraints. The Dendy entries are marked untested on both platforms, so those are claims to verify rather than guarantees.

### What does the USB Drive Mode do in pico-infonesPlus?

It presents the SD card to a computer as a USB drive from the settings menu, so games can be added or removed without taking the card out of the device. The repository also supports WAV playback in the menu, the multi-emulator boot menu under pico-bootLoader, and the NES Zapper in beta, all of which are marked RP2350 only.

### How do I enable Famicom Disk System games in pico-infonesPlus?

You supply your own BIOS: copy the FDS BIOS file to the /bios directory on the SD card and name it fds-bios.rom. FDS ROM images then appear alongside NES ROMs in the menu.

## Sources

- [Issues](https://github.com/PicoPlus-devel/pico-infonesPlus/issues)
- [License: GPL-3.0](https://github.com/PicoPlus-devel/pico-infonesPlus/blob/main/LICENSE)
- [PicoPlus-devel/pico-infonesPlus on GitHub](https://github.com/PicoPlus-devel/pico-infonesPlus)
- [README](https://github.com/PicoPlus-devel/pico-infonesPlus/blob/main/README.md)
- [Releases](https://github.com/PicoPlus-devel/pico-infonesPlus/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/picoplus-devel-pico-infonesplus