Open-source alternatives to Chips

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

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

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

Open-smartwatch-os is an operating system designed for resource-constrained wearable devices. It provides a development and testing environment that allows developers to build, validate, and debug firmware for smartwatches within a simulated desktop environment before deploying to physical hardware. The project distinguishes itself through a comprehensive suite of tools for hardware emulation and remote diagnostics. By utilizing a hardware abstraction layer and modular driver architecture, it decouples core system logic from specific physical components. This enables developers to run the ope

NuttX is a POSIX-compliant real-time operating system designed for microcontrollers ranging from 8-bit to 64-bit architectures. It provides a deterministic execution environment with a real-time task scheduler and a POSIX embedded kernel to ensure portable code execution across diverse hardware targets. The project distinguishes itself through a comprehensive hardware abstraction layer that provides standardized drivers for I2C, SPI, CAN, and USB across various semiconductor chipsets. It also features an embedded networking stack supporting TCP, UDP, IPv4, and IPv6, alongside industrial proto

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

This project is a GameBoy hardware emulator that simulates the original processor, graphics, and sound systems to run vintage ROMs. It provides a core emulation engine that executes instructions using cycle-accurate simulation to match original hardware timing. The emulator is designed for remote play, enabling cloud game streaming via HTTP and WebSockets. This allows for remote cooperative gaming through a web browser and terminal-based gaming where game state is rendered via telnet. The system includes capabilities for memory-mapped I/O emulation and state-based save restoration to preserv

HyperDbg is a hardware-assisted kernel-mode debugging platform that leverages virtualization to monitor and control system execution. By utilizing hypervisor-level primitives, it enables deep system analysis and instrumentation without relying on standard operating system debugging interfaces. The framework provides a comprehensive environment for inspecting both kernel and user-mode processes, allowing for granular control over execution flow and system state. The project distinguishes itself through a transparent debugging layer designed to remain invisible to the target environment. It emp

Furnace is a multi-system chiptune tracker and vintage sound chip emulator used for composing and rendering audio. It functions as a music sequencer that mimics legacy hardware, including FM and square wave synthesizers, to create authentic retro sounds. The project distinguishes itself by enabling multi-system chiptune production, allowing users to mix different vintage audio chips and wavetable synthesizers within a single project. It also serves as a module editor compatible with DefleMask project files and provides a headless audio player for streaming modules via a console interface with

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 Nintendo Entertainment System emulator written in Go. It functions as a hardware simulation that executes game ROMs by mimicking the original console's circuitry, including the processor and picture processing unit. The emulator includes a game library browser that identifies local files and retrieves titles and thumbnails from online databases using file checksums. It also implements a system of memory management mappers to ensure compatibility across various game ROM formats and hardware configurations. The software covers high-level capabilities for game ROM execution an

Verilator is a hardware simulation engine and toolchain that translates Verilog and SystemVerilog hardware description languages into optimized C++ or SystemC models. It functions as a compiler and transpiler, converting hardware designs into executable binaries to achieve high-speed simulation and integration into software environments. The project distinguishes itself by focusing on simulation acceleration through the generation of optimized C++ classes and cycle-accurate models. It provides a SystemVerilog linter for static analysis of hardware designs and a hardware coverage analyzer to t

mGBA is a high-accuracy Game Boy Advance emulator and hardware-level debugger designed to run handheld console ROMs on modern computers. It serves as a scriptable emulation environment that allows for the execution of portable hardware software and the simulation of associated peripherals. The project distinguishes itself through its focus on technical analysis, providing a suite of tools for retro game debugging and game logic inspection. It includes a host-client debug protocol that enables external debugger connectivity via TCP socket communication and an event-driven scripting engine for

This project is a graphical Windows debugger designed for the analysis and manipulation of compiled binary applications. It functions as a comprehensive binary analysis suite, providing a real-time environment for inspecting CPU registers, monitoring memory states, and tracing instruction execution to investigate system-level software behavior. The tool distinguishes itself through an event-driven debugging loop that allows for precise process control and state modification during runtime. It supports advanced analysis techniques, including hardware-breakpoint injection for monitoring memory

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

probe-rs is an embedded debugging toolset used for flashing, debugging, and inspecting microcontrollers via hardware debug probes. It functions as an embedded firmware flasher, a memory manager for reading and writing to processor registers, and a server implementing the Debug Adapter Protocol to connect hardware debugging to various code editors. The project includes a CMSIS-Pack target parser to extract device metadata and flash configurations from industry-standard definition files. It provides a driver-based probe abstraction to interact with various hardware debug probes regardless of th

