thehardwarestore.ai

ClassiCube is a cross-platform voxel-based sandbox game engine inspired by Minecraft Classic. It features a modular architecture with clear separation of concerns between rendering, input, audio, networking, world management, and game logic systems. The engine supports an extensive range of platforms from modern desktop and mobile systems to legacy consoles like PS1, PS2, Dreamcast, GBA, and many others through platform-specific implementations behind common abstractions. Key features include block placement/breaking, inventory management, chat system, texture packs, lighting (classic and fancy modes), entity rendering, and multiplayer networking.

This repository is a complete, annotated disassembly of the original Game Boy Pokémon Red and Blue games. It faithfully reproduces the exact ROM images (verified by SHA1 hashes) using the RGBDS assembler toolchain. The codebase is organized into modular subsystems: engine (battle, overworld, events, items, menus), data (maps, Pokémon stats, moves, items, trainers, wild encounters), audio (music and SFX with a macro-based composition language), graphics (sprites, tilesets, fonts), and scripts (map-specific event scripts). It includes custom C tools for graphics optimization, compression, and Virtual Console patch generation. The architecture is a monolithic ROM image with bank switching, using a predef dispatch system for cross-bank calls. Key entry points include the game start routine in home/start.asm and the VBlank handler in home/vblank.asm. This is a high-quality reverse engineering project with extensive comments, consistent coding patterns, and a robust build system, making it an invaluable resource for ROM hacking, retro game development, and studying Game Boy internals.

DevilutionX is a modern C++ source port of the 1996 action role-playing game Diablo and its Hellfire expansion. It is a monolithic game engine that reimplements the original game's logic, rendering, audio, and networking from scratch, requiring the original game data files (DIABDAT.MPQ or spawn.mpq) to run. The architecture is highly cross-platform, targeting modern desktops (Windows, Linux, macOS), consoles (PS4, PS5, Switch, Xbox, Vita, 3DS), retro platforms (Amiga, DOS), and embedded devices (Miyoo Mini, OpenDingux), all managed through a sophisticated CMake build system. The codebase is data-driven, loading game content (monsters, items, spells, levels) from tab-separated value (TSV) files and original MPQ archives. It features a robust Lua scripting engine for modding, a comprehensive input abstraction layer supporting keyboard, mouse, gamepad, and touch, and a modular networking stack supporting TCP and ZeroTier P2P multiplayer. The project maintains an extensive test suite using GoogleTest and GoogleBenchmark, including deterministic dungeon generation tests and performance benchmarks. While the codebase exhibits tight coupling inherent to game engine development and carries significant platform-specific conditional compilation (#ifdef sprawl), it contains several high-quality, isolated utility components that are safely reusable. These include a robust INI parser, a fixed-capacity static vector, endian-safe I/O helpers, an A* pathfinding implementation, and a KD-tree for color quantization. The code is written in modern C++ (C++17/20 style) with pervasive use of std::expected for error handling, demonstrating strong engineering practices despite the complexity of its domain.

Cemu is a cross-platform Wii U emulator written in C/C++. It emulates the PowerPC-based Espresso CPU and Latte GPU via a dynamic recompiler (IML) and interpreter, and provides high-level emulation (HLE) of Wii U operating system libraries (coreinit, GX2, nn_*, etc.). The architecture is a monolithic desktop application with a wxWidgets GUI, multiple graphics backends (Vulkan, OpenGL, Metal), audio backends (Cubeb, XAudio2, DirectSound), and an abstract input layer supporting various controllers. The core emulation loop loads Wii U game images (WUD, WUX, WUHB), parses RPL modules, and translates PowerPC instructions into native code while rendering graphics via Vulkan/OpenGL/Metal. The codebase also includes a GDB stub for debugging, per-title game profiles, graphic packs for patches, and network service stubs (Miiverse, NIM). It is actively maintained with regular commits and vibrant community contributions.

Retrom is a self-hosted game library manager and emulation frontend that lets users manage their DRM-free game collection across devices. Its server component (Rust, gRPC, REST, WebDAV) handles library scanning, metadata enrichment (IGDB, Steam), cloud save synchronization (Ludusavi, WebDAV), and emulator configuration. The desktop client (Tauri) and web client (React, TanStack Router) provide a unified interface with both windowed and fullscreen modes, including in-browser emulation via EmulatorJS. The architecture follows a monorepo structure with well-separated packages for the database layer (Diesel/PostgreSQL), gRPC service handlers, UI components, and Tauri plugins, enabling reuse and independent development.

