floooh/chips
Chips
Chips is a modular, header-only C library framework designed for building cycle-accurate hardware simulators and replicating historical eight-bit computing architectures. It provides the foundational components necessary to construct complete vintage systems by integrating individual emulated microprocessors and peripheral chips.
The framework distinguishes itself through a component-based architecture where hardware modules are implemented as standalone headers that can be wired together to form complex systems. It models hardware interactions at a low level, utilizing pin-level signal emulation and memory-mapped bus communication to ensure deterministic behavior. Developers can capture the entire internal state of an emulator into a memory buffer, enabling persistent snapshots and precise state restoration.
The project includes a comprehensive suite of diagnostic and development tools, such as immediate-mode debug visualization and real-time monitoring of system registers and framebuffers. It also provides command-line utilities to automate the generation of hardware component definitions and source code, facilitating the construction of custom embedded environments.
Features
- 8-Bit Emulator Libraries - Provides a collection of header-only C libraries for simulating vintage microprocessors and peripheral chips.
- C Emulator Frameworks - Provides a modular toolkit for wiring discrete hardware components together to replicate historical eight-bit computing architectures.
- Component State Monitors - Renders graphical debugging interfaces for individual chip components to monitor internal registers, memory, and execution state.
- Eight-Bit - Simulates classic microprocessors and peripheral chips to recreate historical eight-bit computing environments.
- Vintage System Simulators - Wires together multiple discrete chip emulators to replicate the complete behavior of classic home computers and arcade systems.
- System Debugging - Provides an integrated debugger with cycle-accurate timing, breakpoint management, and state inspection for deep system investigation.
- Eight-Bit Component Simulators - Simulates individual eight-bit processor and peripheral chips through modular, header-only implementations.
- Cycle-Accurate Emulators - Advances execution by discrete clock cycles to ensure precise timing and deterministic behavior across hardware components.
- Eight-Bit - Provides preconfigured hardware definitions for classic eight-bit home computers and arcade systems.
- Hardware Component Headers - Implements hardware modules as standalone C headers that can be wired together to form complex system architectures.
- Emulator Framebuffer Visualizers - Provides real-time visualization of the emulator framebuffer and system status to monitor video output during execution.
- Web-Based Emulator Controls - Provides a web-based interface for controlling emulator execution, managing states, and automating testing cycles.
- Embedded System Construction Frameworks - Enables the construction of complete embedded computer systems by wiring together multiple chip emulators.
- Embedded Systems Debugging - Provides tools for inspecting hardware state and cycle-accurate timing to troubleshoot embedded software behavior.
- Hardware Signal Emulation - Models hardware interactions by manipulating bit masks representing physical voltage levels on chip pins.
- Memory Bus Interfaces - Simulates physical bus connections by reading and writing to shared memory address spaces.
- Hardware Emulators - Automates the creation and integration of custom hardware components into unified simulation environments.
- Custom System Composition Tools - Integrates multiple discrete chip emulators into a unified environment to replicate specific vintage computing architectures.
- Machine State Serialization - Captures the entire internal register and memory state of the emulator into a flat memory buffer for persistence.
- Emulator State Snapshots - Captures and restores the complete internal state of an emulator to memory for debugging and persistent snapshots.
- Immediate-Mode Rendering - Renders debugging interfaces by directly querying the internal state of the emulator during each frame.
