nickkossolapov/fame-boy

Fame Boy is a Game Boy (DMG) emulator written in F\# that provides both a native desktop application and a browser-based client for playing ROMs. It features a zero-dependency core that emulates the CPU, PPU, APU, and memory controllers, synchronized to accurately reproduce video and audio output. The system includes comprehensive testing for hardware components and instruction sets, along with dedicated benchmarking tools to measure performance across native and web targets.

8 changes.

This period focused on the initial release of the Fame Boy Game Boy emulator, establishing the zero-dependency F\# core with full CPU, PPU, and APU hardware emulation. It also introduced the native Raylib desktop frontend and the browser-based web frontend, supported by comprehensive unit and integration tests to verify instruction accuracy and system behavior.

4 changes.

This period focused on expanding the FameBoy ecosystem with a new web-based Game Boy emulator featuring a responsive UI and audio support, alongside a comprehensive benchmarking suite for performance measurement. Development also included adding extensive test coverage for MBC cartridge controllers to ensure correctness of bank switching and RTC handling.

A new web benchmarking project has been added to measure emulator performance. This tool loads Game Boy ROMs (flag.gb, roboto.gb, merken.gb) and runs CPU cycle simulations to calculate frames per second (FPS) and mean execution time, providing a standardized way to evaluate emulator speed across different test cases.

src/FameBoy.Benchmark.Web · high confidence

A new benchmark project has been added to measure the performance of the FameBoy emulator using BenchmarkDotNet. The suite includes specific benchmarks for different ROM types (Flag, Roboto, and Merken) to evaluate execution speed with and without MBC support, and provides a custom FPS column to report frames per second based on DMG CPU cycle timing.

src/FameBoy.Benchmark · high confidence

The CPU executor module now includes implementations for arithmetic, bitwise, control, load, and logic instructions. This adds support for operations such as addition, subtraction, bitwise shifts and rotations, conditional jumps, memory loads/stores, and logical AND/OR/XOR, enabling the emulator to execute a broader range of Game Boy CPU instructions.

src/FameBoy/Cpu/Executors · high confidence

The CPU emulation core in src/FameBoy/Cpu has been implemented from scratch, providing the foundational execution engine for the emulator. This includes the complete opcode decoding logic in Opcodes.fs, the CPU state management (registers, flags, program counter, stack pointer) in State.fs, and the instruction execution pipeline in Execute.fs. The implementation covers all standard Game Boy CPU instructions, including arithmetic, bitwise, logic, load, and control operations, as well as proper handling of interrupts and the HALT state. The code is structured into modular executor modules (Arithmetic, Bitwise, Control, Logic, Load) to manage the complexity of the instruction set.

src/FameBoy/Cpu · high confidence

This change introduces the foundational hardware emulation components for the Game Boy, including the CPU, PPU (with background, window, and sprite rendering), APU (four-channel sound with filters), memory management (MBC1, MBC3, MBC5), and I/O (joypad, timer, serial). It establishes the main emulation loop that synchronizes CPU, PPU, and APU cycles, enabling the execution of Game Boy ROMs with basic audio and video output.

src/FameBoy · high confidence

The repository is initialized with the Fame Boy Game Boy (DMG) emulator, featuring a zero-dependency F\# core, a native desktop frontend using Raylib, and a browser-based frontend built with Fable and Vite. The project includes comprehensive documentation, an MIT license, CI workflows, and dedicated projects for unit/integration testing and performance benchmarking for both native and web targets.

(repo-wide) · high confidence

This change introduces the initial implementation of the Fame Boy emulator frontend using the Raylib library. It provides a complete user-facing application that loads Game Boy ROM files, renders the video output to a window, and handles input via a default QWERTY keyboard mapping (WASD for D-pad, K/J for buttons). The emulator includes an audio subsystem with dynamic resampling to 48kHz, a configurable display scale, and a debug view that visualizes the background map and tile data when a debugger is attached.

src/FameBoy.Raylib · high confidence

A new web client has been added to run the Game Boy emulator in the browser. It features a responsive, retro-styled UI with on-screen D-pad and buttons, keyboard support (WASD, J, K, N, B), and a mute toggle. Audio is handled via the Web Audio API with a sliding-window mute to suppress noise when the tab is out of focus. Users can load ROMs via file upload or use the bundled demo game (Tobu Tobu Girl Deluxe). The view includes an FPS counter, a scale selector (0.5x–2x), and respects the system's dark mode preference.

src/FameBoy.Web · high confidence

Added comprehensive instruction-level unit tests for the CPU emulator; Added tests for MBC1, MBC3, and MBC5 cartridge controllers; Added unit and integration tests for Game Boy emulator core components.

The core emulator library has been upgraded from .NET 9 to .NET 10 and converted from an executable to a library, enabling reuse across new project types. A new .NET 10 benchmark project has been added using BenchmarkDotNet 0.15.8 to measure performance, and a new web-based benchmark project has been introduced using Fable.Core 5.0.0-rc.1. The existing web project has been updated to use Fable.Core 5.0.0 and Vite 8.0.0, while the Raylib renderer now targets .NET 10 and uses Raylib-cs 7.0.2. The test suite has also been updated to target .NET 10 and uses NUnit 4.2.2.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 70 → 70 (+0.7)
• Rubric changed (rubric-2026.09.13 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 95 → 95 (-0.0)
• Architecture 91 → 94 (+3.4)
• Maturity 76 → 76 (+0.0)
• Readiness 65 → 65 (+0.0)
• Security 70 → 78 (+7.2)
• Accessibility 70 → 70 (+0.0)
• Performance 80 (new)

• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)

• No test project references FameBoy.Benchmark.Web (src/FameBoy.Benchmark.Web/FameBoy.Benchmark.Web.fsproj)
• No test project references FameBoy.Raylib (src/FameBoy.Raylib/FameBoy.Raylib.fsproj)
• No test project references FameBoy.Web (src/FameBoy.Web/FameBoy.Web.fsproj)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

nickkossolapov/fame-boy was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.