Projects sharing features with Dolphin

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

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

This project is a bare-metal operating system developed for ARM64 architecture. It serves as a low-level implementation of kernel engineering, focusing on the fundamental construction of an OS from the hardware level up. The system is distinguished by its comprehensive approach to ARM64 processor control, featuring a red-black tree task scheduler and a hierarchical page table system for virtual memory management. It implements a sophisticated privilege model that handles transitions between kernel and user modes, ensuring process isolation through address space splitting and exception level m

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

This project is a cross-platform graphics and compute framework that provides a unified, hardware-agnostic abstraction layer for rendering and parallel processing. It enables developers to build high-performance applications that execute consistently across diverse operating systems and hardware backends, including Vulkan, Metal, and DirectX. By mapping high-level graphics commands to native APIs, it serves as a portable foundation for both real-time 3D rendering and general-purpose GPU computing. The framework distinguishes itself through a robust architecture that supports both native deskt

ZLUDA is a middleware and translation engine designed to enable the execution of unmodified proprietary compute binaries on non-native graphics hardware. It functions as a compatibility layer that bridges vendor-specific compute interfaces with open standards, allowing software originally restricted to a single hardware ecosystem to operate on alternative graphics processing units. The project achieves this through a combination of dynamic library interception and runtime instruction translation. By replacing standard system libraries and mapping proprietary compute calls to open standards, t

This repository is a comprehensive collection of functional 2D and 3D demo projects and implementation samples for the Godot Game Engine. It serves as an interactive tutorial and reference library, providing a working codebase to demonstrate how to apply engine features in real-world scenarios. The collection focuses on practical implementation guides, covering a wide array of technical capabilities from basic engine fundamentals to advanced rendering and scripting techniques. It allows users to study the application of node-based composition, asset pipelines, and game logic through direct ex

QEMU is a cross-platform system emulator and hardware virtualization platform that enables the execution of multiple isolated operating systems on a single host machine. It functions as a processor architecture emulator, translating machine instructions between different hardware platforms to allow software designed for one architecture to run on another. The project distinguishes itself through a modular target architecture that separates core emulation logic from specific hardware definitions, supporting a wide range of processor and peripheral configurations. It utilizes dynamic binary tra

This project is an educational framework and toolkit designed for developing and testing operating system kernels. It provides a structured environment for implementing fundamental system primitives, including virtual memory management, preemptive process scheduling, and filesystem organization, using Rust and C. The framework is specifically oriented toward RISC-V and x86 architectures, serving as a laboratory for learning how to build core system software from the ground up. The project distinguishes itself by supporting both bare-metal deployment and hardware emulation, allowing developers

This project is a freestanding kernel written in Rust that boots on x86 hardware without a standard library. It serves as a low-level system implementation focusing on the creation of a bare metal operating system. The system implements a bootable disk image toolchain that transforms source code into binaries compatible with a bootloader. It features a custom memory allocator for dynamic memory management and an x86 kernel implementation that includes paging, interrupt handling, and VGA text mode. The project covers several core capability areas, including low-level memory management through

This project is a tutorial and framework for building a low-level, bare-metal operating system from scratch using the Rust language. It focuses on ARMv8 kernel development specifically for the Raspberry Pi 3, providing the resources necessary to implement a monolithic kernel that runs directly on hardware without an underlying operating system. The project distinguishes itself by providing a complete embedded cross-compilation suite within a containerized environment to ensure consistent builds. It includes a dedicated kernel deployer that uses a serial interface and chainloader to load and b

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

Sokol is a C hardware abstraction layer and cross-platform graphics library designed for managing windowing, input, and audio across different operating systems. It functions as a GPU resource manager and multimedia application framework, providing a unified API for rendering 2D and 3D graphics across WebGL, Metal, Direct3D, and OpenGL. The project is distinguished by its single-header implementation, which simplifies integration and portability. It utilizes a stateless render pass definition and a one-update-per-frame model to synchronize CPU data to GPU memory and manage resource lifecycles