Blackmagic is a GDB server for embedded hardware that translates GDB remote protocol messages into JTAG and SWD commands. It functions as an ARM and RISC-V debugger and hardware debug probe manager, enabling users to inspect memory, control execution, and manage registers on ARM Cortex and RISC-V cores. The project distinguishes itself by acting as a remote hardware debugging bridge that can stream GDB server traffic over TCP/IP to control physical hardware from a remote machine. It also provides a JTAG and SWD interface to connect host computers to target hardware and serves as an embedded f

Delve is a command-line debugger designed for programs written in the Go programming language. It provides an interactive interface for runtime analysis, allowing developers to control program execution, inspect memory and variable states, and navigate call stacks to identify logic errors. The tool distinguishes itself through deep integration with the Go runtime, specifically by providing goroutine-aware stack unwinding and the ability to manage concurrent execution threads. It utilizes a client-server protocol to decouple the debugger engine from the user interface, enabling both local and

Nuklear is a portable, header-only immediate mode graphical user interface library written in C. It is designed to function as a lightweight framework for creating interfaces that render directly to hardware, making it suitable for integration into custom graphics engines, embedded systems, and resource-constrained environments. The library operates by generating abstract draw commands that are converted into vertex buffers, allowing for hardware-accelerated rendering through standard graphics APIs. By utilizing an immediate mode approach, the interface state is defined and updated within the

This project is an educational resource and virtual environment designed to teach the fundamentals of embedded systems and internet-connected device development. It provides a structured curriculum that guides learners through the essential skills required to program, connect, and integrate hardware components. The platform distinguishes itself by offering virtual hardware emulation, which allows users to test electronic circuits and device logic within a digital environment. This simulation capability enables students to practice building and testing projects without the requirement for phys

Nuklear is a minimal, header-only graphical user interface toolkit written in C. It utilizes an immediate-mode rendering model, where the interface is reconstructed and drawn directly within the application loop each frame. This approach eliminates the need for persistent widget state or complex synchronization between the interface and underlying application data. The library is designed for portability and integration into resource-constrained environments. It requires the host application to manage memory manually, allowing it to function in systems that lack standard library support. By d

DearPyGui is a GPU-accelerated, immediate-mode graphical user interface framework for Python. It provides a high-performance toolkit for building interactive desktop applications by leveraging native hardware-accelerated rendering backends across multiple operating systems. By utilizing an immediate-mode execution model, the library offers direct control over the rendering loop and element state, enabling the creation of responsive, dynamic interfaces. The framework distinguishes itself through its ability to handle complex, high-frequency visual updates, making it suitable for real-time data

Tiny-gpu is an educational hardware emulator designed to model the fundamental operations of a graphics processing unit. It provides a software environment that simulates hardware data flow and parallel computing logic, allowing users to visualize the internal execution cycles and memory structures characteristic of graphics hardware. The project distinguishes itself by implementing a cycle-accurate execution model that tracks the progression of operations through discrete processing steps. It utilizes a fixed-function pipeline to process geometric data through sequential transformation and r

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

UTM is a comprehensive virtualization suite that provides a unified interface for running guest operating systems on host hardware. It functions as a cross-platform system emulator and hypervisor, coordinating both hardware-accelerated virtualization and software-based instruction emulation to execute diverse operating systems. By leveraging native kernel-level virtualization frameworks, the software achieves near-native performance while maintaining strict security through sandboxed process isolation. The project distinguishes itself by enabling full-featured desktop operating systems to run

ImGuizmo is a widget library for Dear ImGui that provides interactive graphical components for 3D transformations, chronological timelines, vector geometry editing, and node-based data flow. It primarily provides a 3D transformation gizmo for manipulating the rotation, translation, and scale of objects within a 3D scene. The library includes a visual node graph editor for managing networks of connected nodes to represent data flow and a linear sequence timeline for editing frame ranges for events. It also features a vector path editor, which uses a pen tool and anchor handles to create and ma

Xtreme-Firmware is a custom operating system for the Flipper Zero designed to expand hardware capabilities and remove software restrictions. It functions as a multi-protocol signal emulator for capturing and replaying RFID, NFC, Sub-GHz, and Infrared signals to test hardware security. The project features a specialized USB HID attack framework for sending keystroke payloads and spoofing device identifiers over USB and Bluetooth. It also includes a WiFi penetration testing suite for scanning, sniffing, and sending deauthentication frames using a wireless development board. Broad capabilities