Nostalgist.js is a TypeScript library that provides a simplified API for running retro console emulators in web browsers using RetroArch compiled via Emscripten. It handles the complex setup of Emscripten modules, virtual file systems, and RetroArch configuration, allowing developers to launch games with minimal code. The library supports a wide range of consoles (NES, SNES, Game Boy, etc.) with sensible defaults for loading cores and ROMs from CDNs, while also allowing custom resolvers. It includes features like save/load states, SRAM management, screenshot capture, and programmatic input control. The codebase is well-structured with strong TypeScript types, comprehensive tests (integration and e2e), and a clean class hierarchy. Notable highlights include a flexible file resolution system that handles various input formats (URLs, Blobs, ArrayBuffers, etc.) and a clever patching mechanism for importing Emscripten modules as ES modules.

DIJI-NES is a high-performance NES (Nintendo Entertainment System) emulator designed to run on the ESP32-S3 microcontroller. It emulates the 6502 CPU, PPU graphics, and APU audio with cycle-level accuracy, supporting mappers 0-4 (NROM, MMC1, UxROM, CNROM, MMC3). The system renders 256x240 pixel frames at near-60 FPS to an ST7789 display via LovyanGFX and outputs audio through an I2S DAC (MAX98357A). It features a dual-core architecture: Core 0 handles audio generation and display DMA, while Core 1 runs the emulation loop. The firmware includes a ROM browser menu, save/load state support, volume control, and a particle boot animation. The codebase demonstrates deep NES hardware knowledge and aggressive optimization for embedded systems, including IRAM placement, lookup tables, bank caching, and frame-skip logic. While the main application is tightly coupled to the ESP32-S3 platform, the core emulation components (CPU, PPU, APU, cartridge) are well-isolated and could be extracted for reuse in other NES emulation projects.

pacman.zig is a faithful recreation of the classic Pacman arcade game implemented in the Zig programming language. It uses the Sokol cross-platform libraries for graphics, audio, and input handling, allowing it to run as a native desktop application or be compiled to WebAssembly for browser play. The game implements all original Pacman mechanics including Pacman movement, ghost AI with distinct behaviors for each ghost, dot and pill eating, bonus fruits, sound effects, score tracking, and level progression. The architecture follows a monolithic design with clear separation of concerns into game state management, game logic, rendering, audio, and input systems. Despite being contained primarily in a single source file, the code is well-organized with distinct sections for different subsystems. The implementation demonstrates attention to detail in replicating the original game's behavior and performance characteristics.

RetroAssembly is a full-stack web application for self-hosting a personal retro game collection and playing it directly in the browser via emulation. It provides a complete library management system for ROMs, save states, favorites, and launch history, with a rich UI built on React 19, Radix UI, and Tailwind CSS 4. The backend uses Hono with Drizzle ORM and SQLite (Node.js) or Cloudflare D1 (Workers), with file storage abstracted for local filesystem or Cloudflare R2. Emulation is powered by Nostalgist.js using libretro cores, supporting dozens of platforms with per-platform core options, BIOS validation, shaders, rewind, and auto-save. The app features multi-user accounts with shared library mode, keyboard/gamepad navigation via spatial navigation, a virtual gamepad for touch devices, internationalization with 12 languages, and a Docker-first deployment model. The architecture is dual-runtime (Node.js or Cloudflare Workers), with a Vite-based build system and pnpm workspaces. While the codebase is well-structured and demonstrates strong engineering patterns, it carries medium technical drift due to pinned CDN commit hashes, patched third-party packages for SSR compatibility, and the complexity of maintaining dual runtimes.

This repository implements a cycle-accurate NES/Famicom console on FPGA, targeting the MiSTer platform. The core is written in Verilog/SystemVerilog with some VHDL, integrating a 6502 CPU (T65 core), PPU with composite video output, APU with expansion audio support, and dozens of cartridge mappers (MMC1-5, VRC1-7, FDS, Namco163, Sunsoft, etc.). It provides a complete hardware video/audio pipeline including scanlines, gamma correction, scandoubling, HQ2x scaling, and HDMI output. The system supports save states, cheat codes, zapper light gun, multiplayer adapters, and the Family BASIC keyboard. The codebase is well-structured with a modular mapper interface and a generic savestate bus pattern, though it is tightly coupled to the MiSTer platform (Cyclone V FPGA, HPS interface). It is an actively maintained core in the MiSTer ecosystem, with frequent releases and community contributions.

