Screenshot published in the nemu project's official README. Image source: nemu project on GitHub.

nemu

NES EMULATOR

nemu

Nemu — a Rust-written NES (Nintendo Entertainment System) emulator that runs a subset of NES games, with a browser (WASM) frontend on the author's site and a native build in the GitHub repository.

Jump to download ↓Jump to setup guide ↓

Screenshot published in the nemu project's official README. Image source: nemu project on GitHub.

NESPRIMARY SYSTEM

History documentedPROJECT BEGAN

Open sourcePROJECT MODEL

WHY IT MATTERS

Why Nemu is notable

Nemu is a small, personal NES emulator implemented in Rust that includes CPU, PPU and APU work-in-progress, several debugging viewers (pattern tables, nametables, CPU/PPU state) and a WASM build that runs in the browser. It targets accuracy for a subset of mappers and publishes source and a playable web demo from the author.

BEST FOR

Best uses

Learning NES internals and emulator structure, experimenting with Rust for systems programming, debugging and visualization of NES state, and playing a limited set of verified-working NES ROMs that use supported mappers.

Gameplay from The Legend of Zelda on NES.

The people behind nemu

History and current status

The primary source for Nemu is the Quaqqer GitHub repository, which identifies the project as "Nemu is my NES emulator" and lists CPU/PPU/APU, input and debugging viewers as features. The project author publishes a web demo (WASM) at the Quaqqer site and the GitHub repository contains the native Rust source and build files. The Quaqqer demo page explicitly lists a set of supported mappers (Mapper 0, 1, 2 and 3 marked implemented; Mapper 4 marked not implemented) and notes a handful of working games such as Super Mario Bros., Zelda, Donkey Kong and Castlevania. The repository shows active commits and issue activity; the public README and project pages are the authoritative documentation for supported features and current mapper coverage. No official binary distribution is provided except for any GitHub releases if present; the canonical way to obtain Nemu is to clone the repository or use the WASM demo on the author’s site.

What nemu supports

System: Nintendo Entertainment System (NES)
Mapped cartridge support: Mapper 0 (NROM), Mapper 1 (MMC1), Mapper 2 (UxROM), Mapper 3 (CNROM) — (Mapper list as documented by the author)
Frontends: native Rust build (Cargo) and WASM browser demo
Platforms: native Linux / Windows (native build via Rust/Cargo), browser via WASM

Download and availability

OFFICIAL DOWNLOADS

Get nemu

Official source and any binary releases are on the project's GitHub page. If no release assets exist there, build from source with cargo or use the web demo hosted by the author.

Get nemu ↗

DOCUMENTATION

Official documentation

Read the official configuration, compatibility, and troubleshooting material before changing advanced options.

Read official documentation ↗

Broken or missing download? Emulator projects move and official links sometimes change. Please contact Retro Replay so the source can be verified and updated.

nemu setup guide

Setup note: Below are practical, repository-verified steps to build and run Nemu locally (native) and to use the browser demo. These steps assume a modern developer environment on Linux or Windows and basic Rust tooling knowledge.

Obtain the source or use the web demo: Official repository: clone https://github.com/Quaqqer/nemu. The author also hosts a WASM demo on Quaqqer.com/projects/nemu where you can load a ROM in-browser for quick testing. Check the GitHub releases page for any prebuilt assets; if none exist, build from source (next steps).
Native build prerequisites: Install Rust toolchain (rustup + stable toolchain) and Cargo. On Linux, you may also need SDL2 development headers if the native frontend uses SDL2 (check the repository README or crates/ for dependencies). The repository includes a rust-toolchain.toml indicating the Rust toolchain configuration.
Building native (general): From the repository root: run cargo build –release for a release build. If the project uses workspace crates or subcrates, the top-level Cargo.toml coordinates builds. If the README lists feature flags, enable them as needed (for example, GUI or audio). If SDL2 or other native libs are required, install their dev packages first (e.g., libsdl2-dev on Debian/Ubuntu).
Running the native build: Run the compiled binary produced in target/release/. Start the emulator with a path to a .nes ROM file if supported by the binary's CLI. Consult the repository README for exact command-line options and runtime keys. The author-provided controls mapping is documented on the web demo (arrow keys, Z/X for B/A, Enter for Start, Right-Shift for Select).
Using the browser (WASM) demo: Open the Quaqqer project page (Quaqqer.com/projects/nemu). The demo provides an in-browser UI with keyboard bindings documented on the page. The demo runs the same emulation core compiled to WASM and is useful for quick verification without native builds. The demo notes which mappers are implemented and lists some working games.
Mapper and compatibility considerations: Nemu implements a limited set of mappers (author-marked Mapper 0, 1, 2 and 3 implemented; Mapper 4 not implemented). Because many NES games depend on specific mappers, only cartridges using implemented mappers will run correctly. Test games known to be listed as working by the author first (Super Mario Bros., Donkey Kong, Zelda, Castlevania).
Debugging and developer features: The project exposes debugging viewers (CPU info, PPU info, pattern table and nametable viewers) useful for emulator development and verification. Use those tools to inspect PPU state, palettes and pattern tables when troubleshooting rendering or mapper issues.
Legal and ROM notes: The project does not include commercial game ROMs, BIOS or other copyrighted firmware. Use only ROMs you legally own or public-domain / homebrew test ROMs. The Quaqqer demo and repository README do not provide copyrighted ROMs.

Software reminder: Confirm required native libraries (SDL2 etc.) and Rust toolchain versions from the repository README and rust-toolchain.toml before building. Consult the README for any crate feature flags or platform-specific notes.