egret-core is a cross-platform game engine and mobile application framework used to develop 2D and 3D software for Android, iOS, and Windows. It serves as a multi-platform graphics engine and input handler designed to maintain consistent visual output and interaction behavior across different hardware. The project provides a game physics and animation suite that integrates external libraries for skeletal animations, particle systems, and complex physics simulations. It utilizes a hardware-abstraction layer to standardize touch, keyboard, and mouse interactions across multiple operating system

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

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.

Onion is a custom handheld gaming operating system and retro gaming frontend designed to manage and launch emulators on portable hardware. It functions as a bootable custom firmware distribution and emulation environment manager that replaces factory software to provide an integrated gaming environment. The system distinguishes itself through a modular core-based emulation architecture, allowing for the installation of verified emulator packages, BIOS configuration, and the use of hardware-specific drivers and filters. It also supports the integration of third-party game ports via standardize

OpenRCT2 is an open-source reimplementation of a classic amusement park management simulation engine. It functions as a cross-platform engine that modernizes the original game, enabling it to run on contemporary operating systems while maintaining full compatibility with legacy assets and data files. The project distinguishes itself by providing a comprehensive multiplayer simulation server that supports cooperative, real-time park management and construction across multiple connected clients. It utilizes a deterministic lockstep networking model and a centralized action-based validation syst

Battle for Wesnoth is an open-source turn-based strategy game set in a high fantasy world, built around hex-grid tactical combat. At its core, it is both a complete game and a game engine, offering single-player campaigns and multiplayer battles where players command faction-specific units across terrain that provides tactical advantages. The project is fundamentally a turn-based strategy game with a dedicated multiplayer platform, supporting online and local matches with replay recording and playback. What distinguishes Wesnoth is its deep commitment to custom content creation and modding. T

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

Shipwright is a native execution engine designed to run decompiled legacy game code on modern hardware. It functions as a game engine execution layer that provides a high-performance environment for legacy logic while ensuring compatibility with current systems. The project features a pluggable graphics API wrapper that allows for switching between different rendering backends to ensure visual stability across various operating systems. It also includes a custom asset loader that imports external archive files to modify game content and add custom assets. Additional capabilities include an i

PixiJS is a hardware-accelerated 2D rendering engine and HTML5 canvas library. It functions as a web-based graphics engine that utilizes WebGL to draw interactive digital content, shapes, text, and images in the browser. The engine provides a specialized pipeline for high-performance 2D graphics, featuring a scene-graph hierarchy for organizing visual objects and a system for dynamic texture management. It includes capabilities for applying visual effects through masks, filters, and blend modes. The project covers broad functional areas including digital asset loading, user input processing

Neovide is a cross-platform graphical frontend for the Neovim text editor. It provides a native windowed interface that preserves terminal-based functionality and keyboard-driven workflows while introducing a hardware-accelerated display layer. By utilizing GPU-accelerated rendering, the application ensures high-performance visual output across different desktop operating systems. The project distinguishes itself through an interpolated animation engine that provides fluid, frame-by-frame transitions for cursor movement and scrolling. It features an asynchronous input event loop to maintain i

AntiMicroX is a gamepad input manager and automation tool that translates gamepad inputs into keyboard and mouse commands. It functions as an input remapper capable of translating physical controller buttons and joystick movements into system actions for applications that lack native controller support. The system features window detection to automatically switch between custom input profiles based on the currently active application. It includes tools for game controller automation through complex macros and provides hardware standardization to ensure diverse controller models behave consist

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

MinIO is a software-defined, cloud-native object storage server designed to manage large volumes of unstructured data. It functions as a distributed storage cluster that aggregates multiple independent nodes into a unified, scalable pool, providing a high-performance infrastructure compatible with standard cloud storage protocols and application programming interfaces. The system utilizes a shared-nothing architecture that eliminates central metadata servers, relying instead on a decentralized hash table to map objects across the cluster. Data availability and resilience are maintained throug

Firefox is a cross-platform web browser engine designed to render web content, execute JavaScript, and manage secure browsing sessions. It utilizes a multi-process isolation architecture that distributes browser tasks across independent operating system processes to ensure stability and prevent site-specific failures from impacting the entire application. The engine incorporates a sandboxed execution environment to restrict web content and untrusted scripts to isolated memory compartments, enforcing security policies that prevent unauthorized access to system resources. The project distinguis