jitboy

GAME BOY COLOR EMULATOR

jitboy

jitboy is an open-source Game Boy / Game Boy Color emulator that uses dynamic recompilation (a JIT) targeting x86-64 Linux systems. It implements a JIT CPU core (DynASM/LuaJIT) and interprets the remaining hardware (video, memory, I/O).

Jump to download ↓Jump to setup guide ↓

jitboy emulator screenshot.

game boy colorPRIMARY SYSTEM

2020PROJECT BEGAN

Open sourcePROJECT MODEL

WHY IT MATTERS

Why this project matters

jitboy explores a JIT-based approach to Game Boy emulation: rather than interpreting every LR35902 (GB CPU) opcode, it dynamically recompiles blocks of guest code to x86-64 at runtime with DynASM (LuaJIT's assembler) to improve execution speed while still emulating memory-mapped hardware in software. This makes it an interesting project for people studying emulator performance and dynarec techniques.

BEST FOR

Best use cases

Research, education, and experimentation with JIT/dynarec techniques for 8-bit console emulation; running Game Boy and Game Boy Color ROMs on x86-64 GNU/Linux systems for testing and development.

The people behind jitboy

History and status

The repository documents a project developed and copyrighted 2020–2021 and originally written by Thomas Witte; it is hosted on GitHub and licensed GPLv3. The codebase centers on a JIT translation core that emits x86-64 code via DynASM, while other subsystems (graphics, APU references, memory-mapped I/O) are implemented with interpreted emulation. The README and repository show active development with commits and issues, but the project is explicitly targeted at GNU/Linux due to ABI compatibility and is not presented as a cross-platform distribution. The project reuses small third-party components (for example an APU implementation based on MiniGBS) and includes build instructions relying on SDL2. The repository provides source releases via GitHub Releases; prebuilt binaries are not provided for every platform. Known limitations listed by the author include Linux-only support and the usual cartridge edge cases (special mapper/hardware on some cartridges) that any emulator must handle carefully.

What jitboy supports

Game Boy (DMG)
Game Boy Color (CGB)
x86-64 GNU/Linux (build target and runtime ABI)
Requires SDL2 development libraries at build time

Download and availability

OFFICIAL DOWNLOADS

Get jitboy

Source and release assets are hosted on the project's GitHub repository and Releases page. Build from source using the included Makefile after installing SDL2 development packages. No commercial ROMs, BIOS files, or firmware are bundled with the project; users must supply their own legally-obtained ROM images.

Get jitboy ↗

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.

jitboy setup guide

Setup note: Practical setup notes and a focused build/run guide for jitboy (x86-64 GNU/Linux): follow the steps below to clone, build, and run the emulator. The instructions reflect the project's README and Makefile; adjust package manager commands as needed for your distribution.

Install prerequisites: Install a C toolchain and SDL2 development headers. Example on Debian/Ubuntu: sudo apt update && sudo apt install build-essential libsdl2-dev git. Ensure you are on an x86-64 GNU/Linux host — the project documents ABI dependence on Linux.
Clone the repository: git clone https://github.com/sysprog21/jitboy.git && cd jitboy. Use the repository sources rather than unknown forks when possible.
Build: Run make in the repository root. The Makefile produces build/jitboy (the executable). If you need debug output, run make clean debug as documented in the README to enable verbose messages; debug builds will also generate temporary JIT binaries under /tmp/jitcode* for inspection.
Run a ROM: Launch the emulator with the built binary: build/jitboy <path-to-rom>. The emulator attempts to find a .sav file with the same name as the ROM to load/save battery-backed RAM. Use the documented runtime options (for example -O to select optimization level) to tune JIT behaviour.
Controls and behaviour: Default key mappings are A=z, B=x, Start=Return, Select=Backspace, Directional=arrow keys, fullscreen=Alt+Return, power off=Esc. The README documents how the emulator handles save files and mentions tools to disassemble generated JIT code (objdump with the binary format produced by DynASM/JIT temp files).
Debugging and inspecting JIT output: Enable debug builds to generate /tmp/jitcode* output. The README suggests disassembling those files with an objdump command (for example: objdump -D -b binary -mi386 -Mx86-64 /tmp/jitcode?). This is useful when studying generated machine code and JIT behaviour.
Limitations and portability: The project explicitly states it only works on GNU/Linux due to ABI compatibility. Porting to other OSes or CPU architectures would require addressing DynASM/LuaJIT usage and any platform-specific assumptions. Some cartridges with extra hardware or unusual mappers may not behave correctly; the README and issue tracker mention cartridge-specific problems and audio issues in some cases.

Software reminder: jitboy is GPLv3-licensed source code. It does not include commercial ROMs, BIOS, or firmware; obtain those files through legal means if you want to run commercial titles. The project depends on SDL2 and DynASM/LuaJIT components as documented in the repository.