Embassy is a next-generation embedded framework for Rust that enables asynchronous programming on microcontrollers using async/await syntax. It provides Hardware Abstraction Layers (HALs) for multiple MCU families (STM32, Nordic nRF, Raspberry Pi RP2040/RP23xx, TI MSPM0, NXP MCX-A, etc.), an async executor for cooperative multitasking, timekeeping utilities, networking stack, USB device/host stack, Bluetooth support, bootloader/DFU capabilities, cryptographic primitives, and synchronization primitives. The framework emphasizes safety, correctness, and energy efficiency through Rust's compile-time guarantees, with an executor that automatically enters low-power sleep when idle. Applications are structured around peripheral initialization, async task spawning via #[embassy_executor::task], and event-driven communication using Embassy's synchronization primitives.
Microsoft's official Rust framework for developing Windows drivers. The codebase is a multi-crate workspace with clean layering: `wdk-sys` provides raw bindgen-generated FFI bindings to the Windows Driver Kit (WDM/KMDF/UMDF APIs) with feature-gated API subsets (gpio, hid, spb, storage, usb, wdf); `wdk` layers safe idiomatic wrappers on top (no-std formatting buffers, WDF spinlock/timer wrappers, print macros); `wdk-build` powers driver `build.rs` scripts by auto-detecting WDK installations via registry/env vars and emitting compiler flags, linker args, and cfg settings; and `cargo-wdk` is a Cargo extension CLI for scaffolding (`new`), building (`build`), and cleaning (`clean`) driver projects including signing and packaging. Supporting crates `wdk-alloc` and `wdk-panic` provide kernel-mode global allocation (ExAllocatePool2/ExFreePool) and panic handling (KeBugCheckEx/OutputDebugStringA+abort), while `wdk-macros` implements a proc macro for typesafe dispatch of WDF function-table calls. The architecture is a layered library plus CLI toolchain, not a monolith or service; it serves driver developers as both a framework and a build tool. Key entry points are the `cargo wdk` CLI, the `wdk_build::configure_wdk_binary_build()`/`configure_wdk_library_build()` functions invoked from build scripts, and the `wdk` public API. The primary build data flow is: Cargo `[package.metadata.wdk]` manifest metadata → `wdk-build` config → bindgen → generated FFI bindings → driver binary, with WDK/SDK version and install-path detection from registry keys and environment variables. External dependencies include the Windows Driver Kit, LLVM/Clang, bindgen, and Windows packaging/signing tools (signtool, inf2cat, stampinf, certmgr). Engineering quality is genuinely strong: clean crate separation, a testable provider abstraction in the CLI (exec/fs/metadata/wdk_build), secret-redacting command logging, trybuild compile-fail tests, macrotest snapshots pinned per stable/beta/nightly toolchain, emulated-workspace integration tests, and CI spanning multiple WDK/LLVM/Rust versions with CodeQL, cargo-audit, dependabot, and release-plz release automation. Known caveats: the bindgen pipeline is fragile against WDK header changes, a proc-macro cache does not invalidate when source types change, thousands of NTSTATUS constants are manually maintained, LLVM is pinned to 17.0.6 due to an upstream ARM64 bug, and the README explicitly states the project is not yet recommended for production driver use. The repository is Windows-only by domain necessity.
This repository is a comprehensive IoT device driver library for .NET nanoFramework. It provides bindings for hundreds of sensors, actuators, displays, and communication modules (e.g., BME280, SSD1306, NFC, Modbus, cellular modems, GPS). The architecture is a collection of independent driver projects, each with its own samples, tests, and documentation. Shared utility libraries (e.g., System.Device.Model, NumberHelper, SpanByte compatibility shims) support cross-cutting concerns. The codebase is actively maintained with frequent commits, but the sheer number of drivers (300+) leads to varying quality, some code duplication (e.g., SpanByte classes in multiple locations), and partially auto-generated code. Networking components like DHCP server, DNS server, and Home Assistant MQTT integration extend the library beyond raw sensor access. The primary use case is building embedded IoT applications on microcontrollers (ESP32, STM32) running nanoFramework.