RustyBoy

GAME BOY COLOR EMULATOR

RustyBoy

RustyBoy is a cycle-accurate Game Boy emulator implemented in Rust that aims to closely mimic the original hardware (including a microcode-driven CPU implementation) rather than prioritize raw speed.

Jump to download ↓Jump to setup guide ↓

RustyBoy emulator screenshot.

game boy colorPRIMARY SYSTEM

History documentedPROJECT BEGAN

Open sourcePROJECT MODEL

WHY IT MATTERS

Why RustyBoy exists

RustyBoy was created to produce a highly accurate, hardware-minded Game Boy implementation (the author describes the design as emulating FPGA-style development and uses a microcode-driven CPU model). It is intended for accuracy and correctness rather than being optimized purely for speed.

BEST FOR

What it does well

Cycle-accurate CPU implementation driven by microcode, thorough testing against well-known GB test suites, and an implementation that runs on any Rust-supported target. The project documents its test status and focuses on GPU/cycle-accurate behaviour that many demo-scene ROMs and correctness-focused users care about.

The people behind RustyBoy

Project history & status

RustyBoy is developed in a public GitHub repository and has an active commit history and formal releases. The README and changelog document progress (including a v1.1.0 release) and list test-suite results (Blargh, MooneyeGB, Wilbert Pol tests). The author describes the emulator as feature-complete for the areas they care about (with audio noted as recently improved). The repository lists 200+ commits and shows active repository activity and releases on GitHub.

What RustyBoy supports

Original Game Boy (DMG)
Game Boy Color ROMs (behaviour and GPU accuracy are discussed in the README; the project focuses on cycle-accuracy but does not claim 100% compatibility with all GBC edge cases)
Cartridge controllers: MBC1 and MBC3 (documented in the changelog/README)
Cross-platform Rust targets (desktop audio backend available on Linux, macOS, Windows)

Download and availability

OFFICIAL DOWNLOADS

Get RustyBoy

Official source and releases are hosted on the project's GitHub repository and its Releases page. Pre-built binaries may be attached to GitHub releases when present; otherwise build from source with Cargo.

Get RustyBoy ↗

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.

RustyBoy setup guide

Setup note: RustyBoy builds and runs from source using the Rust toolchain. The README lists platform prerequisites and a simple run example. The following setup notes are practical, concrete steps derived from the project's documentation and codebase.

1) Get the source and prerequisites: Install Rust (stable channel) and Cargo. Install cmake (required to build the audio backend's third-party dependency). On Linux, install pkg-config and PulseAudio if you want audio playback (example for Debian-based systems: sudo apt install pkg-config pulseaudio). If audio build fails, the project README notes you can remove the audio feature from the soc crate's default features.
2) Clone the repository: Clone the official repository: git clone https://github.com/RamiHg/RustyBoy (use the Releases page to download source tarballs or release assets if you prefer).
3) Build and run a ROM (desktop): From the repository root you can run a ROM directly with Cargo. Example: cargo run –release — path_to_rom.gb. Replace path_to_rom.gb with the path to a legally-obtained Game Boy / Game Boy Color ROM file. If you prefer to produce a binary first: cargo build –release and then run target/release/<binary-name> path_to_rom.gb (binary name is visible in Cargo.toml or target directory after build).
4) Audio build notes: The audio backend uses libsoundio (built via CMake) and libsamplerate for resampling to 48 kHz as described in the changelog/README. If you cannot compile those dependencies, remove the audio feature from the soc crate's default feature list in Cargo.toml to build without audio support.
5) Cartridge/Save handling: RustyBoy documents support for MBC1 and MBC3 cartridge types. The repository contains code and test ROMs used during development. The README and test folders are the best place to inspect how save (battery-backed RAM) or RTC-sensitive cartridges are expected to behave; do not expect bundled commercial ROMs or BIOS files in the repo.
6) Platform targets and headless/web demo: The project is written in Rust and intended to run on any target supported by Rust. The README references a web_demo folder; the repository structure also contains cross-platform code paths. Consult the repository files (Cargo.toml and web_demo) to build for non-desktop targets or WebAssembly.
7) Troubleshooting and testing: If you encounter issues, check the repository's tests and test_roms folders and the project's changelog and README sections that report which test suites pass or fail. The README includes notes on test status against Blargh, MooneyeGB, and Wilbert Pol tests.

Software reminder: RustyBoy does not include commercial games, BIOS files, firmware, or other proprietary content. Provide your own legally-obtained ROMs and any required BIOS files (if a particular frontend or build requires them).