Babalwa Latsha, South African rugby pro player, attends an event promoting mental wellness in women's professional sports. Image by Soweto TV, via Wikimedia Commons (CC BY-SA 3.0).

rugby

GAME BOY EMULATOR

rugby

Rugby is an open-source, cycle-accurate implementation of the SM83-based Nintendo Game Boy (original DMG) designed as a modular Rust workspace with cores, frontends (CLI, web/WASM, iOS), a libretro port, and testing suites.

Jump to download ↓Jump to setup guide ↓

Babalwa Latsha, South African rugby pro player, attends an event promoting mental wellness in women's professional sports. Image by Soweto TV, via Wikimedia Commons (CC BY-SA 3.0).

Game BoyPRIMARY SYSTEM

History documentedPROJECT BEGAN

Open sourcePROJECT MODEL

WHY IT MATTERS

Why Rugby exists

Rugby aims to provide high-accuracy, modular emulation of the original 1989 Nintendo Game Boy (SM83 family). It focuses on component modularity so different implementations of CPU, PPU, APU, etc. can be substituted for different accuracy/performance trade-offs and to support multiple frontend targets (CLI, WebAssembly, iOS, libretro).

BEST FOR

Best for

Developers, researchers, or advanced users who want a high-accuracy Rust-based Game Boy core that can be embedded in frontends (CLI, web/WASM, iOS) or used as a libretro core. Not targeted as a consumer-ready GUI player — it is pre-alpha and oriented toward development, testing, and integration.

Gameplay from Tetris on Game Boy.

The people behind rugby

History & status

Rugby is actively developed as an open Rust workspace (repository contains core crates, frontends, bindings, extras, and test ROMs). The README and documentation explicitly call the project pre-alpha and warn that APIs are not stable until an official release. The repository is structured as a Cargo workspace with many crates and frontends (core, debugger, CLI, iOS, web/WASM, libretro). The project includes extensive testing (multiple test suites listed in docs).

What rugby supports

Nintendo Game Boy (original DMG, SM83 family — cycle-accurate focus)
Rust-native frontends (CLI)
WebAssembly frontend (rugby-web)
iOS frontend (rugby-ios, SwiftUI)
libretro core (libretro implementation included in workspace)

Download and availability

OFFICIAL DOWNLOADS

Get rugby

Official source and releases are hosted on GitHub. Source: repository; binary/packaged builds (if any) are available from the repository's Releases page when provided by the author.

Get rugby ↗

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.

rugby setup guide

Setup note: Notes before you start: Rugby is a Rust workspace. Building and using it requires a current Rust toolchain, Cargo, and (optionally) platform toolchains for WASM or iOS. The project is pre-alpha — expect developer-oriented documentation and build steps rather than a polished end-user installer. This guide explains practical setup steps based on the project's repository layout and docs.

1) Get the source: Clone the official repository from GitHub (kaplanz/rugby). The repository is the canonical source of code, docs, and examples; Releases are served from the repository's Releases page.
2) Install Rust toolchain: Install the Rust toolchain (rustup) and ensure cargo is available. The project uses Cargo workspaces (multiple crates). Use a recent stable Rust toolchain; the README references Cargo as the package manager.
3) Build the workspace (native CLI/frontend): From the repository root you can build workspace crates. A typical developer step is to build the CLI frontend or the top-level crates with Cargo. For example, in the repo root run a cargo build or cargo build –release to compile the crates. Expect the build to produce binaries under target/ appropriate to the frontend you compile (apps/cli for the command-line frontend).
4) WebAssembly frontend (rugby-web): The project includes a web/WASM frontend. Building that frontend requires the wasm target and typical WASM toolchain (wasm-pack, or cargo + wasm toolchain) depending on the build instructions used by the project. Consult the project's docs/ or apps/web folder for exact build steps and any npm/bundler steps needed.
5) iOS frontend (rugby-ios): An iOS frontend exists (SwiftUI). Building the iOS app requires Xcode and the Swift toolchain. The workspace exposes bindings for Swift via UniFFI; follow the apps/ios and bind/swift code and the project's docs for platform-specific steps.
6) Libretro integration: The repository contains a libretro implementation under lib/retro. If you want to use Rugby as a libretro core, build the libretro crate according to the repository's crate/build conventions and then load the resulting core into a libretro frontend (RetroArch).
7) Testing and debugging: The project provides testing suites (Blargg, Mooneye, etc., listed in docs) and an interactive debugger crate (rugby-gbd). Use these for validation and development. The repository also includes open-source ROMs used for testing; commercial ROMs and official BIOS are not provided.
8) Practical tips and caveats: Rugby is pre-alpha. Expect API instability and developer-focused tooling. Always read the repository README and docs/ before attempting cross-compilation (WASM/iOS) or embedding as a libretro core. Do not expect prebuilt binaries for all platforms — if a release provides binaries they will appear on the GitHub Releases page.

Software reminder: Rugby does not include commercial game ROMs, firmware, or proprietary BIOS files. You must supply legally obtained ROMs and any required platform files; follow local laws and the project's licensing.