Projects sharing features with Duckstation

Cemu is a cross-platform game console emulator designed to replicate the Nintendo Wii U hardware environment. It provides a software simulation layer that allows original Wii U games and homebrew applications to run on Windows, Linux, and macOS. The project translates guest machine code and graphics API calls into host instructions and modern shaders to enable hardware acceleration. It utilizes a dynamic recompilation engine and a host-API graphics backend to interface with Vulkan or OpenGL. The system manages hardware simulation through multi-threaded CPU emulation, memory-mapped I/O simula

SimpleNES is a C++ application that simulates original Nintendo Entertainment System hardware to run legacy games on modern computers. It functions as a hardware simulator and retro gaming emulator designed to execute classic game ROMs by recreating the original console environment through software. The system implements a software version of the 6502 CPU and picture processing unit to render retro game video and audio. It recreates 8-bit console architecture to ensure the execution of original game ROMs. The project covers low-level hardware simulation, including cycle-accurate CPU emulatio

RetroArch is a cross-platform emulation host and multi-system game emulator that serves as a frontend for the Libretro API. It coordinates video, audio, and user input to maintain the application state for various emulator cores, allowing it to run a wide variety of vintage gaming hardware and software engines. The platform distinguishes itself through a low-latency emulation model that uses run-ahead processing to reduce input lag. It also features a real-time state tracking system that enables gameplay rewinding by saving periodic snapshots of the emulator memory state. The environment inc

Luma3DS is a custom firmware for the Nintendo 3DS that removes factory restrictions to enable the execution of unsigned homebrew and game modifications. It functions as a kernel-level system extension that hooks system calls to bypass hardware limitations and introduce new operating system capabilities. The project serves as a homebrew payload loader, using boot-time mechanisms to launch third-party software and custom firmware versions. It also provides a game modding framework capable of patching executable code and intercepting file requests to load custom assets and modified data. The en

xemu is a game console emulator and virtual hardware hypervisor designed to execute original Xbox game software on various operating systems. It functions as a disk image player that simulates physical circuitry and storage to enable the playback of original titles. The project includes a suite of low-level system debugging tools for inspecting registers, tracing execution events, and dumping memory from running guest code. It provides specialized capabilities for hardware accuracy testing and game hardware debugging to analyze system behavior. The software covers a broad range of emulation

Xenia is an emulator designed to run Xbox 360 games and applications on modern computer hardware. It enables the execution of console software from disc images, digital downloads, and extracted files, facilitating legacy software preservation on hardware that lacks native support. The project distinguishes itself through high-fidelity graphics enhancements, including the ability to increase internal rendering resolution and apply contrast-adaptive sharpening to restore image clarity. It implements specialized visual techniques such as blue noise dithering to reduce color banding and multisamp

shadPS4 is a C++ game emulator and hardware virtualization tool designed to replicate the PlayStation 4 system environment and hardware to run console software on a computer. It functions as a cross-platform application compatible with Windows, Linux, macOS, and FreeBSD. The project serves as a graphics debugging tool capable of dumping shaders and integrating with rendering tools for performance analysis. It provides a system for recreating the console environment through the import of official firmware files, system fonts, and the use of decrypted keys for tracking game trophies. The emula

Azahar is an open-source, cross-platform emulator that translates Nintendo 3DS hardware calls into system-native operations, enabling computer users to run 3DS games and homebrew software without the original console hardware. Its core identity is defined by being a publicly available emulator that operates across multiple operating systems, providing access to the 3DS library on standard computing platforms. The emulator achieves high-performance emulation through several key technical approaches. It employs a JIT-based CPU core with a dynamic recompilation engine that translates ARM11 and A

Vita3K is a console hardware emulator specifically designed to replicate the PlayStation Vita environment. It functions as a cross-platform game emulator that allows handheld software and homebrew to run on desktop and mobile devices. The project focuses on PlayStation Vita emulation to enable retro game preservation and cross-platform gaming on operating systems such as Windows, Linux, and Android. The emulator implements hardware emulation through a dynamic recompilation engine, firmware-based system call translation, and a GPU hardware abstraction layer. It further simulates the original

Romm is a self-hosted game library manager and ROM management web interface. It serves as a central server for storing and categorizing game files and emulator firmware, providing a web-based browser to organize collections through automated library scanning and metadata retrieval. The project distinguishes itself by integrating a web-based emulator frontend that uses WebAssembly to play games directly in the browser. It further provides a game save synchronization server that uses SSH-based synchronization to transfer save states and progress between the server and registered handheld device

MAME is a vintage hardware emulation platform designed to recreate the circuitry of arcade games, computers, and consoles to run original software on modern devices. It functions as a retro gaming preservation framework for managing, verifying, and archiving ROM sets and disk images to ensure long-term software accessibility. The project features a system debugging tool for inspecting emulated memory, CPU registers, and execution flow via breakpoints and disassembly. It also includes a Lua-based automation layer that exposes core system state and hardware controls for custom behavior and anal

Snes9x is a cross-platform emulator designed to replicate the Super Nintendo Entertainment System hardware. It functions as a gaming tool that allows users to load and play Super Nintendo software on modern hardware and operating systems. The software provides a portable emulation layer across various hardware architectures to ensure consistent performance. It supports the execution of game ROMs while providing utilities for input mapping and save states. The system implements hardware emulation through cycle-accurate CPU emulation, dynamic recompilation, and scanline-based video rendering.

Zelda64Recomp is a native game recompilation project that translates legacy binary machine code into modern machine code. It functions as a native hardware port and a static recompiled binary, executing original game logic directly on modern CPUs and GPUs to run without an emulator. The project serves as a moddable game engine, providing a framework to apply community texture packs and code patches to the recompiled title. It includes native hardware porting capabilities that remove emulator overhead to improve stability and frame rate control. The software covers retro game modernization th

