thehardwarestore.ai

The Obtainium Emulation Pack is a curated collection of Android app configurations for the Obtainium updater tool, focused on emulation, frontend utilities, and related tools. It processes a sparse JSON definition file (src/applications.json) through a pipeline of Python scripts to generate two variant-specific JSON files (standard and dual-screen) that users import into Obtainium for automatic app updates. The architecture centers around a Justfile task runner orchestrating validation, normalization, documentation generation, and minification scripts. Key features include sparse settings storage (only non-default values), variant inclusion flags for dual-screen compatibility, automated live testing of update sources, and scheduled CI workflows that detect and report breakages via GitHub issues. The system emphasizes ease of setup: install Obtainium, import the JSON, and receive updates for over 100 curated apps.

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.

shadPS4 is a PlayStation 4 emulator for Windows, Linux, and macOS, written in C++20. It emulates the PS4's AMD GCN GPU via a custom shader recompiler that translates GCN instructions to SPIR-V, and implements high-level emulation (HLE) of PS4 system libraries (kernel, libc, networking, audio, video, input, etc.). The architecture is monolithic with modular subsystems: a Vulkan renderer with texture/buffer caches, a shader recompiler with IR optimization passes, a file system abstraction supporting host files and ZArchive, and an ImGui-based debug UI. While many library functions are stubbed or partially implemented, the core GPU and CPU emulation is functional enough to run several commercial games. The codebase demonstrates strong engineering practices with reusable common utilities (bitfields, slot containers, thread-safe queues) and a well-structured shader compilation pipeline. It is a hybrid project, combining software application development with significant reverse-engineering and data analysis of PS4 firmware and GPU architecture.

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.

This repository is Xilinx's fork of QEMU, a full-system and user-mode emulator/virtualizer. It provides machine emulation via dynamic binary translation (TCG) and hardware acceleration through KVM, Xen, HVF, and other accelerators. The codebase includes a vast array of device models (CPUs, interrupt controllers, storage, network, graphics, timers, etc.), a block layer for storage backends, live migration for VM state transfer, and QMP/HMP monitoring interfaces. The architecture is highly modular with the QEMU Object Model (QOM), coroutine-based async I/O, and a plugin API. It also supports user-mode emulation for Linux and BSD syscalls. This is purely an application repo; there is no data science or research code. The Xilinx fork adds extensive device models for Xilinx FPGAs and SoCs (Versal, ZynqMP, etc.), making it especially relevant for embedded developers. The code is actively maintained with recent commits and issue triage, and while the sheer size introduces some technical debt, the overall engineering quality is high.

WiiUDownloader is a cross-platform desktop application written in Go that downloads Wii U games, updates, DLC, and demos directly from Nintendo's CDN servers. It is the primary open-source replacement for the abandoned Wii U USB Helper. The application provides a GTK3-based GUI (via gotk3) on all three major platforms, with a command-line core library. Key features include automatic decryption using embedded common keys and title keys derived from PBKDF2, resume-capable downloads with SHA-256 segment verification via a journal file, hash-tree validation for hashed content, FST/U8 archive extraction, and a queue-based batch download system. The architecture cleanly separates the core download/decryption logic (root package) from the GUI (cmd/WiiUDownloader), with reusable internal format parsers for TMD, FST, and U8. No title keys are required; the system generates tickets and certificates on the fly. The project is actively maintained, with recent commits and CI/CD pipelines producing Windows, macOS, and Linux builds.

This repository contains Pound, a Nintendo Switch emulator focused on emulating Switch 1 and 2 hardware. The emulator features a modular architecture with CPU emulation handled by the Ballistic ARM recompiler for performance, GPU emulation translating Switch graphics commands to host APIs (Vulkan, OpenGL, DirectX, Metal), and SDL-based cross-platform windowing, input, and audio systems. Dear ImGui integration provides debugging and configuration interfaces. The codebase demonstrates careful separation of concerns, with distinct subsystems for memory management, CPU state, platform abstraction, and hardware emulation. Notable engineering practices include the clean interface boundary with the Ballistic recompiler, memory allocation abstraction via a host allocator interface, and platform detection utilities. While the project shows active development and solid engineering, it faces typical emulator challenges including platform-specific maintenance burdens and dependency on external shader translation tools.

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.

Speakeasy is a Windows malware emulation framework developed by Mandiant (FireEye). It executes Windows PE executables, DLLs, drivers, and shellcode in a fully emulated Windows environment, intercepting API calls via a large set of stub handlers that model kernel32, ntdll, ws2_32, user32, ntoskrnl, and many other DLLs. The emulation is powered by Unicorn (CPU emulation) and Capstone (disassembly). It provides both a CLI tool (`speakeasy`) and a Python library (`Speakeasy` class) for programmatic use. Key features include: user-mode and kernel-mode emulation, GDB remote debugging support, configurable file system, registry, network, and process models, SEH handling, API hammering detection, and structured JSON reports with profiling events, memory captures, and artifact deduplication. The architecture is a monolithic Python package with a core emulator class, platform-specific emulators (Win32Emulator, WinKernelEmulator), and a large set of API handler modules organized by DLL. Dependencies include unicorn, capstone, pefile, pydantic, rich, and pyelftools. The project is primarily used for automated malware analysis and reverse engineering.

