Ibex is a production-quality open-source 32-bit RISC-V CPU core designed for embedded control applications. It provides a highly configurable, synthesizable core written in SystemVerilog with support for RISC-V ISA extensions (I, E, M, C, B) and security features like PMP, lockstep, and data-independent timing. The core features a modular architecture with separate functional units, a sophisticated configuration system via YAML/Python, and extensive verification infrastructure including UVM testbenches, formal proofs, and co-simulation with Spike ISS. It is actively maintained and used in real silicon designs including OpenTitan.
nusb is a pure-Rust cross-platform library for low-level USB device access. It provides APIs for enumerating USB devices, opening them, claiming interfaces, and performing control, bulk, and interrupt transfers. The library is designed with an async-first approach while also supporting blocking usage through a custom `MaybeFuture` trait that can be waited on or awaited. Architecture is split into platform-specific backends (Linux usbfs, macOS IOKit, Windows WinUSB, WebUSB) with a common abstraction layer. Key features include zero-copy buffer allocation (Linux), hotplug event streams, fuzz testing for descriptor parsing, and high-level buffered IO adapters implementing standard `Read`/`Write` traits. The codebase is well-structured, thoroughly documented, and demonstrates high craftsmanship in areas like async transfer lifecycle management and cross-platform abstraction.
The openwifi repository provides a full-stack IEEE 802.11 (Wi-Fi) implementation for Software Defined Radio (SDR) hardware, specifically targeting Xilinx Zynq/ZynqMP SoCs with AD9361/AD9364 RF transceivers. It consists of a Linux kernel driver (split into multiple modules for OFDM, TX/RX interfaces, and side-channel processing) and user-space tools for hardware configuration, FPGA bitstream loading, and Wi-Fi interface management. The system supports standard Wi-Fi modes (AP, STA, ad-hoc, monitor) and experimental features like Channel State Information (CSI) extraction, packet injection/fuzzing, and radar sensing. The build system uses Buildroot to generate bootable SD card images, and the project includes extensive documentation for experimentation and hardware bring-up.
This is the Intel RealSense SDK 2.0 (librealsense), a cross-platform C++ library for controlling and streaming data from Intel RealSense depth cameras (D400, D500 series). It provides a unified API for depth, color, infrared, and IMU streams, with hardware abstraction layers for USB (libusb, WinUSB, USBHost), UVC, HID, MIPI, and DDS (Data Distribution Service) network transport. The SDK includes a rich processing pipeline with composable filters (alignment, point cloud generation, decimation, temporal/spatial filtering, HDR merge, colorization) and supports GPU acceleration via CUDA, HIP, OpenGL, and NEON SIMD. It is not a single application but a library with multiple end-user tools (RealSense Viewer, firmware updater, ROS bag converter, DDS adapter, REST API server) and extensive language wrappers for Python, C#, Java/Android, Unity, Unreal Engine, MATLAB, OpenCV, and OpenNI2. The codebase is well-engineered with a modular architecture, extensive unit/integration tests (including live hardware tests), and a comprehensive build system (CMake with vendored third-party dependencies). While the core is actively maintained and demonstrates strong craftsmanship, the large surface area of wrappers and vendored dependencies introduces some technical drift (e.g., outdated ROS Kinetic generated headers, old Unity project version).
The Universal Intel Chipset Device Updater is a Windows PowerShell utility that automates the detection, download, verification, and silent installation of Intel Chipset Device Software (INF files). It scans the system for Intel chipset hardware, matches detected devices against a curated database of INF packages, downloads the correct installer from primary (GitHub) or backup mirrors, verifies integrity via SHA-256 hashes and Intel digital signatures, creates a system restore point, and installs the INF files without unnecessary drivers or bloatware. The tool supports interactive, automatic, and quiet modes, making it suitable for home users, IT technicians, and MDM deployments (Intune, SCCM, Workspace ONE, PDQ Deploy). Architecturally, the system is composed of several PowerShell scripts with batch launchers, distributed as a self-extracting executable (SFX). The main updater script (universal-intel-chipset-device-updater.ps1) orchestrates the workflow: hardware detection via get-intel-hwids.ps1, database parsing from Markdown files, download management, multi-layer security verification, and installation. A companion INF extractor script (universal-intel-chipset-inf-extractor.ps1) handles extraction from modern Intel installers using NanaZip. The codebase emphasizes safety with self-hash verification, automatic update checks, EOL package handling, and cAVS audio conflict safeguards. While primarily an application, the repository also contains data assets: a comprehensive INF database (intel-chipset-infs-latest.md with 6954 entries), download lists with SHA-256 hashes, and extensive documentation including AI audit reports and deployment guides. These data files are tightly coupled to the tool's operation but represent a structured, maintainable knowledge base for Intel chipset support across generations.
Apio is a command-line interface (CLI) tool designed to streamline FPGA hardware development workflows. It acts as a wrapper and manager for open-source EDA toolchains (Yosys, Nextpnr, Verilator, GTKWave) and hardware drivers, supporting multiple FPGA architectures (ICE40, ECP5, GOWIN, XILINX) and over 80 development boards. The tool automates the full lifecycle of FPGA projects, including initialization, linting, synthesis, place-and-route, simulation, and bitstream upload to hardware. Architecturally, Apio follows a modular design with a Click-based CLI layer that delegates heavy build tasks to a SCons subprocess. Communication between the CLI and SCons is handled via Protocol Buffers to avoid global state sharing. The codebase includes robust package management for downloading and installing toolchains, cross-platform support for Linux, macOS, and Windows, and a comprehensive test suite using pytest. It is a professional-grade tool with strong engineering practices, including CI/CD pipelines and semantic versioning. Technical drift is moderate due to the volatile nature of SCons APIs and the reliance on external toolchain versions. There is also a noted inconsistency in Python version usage (mixing 3.9 compatibility checks with 3.10+ match statements). However, the repository is actively maintained with recent commits and a healthy issue resolution rate. The codebase is suitable for reuse in FPGA tooling projects, particularly the package management and IPC patterns.
Tetra3D is a pure-Go 3D game engine and rendering library built on top of Ebiten (a 2D game library). It provides a full scene graph with nodes, models, cameras, lights, materials, and animations, along with collision detection, particle systems, text rendering, and pathfinding grids. The architecture is a library with a rich set of examples demonstrating each feature. Key entry points include the tetra3d package root, Camera.RenderScene() for rendering, and gltf.LoadGLTF() for asset loading. Data flows involve loading GLTF/GLB files (with custom Blender exporter metadata), constructing a scene graph, and rendering per frame with support for lighting, shadows, and transparency. External dependencies are Ebiten for rendering/input, qmuntal/gltf for GLTF parsing, tanema/gween for tweening, and golang.org/x/image for font rendering. The codebase includes SIMD-optimized matrix math, a comprehensive vector library, and a Blender addon for exporting scenes with engine-specific properties.
This repository provides the complete design and firmware for the Smart Plant, an ESP32-S2 based IoT device for monitoring soil moisture, ambient temperature, humidity, and illuminance. The firmware, built on the ESPHome framework, publishes sensor data to Home Assistant via MQTT and displays it on a 2.9-inch ePaper screen. It employs a sophisticated deep-sleep architecture to achieve 40-50 days of battery life, with careful power management of sensors and MQTT connections. The architecture is centered around a highly modular ESPHome YAML configuration. The `examples/multi-device/packages/smart_plant_base.yaml` file serves as a reusable base package, enabling fleet management through YAML substitutions and overrides. This pattern allows users to deploy multiple devices with a shared core configuration, customizing only device-specific parameters like MQTT topics and sensor calibrations. The data flow is strictly sensor-to-cloud, with retained MQTT messages ensuring Home Assistant entities remain available during the device's deep sleep cycles. Beyond firmware, the repository encompasses the full hardware design. The PCB is designed in Autodesk Eagle, and the 3D-printable enclosure is provided in both FDM (STL) and SLA (STEP) formats, originating from CATIA. The project is accompanied by professional Sphinx documentation hosted on ReadTheDocs, including assembly guides, safety information, and programming instructions. Overall, this is a high-quality, production-ready IoT project. The ESPHome base package is a standout reusable component for anyone building battery-powered ESPHome sensors. The hardware designs are complete and manufacturable. While the documentation contains minor copy-paste errors (e.g., referencing 'Smart Powermeter') and mixed-language comments in the YAML configs, the core firmware architecture and hardware design are exceptionally well-executed.
GPU-T is a Linux desktop utility for comprehensive GPU information and monitoring, positioned as a GPU-Z alternative for Linux. It provides real-time sensor data (clocks, temperatures, power, fan speeds), static hardware specifications from JSON databases and sysfs, and detection of API capabilities (Vulkan, OpenCL, CUDA, etc.) through a modular probe system. The application follows the MVVM pattern with Avalonia UI and features a sidecar process for NVIDIA-specific NVAPI/NVML interactions to ensure stability and isolate native interop. Hardware detection relies on sysfs paths, external tool execution, and vendor-specific databases, with user override capabilities for hardware specifications. The modular design separates concerns into probes for hardware polling, advanced providers for feature detection, and utilities for common tasks like settings management and shell command execution.
Gobot is a Go framework for robotics, physical computing, and the Internet of Things. It provides a consistent hardware abstraction layer (HAL) over dozens of single-board computers (Raspberry Pi, BeagleBone, Intel Edison, Jetson, etc.), microcontrollers (Arduino via Firmata, Digispark), and communication protocols (GPIO, I2C, SPI, BLE, serial, MQTT, NATS, MAVLink). The architecture is modular: platform-specific adaptors implement core interfaces (DigitalPinner, PWMPinner, I2cBusAdaptor, etc.) and are composed from reusable building blocks in the `platforms/adaptors` package. Drivers for sensors, actuators, displays, and robots (Sphero, Parrot drones, DJI Tello, GoPiGo3) are organized by bus type (gpio, i2c, spi, ble, aio, onewire, serial) and share a common lifecycle pattern with event publishing and command registration. A built-in HTTP API server (with optional basic auth and CORS) exposes robot state and commands over REST and Server-Sent Events, and includes an embedded web UI (Robeaux). The framework supports both high-level orchestration via `Robot` and `Manager` and low-level 'metal' usage for direct hardware control. External dependencies include `periph.io` for GPIO, `tinygo.org/x/bluetooth` for BLE, `gocv.io/x/gocv` for computer vision, and `go.bug.st/serial` for serial communication. The codebase is extensively tested with mock filesystem and syscall infrastructure, and uses functional options for configuration throughout.
LibreHardwareMonitor is a free, open-source hardware monitoring application for Windows (with partial Linux support) that reads temperatures, fan speeds, voltages, loads, clock speeds, and other sensor data from CPUs, GPUs, motherboards, storage devices, network adapters, power supplies, batteries, and various fan/water cooling controllers. The architecture is a Windows Forms desktop application (LibreHardwareMonitor.Windows.Forms) backed by a reusable .NET library (LibreHardwareMonitorLib) that abstracts hardware access through interfaces (IHardware, ISensor, IControl) and a visitor pattern for traversal. Key entry points include the MainForm UI, the Computer class that orchestrates hardware enumeration, and an embedded HTTP server providing REST/JSON and Prometheus endpoints. Data flows from low-level hardware interfaces (LPC I/O, MSR, SMN, SMBus, HID, NVAPI, ADL, WMI, IPMI, SMART) through sensor objects with min/max tracking and history compression, to the UI tree view, system tray icons, logging, and web clients. External dependencies include the Aga.Controls tree view library, HidSharp for USB HID, PawnIO kernel driver for low-level I/O, and several platform-specific native APIs. The codebase is large and well-structured with clear separation of concerns, but contains some monolithic files, outdated JavaScript libraries (jQuery 1.7.2, Knockout 2.1.0), and hardcoded hardware-specific mappings that require ongoing maintenance.
This repository is a curated suite of 152 Claude AI skills (76 builder + 76 paired checklist reviewer archives) for generating structured Excel workbooks across the automotive engineering lifecycle. Domains include ISO 26262 functional safety, ISO/SAE 21434 cybersecurity, ISO 21448 SOTIF, ASPICE, AUTOSAR, SysML/MBSE, diagnostics (UDS, DBC, ODX), calibration (A2L), quality tools (APQP, PPAP, FMEA), and program management. Each `.skill` file is a ZIP archive containing SKILL.md, Python generators/reviewers, references, and shared utilities. Builders produce multi-tab xlsx workbooks from JSON input; reviewers validate existing workbooks and emit compliance checklists with dashboards. The suite is maintained via an autonomous weekly cycle (plan, polish, docs, release), with status tracking, chain-contract audits, and known issue catalogs. While the concept is robust, many shipped skills suffer from documentation/code drift (advertised check counts mismatch actuals), silent failures (empty workbooks certified as compliant), and duplicated shared scripts across 152 archives.
This repository contains the RISC-V Advanced Core-Local Interrupt Controller (ACLIC) specification document, which defines extensions for fast interrupt handling in RISC-V processors. It includes detailed AsciiDoc specification chapters, example handler assembly code for various interrupt processing models (software dispatcher, fast handler, and push-pop handler), a test plan for architectural verification, and build infrastructure (Makefile, CI workflows) to produce PDF and HTML outputs. The repo is primarily a specification artifact with supporting code examples intended for hardware implementers and compiler developers. It is not a standalone software application but a technical reference with reusable assembly patterns.