This is top from procps-3.2.7. I'm listing it as "Linux software screenshot", whatever that comes out as, though I claim no copyright and doubt that anyone else could either. Image by This file was made by User:Sven Translation If this image contains text, it can be translated easily into your language. If you need help, contact me Flexible licenses If you want to use this picture with another license than stated below, contact me Contact the author If you need a really fast answer, mail me . If you need only a fast answer, write me here ., via Wikimedia Commons (GPL).

mes

NES EMULATOR

mes

Mes (mes) is an open-source, multiplatform NES (Nintendo Entertainment System / Famicom) emulator written in Rust with WebAssembly support; it runs iNES-format ROMs and implements a small set of common mappers and hardware quirks.

Jump to download ↓Jump to setup guide ↓

NESPRIMARY SYSTEM

History documentedPROJECT BEGAN

Open sourcePROJECT MODEL

WHY IT MATTERS

Why consider Mes

Mes is a compact NES implementation in Rust intended for experimentation, embedded/Android/web builds, and developers who want a Rust/WASM-based NES runtime. It offers browser (WASM) playback, Android and desktop builds, and implements core NROM/SXROM/UXROM/CNROM mapper support and several hardware quirks.

BEST FOR

Best for

Developers or hobbyists who want a lightweight Rust-based NES emulator that can run in a browser (WASM), on Android, or be embedded on constrained devices (ESP32), and who need a small, auditable codebase for learning or integration.

Gameplay from The Legend of Zelda on NES.

The people behind mes

History & status

Mes is hosted on GitHub and maintained by the repository owner (luckasRanarison). The project presents itself as a "decent multiplatform NES emulator written in Rust" and includes builds/targets for Web (WASM), Android, desktop (Rust), and embedded (ESP32). The repository lists features, supported mappers (NROM, SXROM, UXROM, CNROM) and references NES development resources. The project is active enough to include code, build instructions, and a web demo, but it is smaller in scope than high-accuracy emulators (it supports a subset of mappers and aims for practicality and portability).

What mes supports

Web (WASM) — runs in browser
Android (via native Rust library + Android project)
Desktop — Rust targets (build from source)
Embedded (ESP32) — mentioned as a target
iNES 1.0 ROM files (common .nes files)

Download and availability

OFFICIAL DOWNLOADS

Get mes

Official source and releases are distributed from the project's GitHub repository. Prebuilt release artifacts (when present) are on the repository Releases page; otherwise build from source using the instructions in the repo and website.

Get mes ↗

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.

mes setup guide

Setup note: This setup guide covers obtaining Mes, building or using the web demo, building for desktop/Android, and practical notes (mapper support, ROM format, and legal reminders). Follow the repository README and site for exact commands and any platform-specific prerequisites.

Obtain the project and releases: Visit the project's GitHub page to view source, issues, and any Releases. If a release binary exists, download it from the Releases tab. If not, clone the repository to build from source: git clone https://github.com/luckasRanarison/mes.git.
Web (WASM) — fastest way to try in a browser: The project provides a web demo powered by WebAssembly. Requirements for building locally are Node.js and wasm-pack. Build steps (from repo): run wasm build script (npm run wasm) to produce WASM artifacts, then run the development server (npm run dev) or npm run build to produce static assets. Alternatively, use the project demo site if available to drag-and-drop iNES-format .nes files to run them in-browser.
Desktop — build from source: Mes's core is written in Rust. Install Rust toolchain (rustup) and ensure a compatible toolchain is selected (the repo includes rust-toolchain configuration). From the repository root, use cargo to build the relevant crate(s). The README notes the Rust toolchain is required; check Cargo.toml and crates/ subfolders for specific crate names and examples. No commercial BIOS or firmware is required — Mes expects iNES-format ROMs.
Android — building the native library and app: Android builds require Android Studio and the NDK plus Rust cross-compilation targets (aarch64-linux-android, x86_64-linux-android). Edit ~/.cargo/config or the repo cargo configuration to point linkers to the NDK toolchains; the README lists example linker entries. The Android Gradle scripts included in the repo are used to assemble the native Rust library for each ABI (e.g., buildRustArm64, buildRustx86_64). After producing the native libraries, use Android Studio to build the APK that wraps the native emulator library.
Embedded (ESP32) target notes: The README mentions an ESP32 embedded target. Building for ESP32 requires the appropriate Rust target and any board-specific SDK/toolchain; consult the repository's crates and build scripts for ESP32-specific instructions. Expect additional platform-specific setup beyond typical desktop/Android builds.
ROM format, mappers and compatibility: Mes supports iNES 1.0 ROMs and implements a handful of common mappers: NROM (0), SXROM (1), UXROM (2), CNROM (3). If a game's mapper is not listed, it will not run correctly. Use known-good iNES .nes files that match supported mappers. The emulator implements some original hardware quirks but is not presented as a high-accuracy emulator covering all NES mappers.
Controls and usage: For the web demo the README documents keyboard mappings (arrow keys for directions; Q/A for A; Z/W for B; Space for Select; Enter for Start) and drag-and-drop ROM loading. For other builds, input binding details depend on the frontend (Android UI or desktop wrapper).
Practical tips and troubleshooting: If a build fails, verify Rust toolchain and target installations and that linker paths to Android NDK are correct for Android builds. For WASM builds ensure wasm-pack and Node.js are installed. If a ROM produces graphical glitches or crashes, check mapper support; many compatibility issues stem from unsupported mappers rather than bugs. Consult the repository Issues page for known problems and pull requests for recent fixes.

Software reminder: Mes does not include commercial games, BIOS, or firmware. Only load ROMs you legally own. Use iNES 1.0 (.nes) files that match one of the supported mappers.