This is the Rust userland library for Tock OS, providing safe abstractions over Tock syscalls (command, subscribe, allow) and a comprehensive set of driver APIs for peripherals such as GPIO, I2C, SPI, console, sensors, display, and networking. It includes a runtime with startup code for ARM, RISC-V, and x86 processes, a build system for generating Tock Binary Format (TBF) and TAB archives, and a full unit-testing framework with a fake kernel and fake drivers that enable testing Tock applications on a host machine. The architecture is trait-based, with drivers generic over a `Syscalls` implementation, allowing compile-time dependency injection for testing. This repo is not a standalone application but a library and framework for building Tock processes. It demonstrates high craftsmanship in its safe resource management patterns (e.g., `share::scope` for scoped buffer allocation) and includes a standalone micro-formatting crate (`ufmt`) that is 6-40x smaller than `core::fmt`.
XCap is a cross-platform screen capture library written in Rust, supporting Linux (X11, Wayland), macOS, Windows, and HarmonyOS (OHOS). It provides a unified API for capturing images of monitors and windows, as well as video recording (currently work-in-progress). The library abstracts platform-specific implementations behind common `Monitor`, `Window`, and `VideoRecorder` structs, using native APIs such as XCB, PipeWire, CoreGraphics, AVFoundation, GDI, Windows Graphics Capture, and OHOS PixelMap. It is well-structured with clean error handling and modular platform modules, though some features like Wayland capture and window recording are still incomplete. The codebase demonstrates solid Rust engineering practices and is actively maintained.
rspirv is a Rust workspace providing comprehensive SPIR-V module processing functionality. It includes a core library (rspirv) with a low-level data representation (DR) for raw instructions and a higher-level structured representation (SR) with type-safe indices. The project also features a binary parser, an assembler, a disassembler CLI (rspirv-dis), and a code generator (rspirv-autogen) that derives Rust types from the official SPIR-V JSON grammar. The parser supports custom consumers via the Consumer trait, enabling streaming or custom processing. The builder (dr/build) allows programmatic construction of SPIR-V modules. The lift module converts from DR to SR, bridging the two representations. The codebase is heavily auto-generated from the SPIR-V specification, ensuring spec compliance, but this also introduces risks of drift if the grammar submodule is not updated. The project is actively maintained with CI/CD pipelines, and the multi-crate workspace is designed for both library reuse and standalone tool usage.
Sorock is a Multi-Raft implementation in Rust that enables multiple Raft consensus processes to coexist in a single OS process for efficient resource sharing. The system implements a complete Raft consensus algorithm with optimizations including batched writes, heartbeat multiplexing, and Phi Accrual Failure Detector for adaptive leader failure detection. It provides gRPC services for client interaction (read/write operations) and includes CLI tools for cluster management (monitoring, remapping, syncing). The architecture follows a modular design where each shard maintains independent Raft state while sharing underlying storage and network connections.
nvml-wrapper is a Rust workspace providing safe, high-level bindings to the NVIDIA Management Library (NVML). It is a library crate, not an application: there are no binaries, servers, or CLIs. The workspace is split into `nvml-wrapper-sys` (low-level FFI bindings, including runtime loading of `libnvidia-ml.so`/`nvml.dll` via `libloading`) and `nvml-wrapper` (a safe, typed API). The primary entry point is `Nvml::init()`, which loads the NVML library and returns a handle; from there, `Device` exposes 100+ methods for querying GPU state such as memory, clocks, temperature, power, ECC, NvLink, vGPU, MIG, and GPM metrics. The crate also supports mutating operations like setting application clocks and fan speed, and includes a `legacy-functions` feature for older NVML versions.
dsperse is a distributed Zero-Knowledge Machine Learning (zkML) toolkit that decomposes ONNX neural network models into circuit-compatible segments for verifiable AI inference. The core Rust library provides model slicing, circuit compilation (using JSTprove backend), witness generation, and proof verification. It exposes both a CLI interface and Python bindings via PyO3/Maturin for integration into ML pipelines. The architecture follows a clear separation: the slicer module handles ONNX graph decomposition and tiling strategies (channel split, dimension split, spatial tiling), the pipeline orchestrates execution with memory-efficient tensor caching, and the backend trait enables pluggable ZK proving systems. Content-addressed storage with SHA256 hashing ensures artifact integrity across distributed execution. Notable constraints: the license explicitly restricts operational use without written permission from the IP owner, and the codebase relies on nightly Rust toolchain with specific git dependencies (tract-onnx, jstprove_circuits) that create version coupling risks. Security advisories are partially ignored in the audit configuration.