This is a Nintendo Switch emulator, a direct fork of the defunct yuzu emulator rebranded as 'Citron Neo'. It provides full system emulation through high-level emulation (HLE) of Switch system services, kernel, GPU (Vulkan), audio, and input. The application has three frontends: a desktop Qt GUI, an Android app (Kotlin/JNI), and an iOS app (Swift/Metal). It supports loading Switch game formats (NSP, XCI, NCA), executing ARM code via Dynarmic, and rendering graphics via Vulkan with custom post-processing (FSR, frame interpolation). The codebase is actively developed with additions like frame skipping, a mod manager, performance overlays, and debugger tools, but retains many stub implementations from upstream, indicating incomplete feature coverage. It is primarily a desktop emulator with mobile ports.

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.

vivisect is a comprehensive reverse engineering framework providing static analysis, dynamic debugging, emulation, and symbolic execution capabilities. It consists of several core packages: `envi` (multi-architecture disassemblers, emulators, memory abstraction), `vivisect` (workspace-based static analysis with analysis passes, import emulation, symbolic execution engine), `vtrace` (cross-platform debugging with ptrace/GDB stub support), `vdb` (debugger CLI and Qt GUI), `vstruct` (declarative binary structure parsing for formats like PE, ELF, Mach-O, minidump), `visgraph` (graph layout for control flow and call graphs), and `cobra` (custom RPC framework for remote collaboration). The system can parse and analyze PE, ELF, Mach-O, and other formats; perform function detection, control-flow recovery, switch-case identification, pointer analysis, and symbolic path exploration. It includes a full-featured debugger with breakpoints, watchpoints, and process control, and offers a Qt GUI for interactive reverse engineering. The architecture is modular but tightly integrated; many components are reusable in isolation. The codebase shows signs of long-term evolution with some Python 2/3 drift, deprecated API usage, and incomplete migration to PyQt6, but remains actively maintained with recent commits and a substantial test suite.

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.

Xenia is a research-grade emulator for the Xbox 360, written in C++ with a focus on accuracy and performance. It translates PowerPC (PPC) guest code into x64 machine code via a custom JIT compiler (HIR → x64 backend) and emulates the Xenos GPU using D3D12 and Vulkan backends, including shader translation from Xbox ucode to HLSL/SPIR-V. The system also emulates kernel subsystems (XAM, Xboxkrnl), audio (XMA decoding via XAudio2/SDL), input (XInput, keyboard, SDL), and the virtual file system (STFS containers, disc images, host paths). The architecture is modular with clear subsystem boundaries (base, cpu, gpu, apu, hid, kernel, vfs, ui), each with platform-specific implementations for Windows, Linux, and Android. Key entry points include the main emulator window (xenia_main.cc), the CPU processor (processor.h), the GPU graphics system (graphics_system.h), and the kernel state manager (kernel_state.h). The emulator is primarily a desktop application but includes Android support and several standalone tools for shader compilation, GPU trace analysis, and API scanning.

EKA2L1 is a Symbian OS emulator written in C++17, targeting the EKA2 (and EKA1) kernel used by Nokia S60 smartphones and N-Gage devices. It provides full system emulation including ARM CPU (with multiple backends: dyncom interpreter, 12l1r JIT, and optional Dynarmic), memory management (flexible and multiple address-space models), kernel reimplementation (processes, threads, IPC, timers, libraries), file system, and a wide range of Symbian services (window server, audio, Bluetooth, SMS, camera, DRM, etc.). The emulator supports multiple frontends: a Qt desktop application, an Android app (Java/JNI), and an iOS app (SwiftUI). It also includes a Lua scripting API for runtime debugging and game-specific patches, a GDB stub for remote debugging, and a set of guest-side DLL patches that redirect Symbian hardware calls to the emulator. The codebase is large and complex, with many services partially implemented or stubbed. It is actively maintained but development is part-time, and some platform-specific backends (e.g., iOS, Android) may lag behind the Qt frontend.

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 provides a comprehensive set of scripts, configuration files, and precompiled bootloader components to run macOS as a guest operating system on Linux hosts using QEMU/KVM and the OpenCore bootloader. It is not a traditional application but rather an infrastructure-as-code project that automates the creation of a virtual Hackintosh environment. The codebase includes a Python script (`fetch-macOS-v2.py`) to download macOS recovery images from Apple's servers with cryptographic verification, shell scripts to launch QEMU with the appropriate CPU flags, firmware, and device emulation, and a set of OpenCore EFI binaries (kexts, drivers, ACPI tables, icons) tailored for macOS compatibility. The project also documents GPU passthrough, USB passthrough, kernel debugging, and reverse engineering of macOS VM detection. While the repository is highly popular and actively maintained, the code quality is uneven: many shell scripts are boilerplate-heavy with hardcoded paths, and the prebuilt binaries are opaque, making the project more of a curated recipe collection than a polished software product. The most reusable components are the macOS downloader script and the OpenCore disk image builder, which can be extracted and adapted for other virtualization workflows.

This repository is the build and packaging meta-repo for Hangover, a project that enables running x86 Windows applications on ARM64 Linux by combining Wine with CPU emulators (FEX, Box64). It contains CI workflows (GitHub Actions) that build Wine with ARM64EC support, compile emulator DLLs, and produce Debian/Ubuntu packages. The actual source code resides in submodules (wine, fex, box64). The repository itself is purely infrastructure: Dockerfiles, debian packaging files, and a complex multi-stage CI pipeline. It is actively maintained with regular releases. There are no reusable software components; the value is in the integration and packaging, not in original code.