Yamagi Quake II is a conservative source port of id Software's Quake II, focusing on offline and cooperative gameplay while maintaining compatibility with the original game data. The codebase implements a full client-server architecture with multiple rendering backends (OpenGL 1.x, OpenGL 3.x, software), OpenAL/SDL sound, input handling (keyboard, mouse, gyro), and network protocols. The game logic includes complete monster AI, weapons, items, and multiplayer support. The project is written in C and organized into client, server, game, and common modules, with platform-specific backends for Unix and Windows. It is GPLv2 licensed and community-driven.

Starship is a source port of Star Fox 64 (Lylat Wars) for modern platforms including Windows, macOS, Linux, and Nintendo Switch. It requires a legal copy of the original Nintendo 64 ROM (version 1.0 or 1.1 in .z64 format) to extract assets and run. The project reimplements the Nintendo 64's libultra SDK and game engine systems while adding modern enhancements such as mod support via OTR/O2R asset files, configurable graphics backends (OpenGL/DirectX/Metal), debugging tools, and quality-of-life features. The architecture centers around a cross-platform porting layer (libultraship) handling windowing, input, and rendering, with core game logic in src/engine/ and src/overlays/ managing game state, rendering, audio, and input. Key systems include a resource factory pattern for asset importing, an event-based communication system, audio heap management with caching, and an ImGui-driven UI for runtime configuration and mods.

This repository is a curated 'awesome list' for Game Boy and Game Boy Color development — a community-maintained directory of resources rather than a software application. Its production function is curation: organizing and continuously validating links to documentation (Pan Docs, opcode references, hardware schematics), emulators (SameBoy, mGBA, BGB), development toolchains (RGBDS, GBDK), homebrew games, and reverse-engineering projects. The main README.md is meticulously organized into roughly 15 categories, with EMULATORS.md and MORE.md serving as supplementary lists for open-source emulators and lower-tier resources respectively. The contribution guidelines (CONTRIBUTING.md) define a clear triage process between the main list and MORE.md, establishing quality gates for what qualifies as 'awesome'. The only executable code is the GitHub Actions CI workflow (.github/workflows/ci.yml), which runs two validation jobs: awesome-lint (installed from a custom fork, gbdev/list-linter) to enforce markdown formatting standards, and brok (a dead-link checker) to detect broken URLs across all markdown files. The workflow runs on push, pull request, a weekly schedule, and manual dispatch, and it deliberately ignores tcrf.net due to that site's DDoS protection — a thoughtful, reusable pattern for any awesome-list maintainer. The repository also ships CartridgeList.csv, a structured dataset cataloging thousands of Game Boy cartridge dumps with columns for mapper type (MBC1/MBC3/MBC5/RUMBLE/CAMERA/etc.), ROM size, RAM size, battery presence, RTC presence, and game title — a valuable reference for emulator developers, cartridge hardware projects, and ROM preservation efforts. Maintenance is active: the last commit is recent, the CI pipeline runs on a weekly schedule, and the community is engaged (4,497 stars, 21 open issues, active Discord). The repo is the de facto canonical starting point for Game Boy development. While it contains no application code in the traditional sense, its curation quality, CI infrastructure, and reference data make it a high-value, well-maintained resource.