RPCS3 is a C++ application that functions as a software environment for executing and managing PlayStation 3 console titles on desktop operating systems. It operates by translating proprietary console hardware instructions and graphics commands into formats compatible with modern computer hardware, allowing for the execution of original game software. The emulator distinguishes itself through a comprehensive suite of tools for managing game libraries, applying software patches to modify performance characteristics, and tracking the compatibility status of individual titles. It includes integr

melonDS is an open-source emulator that runs original Nintendo DS and DSi games on modern operating systems with high-accuracy hardware simulation. It emulates the DS and DSi CPUs, video, and audio systems, and supports booting from original system firmware for access to the system menu and configuration screens. The emulator distinguishes itself through cycle-accurate component simulation for precise timing and compatibility, a JIT dynamic recompilation engine that translates game code to native x86_64 or AArch64 instructions for faster performance, and OpenGL hardware-accelerated rendering

This project is a cross-platform emulator designed to execute software originally developed for the PlayStation 2 console on modern computing hardware. By replicating the original processor and graphics architecture, it allows users to run legacy game discs and digital backups within a virtual environment on contemporary desktop and laptop systems. The software distinguishes itself through advanced graphics enhancement engineering, which enables users to adjust rendering resolutions, apply texture filtering, and utilize community-created patches to improve visual fidelity beyond original hard

PyBoy is a programmable Game Boy emulator and hardware simulation framework written in Python. It functions as an emulation engine that allows users to execute original handheld software while providing a programmatic interface to control, probe, and automate game execution. The project is specifically designed as a reinforcement learning environment, exposing emulator states and controls to facilitate the training of machine learning agents. It distinguishes itself by providing tools for game area mapping and the extraction of simplified 2D screen representations and collision maps to suppor

86Box is a low-level x86 hardware emulator and vintage PC simulator designed to replicate early IBM PC compatibles. It provides virtualized environments for executing legacy operating systems, such as MS-DOS and early versions of Windows, by simulating processors and system designs ranging from the 8086 through the Pentium era. The project distinguishes itself through cycle-accurate processor simulation and high-fidelity hardware emulation. This includes the ability to route retro MIDI audio data to emulated hardware modules or external synthesizers to achieve authentic audio playback from le

Visualboyadvance-m is a cross-platform hardware simulator and Game Boy Advance emulator. It replicates handheld console hardware to run Game Boy Advance and Game Boy Color software on modern desktop computers. The project also serves as a handheld console debugger for analyzing emulated code and validating homebrew software. The system is designed as a modular Libretro emulation core, allowing it to be loaded as a pluggable component into compatible frontend applications. This decoupled architecture separates the emulation logic from the user interface to ensure the engine can run across diff

Play- is a multi-system game emulator and virtual hardware emulator that simulates various console and arcade hardware to run original game files on modern devices. It functions as a retro game frontend, providing a graphical interface for organizing, launching, and managing libraries of legacy console and arcade titles. The project includes a hardware input mapper that translates modern controllers and mouse movements to simulate specialized legacy input devices, such as light guns and steering wheels. It also features a game state manager capable of capturing and restoring the exact memory

melonDS is a Nintendo DS emulator and hardware architecture emulator. It is a software application designed to simulate the original system architecture of a handheld gaming console to run original games and applications on different computing platforms. The project functions as a firmware loader capable of initializing the emulated environment using authentic BIOS and system firmware dumps. This ensures software compatibility by replicating the original system's hardware state and boot sequence. The emulator provides capabilities for retro game preservation by executing original game ROMs.

pwndbg is a GDB plugin and binary analysis framework designed for reverse engineering, exploit development, and low-level program analysis. It extends the core functionality of the debugger to provide advanced memory inspection and automation tools. The project distinguishes itself with specialized capabilities for heap analysis across glibc, jemalloc, and musl, as well as a comprehensive kernel debugging toolkit for inspecting Linux kernel tasks and slab allocators. It includes an integrated ROP gadget searcher for constructing exploit chains and an LLM-powered debugging assistant that provi

Dolphin is a software environment that simulates GameCube and Wii console hardware, allowing users to execute game discs and digital software on modern computing platforms. It functions by translating original console processor instructions into native host machine code at runtime and intercepting low-level graphics commands to render them through modern graphics APIs. The project distinguishes itself through a comprehensive netplay engine that enables online multiplayer for local games by synchronizing game states and input timing across remote instances. This system enforces deterministic e

iOS & tvOS multi-emulator frontend, supporting various Atari, Bandai, NEC, Nintendo, Sega, SNK and Sony console systems… Get Started: https://wiki.provenance-emu.com |

Goboy is a GameBoy emulator written in Go that allows original handheld game ROMs to run on modern computer hardware. It supports both monochromatic and color display modes. The project includes specialized tools for retro game debugging and graphics inspection. These capabilities allow for the analysis of game logic by stepping through opcodes, profiling processor execution in real time, and inspecting background palettes, sprite data, and map layouts. The emulator provides game state preservation by writing cartridge RAM to local files. It also implements pixel-buffer rasterization for ren

jsnes is a JavaScript-based NES emulator that runs classic NES games in the browser or in Node.js. It provides cycle-accurate CPU emulation, frame-buffer-based video rendering, and sample-buffer audio synthesis, along with a ROM cartridge mapper abstraction for broad game compatibility. The emulator exposes a programmable core with a simple API for controlling emulation state, capturing screenshots, and managing save data. It supports keyboard control remapping at runtime, with settings persisted to localStorage, and offers state serialization for save and restore operations. Battery-backed S