arm_asm_emu

GAME BOY COLOR EMULATOR

arm_asm_emu

A Game Boy / Gameboy (DMG/CGB) emulator implemented in ARM assembly, focused on correctness of CPU and timing tests with a Linux-oriented, minimal interface set.

Jump to download ↓Jump to setup guide ↓

arm_asm_emu emulator screenshot.

game boy colorPRIMARY SYSTEM

History documentedPROJECT BEGAN

Open sourcePROJECT MODEL

WHY IT MATTERS

Why this project exists

A compact, hand-written ARM-assembly implementation of a Game Boy emulator — created as an exercise in low-level programming and accuracy rather than as a full-featured desktop emulator.

BEST FOR

What it does well

Highly focused CPU and timing correctness: the repository documents passing Blargg test suites (cpu_instrs and multiple timing tests). The codebase is self-contained, BSD-3-Clause licensed, and designed to build natively on ARM or via cross-compilation and to run under QEMU for testing.

The people behind arm_asm_emu

History & status

The repository contains active development history and a testing harness oriented around automated Blargg tests and bitmap CRC checking. It is a source-first project (assembly sources, Makefile, tests) rather than a packaged end-user emulator. Sound is explicitly not implemented and the supported runtime interfaces are minimal (null, Linux framebuffer, bitmap capture for graphics; null and Linux evdev for controls). The project is published on GitHub and distributed under BSD-3-Clause. The repository shows ongoing commits and an issues page; overall the project is best described as an open-source, developmental emulator implementation rather than a polished multi-platform player.

What arm_asm_emu supports

Game Boy / Game Boy Color (SM83 CPU compatibility; project targets Game Boy hardware behaviour)
Linux framebuffer graphics output
Bitmap output (capture)
Linux evdev input
Native ARM or cross-compiled builds; tests runnable under QEMU

Download and availability

OFFICIAL DOWNLOADS

Get arm_asm_emu

Official source and releases are published on the project's GitHub repository and its Releases page. Build from source using the provided Makefile; no commercial games, firmware, or BIOS are included.

Get arm_asm_emu ↗

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.

arm_asm_emu setup guide

Setup note: This guide explains how to obtain, build, and run arm_asm_emu from source using the repository's Makefile. It assumes a Linux host (x86_64 or ARM) and familiarity with make, a cross-toolchain (if cross-compiling), and basic permissions for accessing /dev/fb or evdev when using native framebuffer/evdev backends.

1) Get the source: Clone the official GitHub repository (use the URL in Sources). Optionally download a release archive from the repository's Releases page if present.
2) Prerequisites: Install a toolchain: for native ARM builds use a native ARM host or an ARM cross-compiler (example: arm-none-eabi- toolchain). For running tests on non-ARM hosts, install QEMU's arm user emulation (qemu-arm). You will also need make, a POSIX shell, a C compiler for test harness glue if used, and standard build utilities (binutils/ld/objcopy as required by the Makefile).
3) Build (native or cross): From the repository root run make. To cross-compile, pass CROSS to make, for example: make CROSS=arm-none-eabi-. The Makefile is prepared to support native ARM builds or cross-compiling using the specified CROSS prefix.
4) Run tests (optional): The repository includes a test harness which runs ROMs for a set number of cycles and validates a CRC32 of the framebuffer output against expected values. On non-ARM hosts you can run: make test TEST_WRAPPER=qemu-arm to execute tests under qemu-arm (adjust wrapper to your qemu binary). The harness will save a .bmp capture if a test fails.
5) Running the emulator: The code supports minimal runtime interfaces. To run the emulator with a framebuffer backend on Linux you will typically need appropriate permissions for /dev/fb*. Alternatively the bitmap capture backend can be used to produce screen captures instead of writing to the framebuffer. Input via Linux evdev requires reading from /dev/input/event* and appropriate permissions.
6) Tips and limitations: Sound is not implemented. Expect a development-oriented environment: the emulator is assembly source with a test-first approach. If you need a GUI, audio, or broad cartridge compatibility, prefer mature emulators (SameBoy, Gearboy, GBCC, etc.) and use this project for study, experimentation, or embedded ARM-targeted uses. Do not expect included ROMs, BIOS, or commercial game content in the repository.

Software reminder: This project compiles and runs from source. You may need root or group permissions to access Linux framebuffer or evdev devices. The repository's tests require ROM images (Blargg test ROMs) which are not included; obtain them from their original authors if you plan to run the test suite.