RetroMultiTools is a cross-platform desktop application built with Avalonia (.NET 8) that serves as a comprehensive utility suite for retro gaming enthusiasts. It provides a unified interface for ROM management, including browsing, inspection, patching (IPS/BPS/xDelta), format conversion (N64 byte order, CHD, archive extraction), verification (CRC, MD5, SHA, DAT file validation, dump quality checks), and emulator configuration for RetroArch, MAME, Mednafen, and Analogue consoles. The application also features a gamepad key mapper, disc burning and USB imaging tools, cheat code conversion across 23 systems, remote file transfer (FTP, SFTP, WebDAV, S3, cloud storage), and a self-updater. It supports 20 languages and runs on Windows, Linux, macOS, and FreeBSD, with Flatpak packaging available. The architecture is a monolithic desktop application with a sidebar navigation tree that loads over 40 distinct views, each backed by a code-behind file and often a static utility class. The core pattern is event-driven UI with async operations using IProgress<string> and CancellationToken for long-running tasks. Localization is handled via a singleton LocalizationManager that binds to XAML controls. Settings are persisted as JSON via AppSettings. The application integrates with external tools (chdman, DolphinTool, cdrecord, dd) and libraries (SDL2, SharpCompress, FluentFTP, SSH.NET, AWS SDK) for platform-specific functionality. Key strengths include a consistent async progress pattern across all tools, reusable utility classes for file operations, path validation, and drag-and-drop, and deep format knowledge for retro gaming file formats. The codebase demonstrates solid engineering practices for a desktop utility, though it suffers from some monolithic view files and hardcoded data that could benefit from modularization. No unit tests are visible, and the large feature surface introduces maintenance overhead.

This repository implements a Field-Programmable Gate Array (FPGA) based emulator for Nintendo Game Boy and Game Boy Color systems, specifically targeting the Analogue Pocket handheld console. The design consists of hardware description language (Verilog/VHDL) modules that replicate the original hardware components including a Z80-compatible CPU core (T80), memory controllers, video display subsystem, four-channel audio processing unit, input handling, cartridge interface with various Memory Bank Controller (MBC) implementations, save state functionality, and real-time clock support. The architecture follows a modular approach with clear separation of concerns between subsystems, interconnected through well-defined interfaces. The project demonstrates significant effort in achieving hardware-level accuracy while incorporating modern features like save states, fast forwarding, and custom palettes. While the codebase shows signs of active maintenance and ongoing development, it remains tightly coupled to the target FPGA platform (Cyclone V) and associated Intel/Altera toolchain, which limits immediate portability to other hardware platforms.

This repository is an unofficial fork of J2ME-Loader, a Java ME (J2ME) emulator for Android. It enables running MIDlets (Java ME applications) on Android devices by implementing J2ME APIs (LCDUI, M3G, MMAPI, etc.) and using native C++ components via JNI for performance-critical sections like 3D rendering (M3G) and audio synthesis (Sonivox, TSF). The emulator includes a user interface for browsing and launching MIDlets, configuring settings, and handling permissions. It also features a dex manipulation library (dexlib) for processing DEX files to ensure compatibility with Android ART. While the emulator is functional and demonstrates solid engineering practices, it shows signs of technical drift due to deprecated Android APIs and a forked dex library that may lag behind upstream, and maintenance appears stale based on commit frequency.

PinMAME is a specialized fork of MAME 0.76 that emulates the hardware found in solid-state pinball machines. It supports over 2700 ROM sets from Williams, Bally, Stern, Gottlieb, Data East, and other manufacturers. The emulator is delivered in multiple forms: a standalone command-line executable (Unix/Windows), a Windows GUI (PinMAME32), a COM DLL (VPinMAME) for integration with Visual Pinball and other simulators, a lightweight library (libpinmame) for embedding in other applications, and hardware control interfaces (LISY, P-ROC) for driving real pinball machines. The codebase includes CPU emulators (Z80, 6809, 6502, i86, TMS9900, ARM7, etc.), sound chip emulators (YM2151, YM3812, SAA1099, TMS5220, etc.), and pinball-specific subsystems (WPC, System 11, Pinball 2000). It also features a remote debugger with an embedded HTTP server and SSE event streaming, an alternative sound system (altsound) for custom audio, and a cheat engine. The architecture is monolithic with platform-specific frontends, heavily reliant on the MAME core framework. While functional and actively maintained, the codebase shows its age with legacy platform drivers, vendored external libraries, and tight coupling between components.

This repository is a web-based application that serves as a museum and emulator for Chinese-developed retro games. It provides browser-based emulation for various platforms including NES/Famicom clones, Sega Genesis, Super A'can, and numerous handheld consoles (Gamate, SuperVision, Mega Duck, GameKing, etc.). The application consists of HTML/CSS/JavaScript files that load game data from JSON files and run appropriate emulator cores (JSNES for NES, Emularity/JSMESS for other systems) to allow users to play games directly in the browser. The architecture is client-side only, with responsive design for mobile and desktop access, featuring game browsing interfaces with search and pagination functionality.