Open-source alternatives to Tiny Gpu

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

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

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

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

PS2Recomp is a static recompiler for PlayStation 2 that translates machine instructions from executable binaries into source code to enable execution on modern hardware. It functions as a binary-to-source translator and a binary analysis tool designed to facilitate the preservation of legacy software. The project distinguishes itself through a hardware emulation runtime that manages memory models and register contexts, combined with a static binary patcher for replacing raw instructions and overriding function bindings. It utilizes a specialized vector unit instruction execution system that m

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

macintosh.js is an Electron-based system emulator designed to run legacy operating systems and vintage software within a modern desktop application. It functions as a virtual machine that replicates the hardware and software environment of a Macintosh Quadra to execute System 8. The project includes a UDP network bridge and virtual Ethernet integration, which routes network traffic to specific ports to enable communication between multiple emulated instances on a local network. The emulator supports virtual disk management and disk-image mounting to transfer files between the host machine an

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

Virtual-Display-Driver is a kernel-level driver for Windows that emulates physical monitors and audio devices. It serves as a virtual monitor emulator, headless server display emulator, and virtual audio device driver to enable extended desktop space and sound routing on systems without physical hardware connections. The project enables the simulation of monitors with custom resolutions, refresh rates, and identification profiles, including support for High Dynamic Range output. It also provides software-defined audio interfaces to simulate virtual microphones and speakers. The software cove

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

GPU-Puzzles is an interactive learning environment and tutorial designed for mastering CUDA GPU kernel development. It serves as an educational tool and lab where users solve coding puzzles to understand how to map high-level logic to low-level GPU hardware instructions. The platform focuses on teaching parallel computing concepts and GPU architecture. Users practice developing parallel algorithms and managing GPU memory through a series of hands-on challenges. The environment utilizes a bridge between Python and CUDA to execute kernels and provide real-time feedback by validating outputs ag

This project is a cross-platform, open-source emulator designed to execute handheld gaming software on modern desktop and mobile hardware. By recreating the original console environment and system libraries, it allows users to run game files without requiring original firmware. The software achieves high-performance execution through a combination of dynamic recompilation and just-in-time instruction translation, which map console-specific instructions to native host machine code. The emulator distinguishes itself by providing advanced visual and connectivity enhancements that extend beyond t

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 a comprehensive educational framework designed to guide learners through the complexities of systems engineering and low-level software development. It provides structured learning paths that integrate hardware simulation, source code analysis, and project-based exercises to help developers master the foundational concepts of computer architecture, operating systems, and firmware design. The curriculum distinguishes itself by emphasizing direct interaction with system internals, requiring learners to examine and modify existing open-source kernel and driver implementations. By

This project is a Java GUI framework used to build cross-platform desktop, mobile, and embedded applications. It centers on a hardware accelerated graphics engine that provides 2D and 3D visualizations and visual effects, complemented by a reactive UI binding system for synchronizing data and interface updates. The framework distinguishes itself through the FXML markup language, which separates the visual structure of an interface from its procedural logic. It also includes a dedicated CSS styling engine that allows for the customization of component appearances using external stylesheets and

Digital-Logic-Sim is a digital logic simulator and interactive circuit designer used for building and simulating digital hardware circuits. It functions as a visual editor and logic state visualizer that allows for the creation of complex digital logic models using logic gates, wires, and custom chips. The system includes a custom logic chip builder, enabling the grouping of basic logic gates into reusable components to create layered hardware architectures. Users can monitor these designs through a logic state visualizer that displays signal states and memory values using light indicators an

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 collection of minimal operating systems, bootloaders, and hardware drivers used to demonstrate low-level x86 system programming and hardware interfacing. It serves as a kernel development toolkit and a system programming lab designed for testing architecture concepts and hardware behavior within a system emulator. The repository provides reference implementations for creating bootable disk images and loading kernel stages. It includes guides for implementing protected mode transitions, memory paging, interrupt descriptor tables, and symmetric multiprocessing on x86 hardware.

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 emula

This project provides a structured educational curriculum designed to teach Linux kernel internals and system architecture. It serves as a comprehensive training resource for developers, offering hands-on laboratory exercises that cover core operating system principles such as memory management, process scheduling, and interrupt handling. The curriculum distinguishes itself by mapping theoretical concepts directly to kernel source code, allowing learners to navigate and analyze system internals through practical implementation tasks. It facilitates the development of hardware device drivers a

HoloCubic is an embedded desktop widget station and holographic display system. It consists of a graphics framework for rendering resolution-specific visuals and a hardware setup that uses a beam-splitting prism and transparent screen to create floating 3D visual effects. The system includes a PC-based hardware emulator used to design and verify graphical interfaces before deploying code to physical hardware. It also features an inertial measurement unit motion controller that translates physical movement into navigation inputs for the user interface. The project covers an asset pipeline for

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

The Intel RealSense SDK is a software development kit providing drivers and libraries for interfacing with depth cameras to capture color, depth, and infrared data streams. It includes a depth camera driver for device discovery and sensor configuration, a stereo vision library for computing depth maps and aligning frames, and a 3D point cloud generator to transform depth and infrared frames into spatial representations. The SDK distinguishes itself through on-chip depth calculation and stereo calibration, using internal vision processors to reduce host CPU load. It supports hardware-level str

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

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

U-Boot is an embedded bootloader that initializes hardware components and loads operating system kernels into memory. It functions as a hardware abstraction layer providing standardized access to networking, storage, and peripheral buses, while also serving as a secure boot loader and a firmware update interface. The project distinguishes itself through the implementation of secure boot sequences that verify cryptographic signatures and interface with TPM modules to establish hardware-rooted trust. It further provides specialized capabilities for updating device firmware via standardized prot

picorv32 is a size-optimized RISC-V CPU core and synthesizable processor IP designed for integration into FPGA and ASIC hardware designs. It serves as an open-source CPU architecture and embedded system-on-chip component that implements a standard RISC-V instruction set. The design features a modular architecture that allows for the integration of external coprocessors to implement custom non-branching instructions. It includes a parameterized integer unit with configurable multiplication and division cores to balance performance against total logic gate count. The project covers a broad ran