// the find
embassy-rs/embassy
Modern embedded framework, using Rust and async.
Embassy is an async embedded framework for Rust that replaces traditional RTOS patterns with cooperative async/await tasks compiled to state machines. It ships HALs for STM32, nRF, RP2040/RP235x, and a growing list of other MCU families, plus networking, USB, Bluetooth, and a bootloader. Aimed at embedded Rust developers who want to escape FreeRTOS or bare-metal interrupt spaghetti.
- The async executor design is genuinely clever: tasks become state machines with zero dynamic allocation, no per-task stacks, and automatic sleep-when-idle — this is not just marketing, the architecture actually achieves it.
- embassy-stm32 covers an unusually wide range of STM32 families with generated code from SVD files, saving enormous amounts of manual register-mapping work across hundreds of chip variants.
- The peripheral ownership model uses Rust's type system to enforce at compile time that you can't accidentally share an SPI bus unsafely or use a pin for two purposes — errors that would be silent runtime bugs in C.
- The shared-bus abstractions (I2C, SPI) and the embassy-embedded-hal compatibility layer mean existing embedded-hal drivers work without rewriting, which matters for ecosystem adoption.
- No single Cargo workspace — the repo uses linked projects instead, which makes local development and cross-crate refactoring genuinely awkward, and Rust Analyzer setup requires manual configuration that trips up newcomers.
- Task functions must have 'static lifetimes on all parameters, which is a real ergonomic cliff: you end up fighting the borrow checker the moment you try to pass anything non-trivial to a spawned task, and the error messages aren't helpful.
- HAL coverage is uneven: STM32 and nRF are mature, but newer additions like embassy-imxrt and embassy-mcxa are sparse (imxrt has no I2C or ADC), so you may hit a peripheral that simply isn't implemented yet with no clear timeline.
- MSRV policy is 'latest stable only', which is hostile to projects with locked toolchains or Yocto/buildroot environments — a common constraint in production embedded work.