The Raspberry Pi Pico SDK is a comprehensive C/C++ software development kit for the RP2040 and RP2350 microcontrollers, providing a hardware abstraction layer, peripheral drivers, synchronization primitives, and build-system integration for embedded firmware. It is not an application itself but a library and toolchain ecosystem consumed by firmware projects, targeting ARM Cortex-M0+/M33 and RISC-V Hazard3 cores. The SDK is architected around modular libraries (pico_*, hardware_*) that expose register-level access via auto-generated structs, runtime initialization with ordered callbacks, an async context abstraction for WiFi/USB/timers, and a lightweight resource claiming system for peripherals. It supports both CMake and Bazel builds, includes a PIO assembler (pioasm), and provides a host-simulation layer for desktop testing. The codebase exhibits strong engineering discipline with extensive use of weak function overrides, config macros, and static assertions, though it carries the inherent complexity of supporting two chip generations, two architectures, and multiple third-party middleware stacks (TinyUSB, lwIP, BTstack, mbedTLS).
This is a bare-metal (no_std) hardware abstraction layer (HAL) for Espressif ESP32 microcontrollers, supporting RISC-V and Xtensa cores. It provides low-level drivers for GPIO, SPI, I2C, UART, ADC, DAC, PWM, timer, USB, Ethernet, Wi-Fi, BLE, IEEE 802.15.4, and many other peripherals across a dozen+ chip families (ESP32, ESP32-C2/C3/C5/C6/C61, ESP32-H2/H4, ESP32-P4, ESP32-S2/S3/S31). The repository is a monorepo containing multiple independently versioned crates: esp-hal (core HAL), esp-radio (wireless radio stacks), esp-alloc (heap allocator), esp-storage (flash storage), esp-backtrace, esp-println, esp-sync (synchronization primitives), esp-rom-sys (ROM function bindings), esp-rtos (lightweight RTOS with async/embassy integration), esp-lp-hal (low-power core HAL), esp-config (build-time configuration), esp-metadata (chip property code generation), xtask (build/release tooling), and bootloader/OTA support. The architecture is built on extensive use of compile-time chip selection via macros (cfg_select!, for_each_*), versioned low-level driver modules per peripheral, and type-erased patterns for unified APIs across chip variants. Async support is first-class via embassy executor integration. The codebase demonstrates high engineering quality with clear abstractions, comprehensive hardware-in-the-loop testing (hil-test, hil-test-radio), and mature CI/CD workflows.
ncnn is a high-performance neural network inference framework designed for mobile, embedded, and desktop deployment. It provides a self-contained C++ library with no mandatory external dependencies, supporting CPU inference with extensive SIMD optimizations (ARM NEON, x86 SSE/AVX/AVX512, RISC-V Vector, MIPS MSA, LoongArch LSX/LASX) and GPU inference via Vulkan. The framework includes a comprehensive set of neural network layers (convolution, pooling, normalization, activation, recurrent, attention, etc.) and supports multiple data types (float32, float16, bfloat16, int8). The companion pnnx tool converts models from PyTorch (TorchScript) and ONNX into ncnn format using a sophisticated graph rewriting pipeline. Python bindings and a model zoo are provided for rapid prototyping. The codebase is production-grade, used in Tencent applications like QQ and WeChat, and is actively maintained with support for modern architectures and operations (e.g., scaled dot-product attention, rotary embeddings).
Capstone is a multi-architecture disassembly engine written in C, derived from LLVM's MC disassembler. It supports over 20 architectures including x86, ARM, AArch64, MIPS, PowerPC, RISC-V, and more. The core library provides a stable C API (cs_open, cs_disasm, cs_option, etc.) and includes per-architecture backends with mapping, disassembler, and instruction printer modules. The architecture is modular: each architecture has a Module.c that registers callbacks into a common cs_struct. The primary data flow is: user provides raw bytes and arch/mode, the engine selects the appropriate disassembler, decodes instructions into MCInst, then prints via instruction printer, optionally filling cs_detail with operand/register/group information. The repository also includes a CLI tool (cstool), extensive test suites (MC regression tests, cstest YAML-based detail tests), fuzzing harnesses, and an automated LLVM sync pipeline (auto-sync) that translates LLVM C++ disassembler code to C using tree-sitter patches. The codebase is well-structured with clean abstractions for operand models (MCInst/MCOperand), string output (SStream), and architecture-specific mapping. The auto-sync tooling is a notable engineering achievement, enabling systematic translation of LLVM backend code to C. Language bindings for Python, Java, OCaml, and others demonstrate the library's embeddability. The test infrastructure is comprehensive, covering both basic disassembly and detailed operand/register analysis. External dependencies are minimal for the core library (pure C), but the auto-sync tooling depends on Python, tree-sitter, clang-format, and lit. Overall, Capstone is a mature, actively maintained disassembly framework with high craftsmanship and reusable components.
OP-TEE (Open Portable Trusted Execution Environment) is a secure operating system that provides a Trusted Execution Environment (TEE) for ARM and RISC-V platforms. It runs in the secure world of a system-on-chip, isolated from the normal world (e.g., Linux). The OS includes a microkernel, cryptographic libraries (LibTomCrypt, Mbed TLS), hardware abstraction layers for crypto accelerators (CAAM, SE050, Hisilicon, etc.), device drivers (UART, GPIO, I2C, clocks, reset controllers, firewalls), and a framework for trusted applications (TAs) and pseudo TAs. It communicates with the normal world via SMC (Secure Monitor Call) or FF-A (Firmware Framework for Arm A-profile). The architecture is a monolithic kernel with modular driver registration using device tree and initcall macros. Key entry points include boot code (platform-specific main.c), SMC handlers (sm.c, thread_optee_smc.c), and system call handlers (arch_scall.c). Data flows involve secure storage (encrypted file system), cryptographic operations (symmetric/asymmetric ciphers, hashing, key derivation), and remote procedure calls (RPC) for I2C, RPMB, and other services. External dependencies include libfdt (device tree), qcbor (CBOR encoding), and softfloat (IEEE 754 floating-point emulation). The project supports a wide range of hardware platforms (NXP i.MX, STMicroelectronics STM32MP, Qualcomm, Xilinx Versal, Microchip SAMA5, etc.) and is actively maintained with frequent releases.
raylib is a cross-platform game development library written in C99, designed to provide a simple and easy-to-use API for creating games, prototypes, and multimedia applications. It abstracts away platform-specific details like window creation, input handling, and graphics rendering, offering a consistent interface across Windows, macOS, Linux, Android, and Web (via Emscripten). The library is modular, with core modules for shapes, textures, text, 3D models, audio, and shaders, all built on top of a low-level OpenGL abstraction layer (rlgl). It bundles its own windowing backend (a fork of GLFW) and includes numerous single-file external libraries for image loading (stb_image), audio decoding (dr_flac, dr_mp3, dr_wav, jar_mod, jar_xm), compression (sdefl, qoa, pep), and model loading (tinyobj_loader, cgltf, vox_loader). The repository contains over 200 example programs that serve as both documentation and test cases, covering everything from basic window creation to advanced shader effects and 3D rendering pipelines. The architecture follows a monolithic library pattern with a single public header (raylib.h) and several optional headers (raymath.h, rlgl.h, raygui.h). The core library is compiled from source files (rcore.c, rshapes.c, rtextures.c, rtext.c, rmodels.c, raudio.c) and platform-specific backends (rcore_desktop_glfw.c, rcore_android.c, rcore_web_emscripten.c, etc.). The library is designed to be self-contained, with no external runtime dependencies beyond the operating system's graphics drivers. Build system support includes CMake, Make, Zig, Meson, and IDE project files for Visual Studio, VSCode, CodeBlocks, and others. Key data flows involve initializing a window and graphics context, then entering a game loop where user input is polled, game state is updated, and rendering commands are issued. The library handles resource management (textures, fonts, models, audio streams) internally, with automatic cleanup on window close. The audio subsystem supports streaming, effects, and multi-channel playback. The shader system allows custom GLSL vertex and fragment shaders to be applied to 2D and 3D rendering. The library also includes utility modules for math (vectors, matrices, quaternions), easing functions, gesture recognition, and camera systems. External dependencies are minimal due to extensive bundling; the only required system libraries are OpenGL (or OpenGL ES on mobile/web) and the platform's native windowing/input APIs. The bundled GLFW fork provides a consistent windowing layer across platforms. The library is actively maintained with regular commits, CI builds for multiple platforms, and a large community of users and contributors.
This is the Asahi Linux fork of U-Boot, the universal bootloader, primarily targeting Apple Silicon Macs. The codebase is a full-featured bootloader with support for multiple architectures (ARM, RISC-V, x86, MIPS, PowerPC, etc.), a driver model (DM) for hardware abstraction, device tree support, SPL/TPL multi-stage boot, and a rich command-line interface. It includes bundled libraries for networking (lwIP), cryptography (mbedTLS), and compression (zstd, lzma). The Asahi-specific modifications add support for Apple's M1/M2 SoCs, including early boot initialization, memory mapping, and device tree bindings. The repository is actively maintained with recent commits and a responsive issue tracker.
xv6 is a monolithic, teaching-oriented Unix-like operating system kernel for RISC-V, reimplemented from Version 6 Unix. The kernel provides process management (fork, exec, wait, exit), multiprocessor scheduling via a round-robin scheduler, virtual memory with SV39 page tables, a block-oriented file system with crash recovery via a write-ahead log, and essential device drivers (UART console, virtio disk). It boots in QEMU and includes a minimal init process, shell, and a suite of simple user commands (cat, grep, ls, etc.). The codebase is intentionally compact and clear, demonstrating core OS concepts with a focus on simplicity and directness rather than performance or production robustness. It is not a hybrid repo; it is purely a systems software application (an operating system).
Unicorn Engine is a lightweight, multi-architecture CPU emulation framework derived from QEMU. It provides a pure C API with bindings for Python, Go, Java, Rust, Ruby, .NET, Haskell, Pascal, Zig, and VB6. The engine supports ARM, ARM64, M68K, MIPS, PowerPC, RISC-V, S390X, SPARC, TriCore, and x86 (16/32/64-bit). It is used primarily for security research, reverse engineering, fuzzing, and dynamic analysis of binary code. The architecture is a library with a central C API that exposes memory mapping, register access, hooks (code, block, memory, interrupt, instruction, syscall, TLB), and context save/restore. The core emulation logic is based on QEMU's TCG (Tiny Code Generator) for dynamic binary translation, with a custom glib compatibility layer to eliminate external dependencies. The repository includes extensive regression tests, fuzz targets, and sample programs for each architecture and binding. While the engine is actively maintained and widely used, it carries technical debt from its QEMU fork (based on QEMU 5.0.1) and auto-generated binding constants that may drift from the C API.
RVX is a fully functional RISC-V RV32I microcontroller IP core written in synthesizable Verilog, targeting FPGAs (specifically Digilent Arty A7 and Cmod A7 boards). It implements the RV32I base ISA v2.1 plus the Zicsr extension and Machine-Level ISA v1.13. The core includes a custom system bus (`rvx_bus`) that can be parameterized with an arbitrary number of memory-mapped slaves, and a set of peripherals: UART, GPIO, SPI, and machine timer (`mtime`/`mtimecmp`). The repository provides complete example projects for bare-metal and FreeRTOS, including board-specific wrapper modules, constraint files, and TCL scripts for Vivado project creation. The software examples use CMake with the RISC-V GCC toolchain and the `libsteel` hardware abstraction library. A comprehensive verification suite covers all RV32I instructions via RISC-V Architecture Test programs, alongside Cocotb-based peripheral tests and a Verilator simulation framework with C++ harness. The bus interface uses a simple request/response handshake with write strobes, which is clean but non-standard (not AXI/Wishbone). The core is a single-monolithic file (~1300 lines) with a 4-state FSM and no pipelining, making it compact but harder to modify. Overall, the repository is a well-documented, professionally structured open-source hardware project with strong testing practices, suitable for FPGA-based embedded systems education or low-complexity control applications.
EIDE (Embedded IDE) is a VS Code extension for embedded microcontroller development, supporting a wide range of architectures (8051, STM8, Cortex-M, RISC-V, MIPS) and toolchains (GCC, Arm Compiler, IAR, SDCC, COSMIC, LLVM). It provides project management (create, import from Keil/IAR/Eclipse), build system integration, flash programming (JLink, STLink, OpenOCD, pyOCD, probe-rs), and analysis tools (callgraph visualization, stack usage, memory map, CMSIS pack management). The extension includes a web-based configuration UI, a Model Context Protocol (MCP) server for headless tool access, and custom language support for embedded assembly/linker scripts. The architecture is a VS Code extension with TypeScript core, Vue.js webviews, and platform-specific .NET binaries for build/flash operations. While deeply functional and feature-rich, the codebase exhibits some monolithic files, vendored outdated dependencies (Bootstrap 4.3.1, Vue 2.6), and a high degree of coupling between project management and UI logic.
This repository is the RISC-V GNU Compiler Toolchain build system. It provides the infrastructure to build cross-compilation toolchains targeting RISC-V architectures (RV32/RV64) with various C libraries (newlib, picolibc, glibc, musl, uClibc). The codebase consists of autotools-based configure scripts, Makefile templates, vendored Linux kernel UAPI headers for RISC-V, CI workflows, and test infrastructure including DejaGnu board configurations and regression test allowlists. It is not an end-user application but a build orchestration project that compiles GCC, binutils, and associated libraries from source. The architecture is a classic GNU autotools build system with submodule dependencies. Key entry points are the top-level `configure` script and `Makefile.in`, which drive the build of all toolchain components. The repository also includes scripts for running tests on QEMU and Spike simulators, and CI pipelines for continuous integration and nightly releases.
The RISC-V ISA Manual repository is primarily a documentation build system that generates the RISC-V Instruction Set Architecture specifications in PDF, HTML, and EPUB formats. It processes AsciiDoc source files using custom Ruby extensions for cross-referencing, macros, and changebars, orchestrated by a Makefile that defaults to a Dockerized build environment. The system includes validation scripts for normative rules and cross-references, ensuring the specification's integrity. While the core purpose is producing a technical reference, the repository's build infrastructure constitutes an application with reusable components for documentation processing.
Tina is a header-only library providing lightweight user-space threading through coroutines and fibers, along with a fiber-based job system for task scheduling. The core library (tina.h) implements symmetric and asymmetric coroutine APIs with platform-specific assembly for context switching. Tina Jobs (tina_jobs.h) builds on this to create a job scheduler featuring work-stealing via queue chaining, memory pooling, and fiber-based job execution to avoid OS thread overhead. The repository includes examples (e.g., Mandelbrot renderer using Sokol graphics) and tests demonstrating usage, but the project has migrated to Codeberg due to philosophical opposition to AI training, indicating the GitHub repository is no longer actively maintained. While the Sokol dependencies in extras are third-party, the Tina core showcases strong craftsmanship in low-level concurrency primitives.