bsnes is a multi-platform Super Nintendo / Super Famicom emulator with an integrated Game Boy core (SameBoy) used for Super Game Boy support and also buildable as a standalone or libretro core. The desktop frontend in target-bsnes loads ROMs, applies BPS/IPS patches, manages save states and rewind, records movies, provides cheat search/editing, maps input, and applies video shaders. The emulation layer in bsnes/sfc is extensive: cycle-accurate CPU/PPU/DSP/SMP, a high-performance alternate PPU, and a broad collection of coprocessor emulations (SA-1, SuperFX, CX4, DSP-1/2/4, SPC7110, SDD1, MSU1, and others). ROM identification is heuristic and normalized into manifests, after which CPU, coprocessor, and PPU threads are synchronized to produce frames, with audio/video/input isolated behind the ruby driver layer.
PCem is a vintage IBM PC/XT/AT/386/486/Pentium emulator that prioritizes hardware-level accuracy over performance. It emulates a vast range of CPUs (8088 through Pentium II, K6, Cyrix), chipsets (Intel 430/440 series, VIA, SiS, OPTi, etc.), video cards (CGA, EGA, VGA, SVGA, Voodoo 1-3, ATI Mach64, S3 Virge, and many more), sound cards (AdLib, Sound Blaster, Gravis Ultrasound, AWE32, OPL, reSID, etc.), storage controllers (IDE, SCSI, MFM, floppy), and networking (NE2000, SLiRP). The emulator uses a dynamic recompiler (codegen) with host backends for x86, x86-64, ARM, and ARM64 to achieve usable performance on modern hardware. It provides two parallel GUI frontends (wxWidgets and Qt), both using SDL2 for video and input, and supports a plugin system for extending emulated hardware. The codebase is written primarily in C with some C++ components, built with CMake and Clang, and targets Windows, Linux, and macOS.
EmuTOS is a complete, GPL-licensed replacement operating system for Atari ST/TT/Falcon, ColdFire, and Amiga computers. It reimplements the entire TOS stack: BIOS (hardware drivers, boot), GEMDOS (file system, process management), VDI (graphics primitives), AES (windowing and event management), a desktop environment (EmuDesk), and a command-line interpreter (EmuCON2). The codebase is highly modular with clear layer separation, extensive conditional compilation for over a dozen hardware variants, and a build system that generates ROM images for each target. It is not a traditional application but a firmware ROM; however, from a software engineering perspective, it exhibits application-like structure with entry points (startup.S, biosmain, gem_main), a GUI, and a CLI. The system is actively maintained, with a rich history of reverse-engineering Atari TOS behavior and fixing emulator quirks. It relies on a 68k/ColdFire cross-compiler toolchain and GNU Make.
Peanut-GB is a high-speed, portable Game Boy (DMG) emulator library implemented as a single C99 header file (peanut_gb.h). It provides a complete emulation core including CPU, memory, LCD, cartridge (MBC1/2/3/5), RTC, serial link, and boot ROM support. The library is designed for easy integration into other projects via a callback-based architecture where the frontend provides ROM read, RAM read/write, error handling, and optional LCD line drawing and audio callbacks. The repository includes multiple example frontends demonstrating integration with SDL2 (full emulator with audio and controls), MiniFB (minimal X11 framebuffer), a debug CLI, a Nuklear-based GUI debugger with disassembler and VRAM viewer, and a benchmark tool. A test suite using the minctest.h framework runs Blargg's CPU instruction and timing tests as well as the dmg-acid2 LCD hash test. The library is MIT-licensed and has been used in several real-world projects (Pico-GB, CPBoy, PlayGB). While the core is well-crafted and portable, known inaccuracies exist (line-by-line LCD rendering, audio timing) and some features are incomplete (MBC6/7, camera). The build system is fragmented across Makefiles and CMake, and some examples have version drift in vendored dependencies.
Prog8 is a Kotlin/JVM compiler and language toolchain for retro 8-bit/16-bit platforms (C64, C128, CX16, PET32, Amiga, m68k). It compiles a high-level language to 6502/68000 assembly through a multi-stage pipeline: lexer/parser, AST construction, semantic analysis, intermediate representation, optimizer, code generation, and optional VM execution. The repository also includes an LSP server, a Gradle build with Kotest tests, CI workflows, and target-specific runtime libraries. It is primarily an application (compiler/CLI), not a data/research project.
This repository is a clean-room, portable reimplementation of Apple Macintosh System 7.1, targeting bare-metal x86, ARM (Raspberry Pi), and PowerPC hardware. It is a monolithic kernel that emulates the classic Mac OS Toolbox API, including subsystems such as the Event Manager, Window Manager, Menu Manager, Dialog Manager, QuickDraw, Font Manager, File Manager (HFS), and a Finder-like desktop environment. The codebase is written in C and assembly, with a hardware abstraction layer (HAL) for platform-specific drivers (USB, storage, timers, framebuffer). It boots via GRUB2 (x86) or custom bootloaders (ARM, PPC) and includes built-in applications like SimpleText and MacPaint. The project is explicitly a reverse-engineering effort based on public documentation and ROM analysis, with many subsystems partially implemented or stubbed. It is not production-ready but demonstrates deep knowledge of Mac OS internals and provides a foundation for running classic Mac software on modern hardware.
This repository is a clean-room reimplementation of the C64/C65/MEGA65 system ROMs, written primarily in 6502 assembly. It produces binary ROM images (e.g., `mega65_orfont.rom`, Kernal/BASIC ROMs) that can be flashed to hardware or used in emulators. The codebase is organized as a firmware source tree rather than a runtime application: `src/` contains the ROM source, `tools/` contains C/C++ utilities for verification and constant generation, and `testsuite/` contains TAP/D64 disk and tape images used as regression fixtures. The build is driven by platform-specific `config_*.s` files that select memory models and feature sets. It implements standard system software: a Kernal jump table, BASIC interpreter, machine-code monitor, keyboard scanner with debounce/repeat, tape/disk I/O, and a Z80 VM for CP/M compatibility. The project uses clean-room methodology: a similarity tool compares the new ROMs against original ROMs to detect accidental copying, and floating-point constants are generated from documented values rather than disassembled code. The test suite validates tape loading and disk access using standard `.tap` and `.d64` formats. Maintenance is active, but the codebase shows some internal drift: many `config_*.s` flags are not always consistent, and some modules carry WIP markers. The project is highly specialized to 6502-based retro platforms; most source is not portable outside that niche. However, several tools and patterns (binary similarity checking, code generation from specs, jump-table APIs, self-contained monitor) are reusable in other firmware or emulation projects.
This repository provides an automated system for setting up a VirtualBox VM running Ubuntu 7.10 that hosts the Open Genera 2.0 Lisp machine environment. It uses veewee to create a base box, Vagrant to manage the VM lifecycle, and shell scripts to install required packages, configure network services (NFS, inetd), set up the Lisp machine software, and launch a VNC server for user interaction. The system is intentionally designed to use an old Ubuntu version due to specific X11 requirements of the Lisp machine emulator. The architecture follows a standard provisioning workflow: dependency verification → base box creation → VM provisioning → application-specific configuration. Key entry points include the Makefile (orchestrating the overall process), Vagrantfile (defining VM properties), and provision.sh (handling the majority of setup tasks). The system demonstrates good practices in idempotent operations, dependency checking with helpful error messages, and clean separation of concerns. While highly specialized for this particular legacy software environment, the repository contains several well-executed patterns that could be adapted elsewhere: the VNC startup script shows proper technique for configuring X resources, remapping keys, and launching applications in a VNC session; the provisioning script demonstrates idempotent setup patterns; and the Makefile provides a reusable model for dependency verification and step-by-step orchestration of complex setup procedures.