HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
embassy-rs
embassy
Rust2021–2026
embassy-rs / embassy

embassy

Modern embedded framework, using Rust and async.

33Distinct people
33Mentions
0Explicit recommenders
10.1KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

Modern embedded framework, using Rust and async.

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

No other repository is repeatedly linked in the same discussions.

This week on Hacker News

Nov 9–Nov 16 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/16/2026, 3:59:04 AM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year33 dated mentions

Observed mentions: 2021-05-06 19:44:33 UTC to 2026-10-24 21:12:22 UTC.

02462021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 5 mentions; 1 submissions, 4 comments20212022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 3 mentions; 1 submissions, 2 comments2023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 7 mentions; 1 submissions, 6 comments20232024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 6 mentions; 1 submissions, 5 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 6 mentions; 1 submissions, 5 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 6 mentions; 1 submissions, 5 comments. Incomplete calendar period.2026*

* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC514
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC312
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC716
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC615
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC615
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC615

From the project README

An excerpt from the repository, fetched Nov 12, 2026.

Read the project’s introduction
Embassy Embassy is the next-generation framework for embedded applications. Write safe, correct, and energy-efficient embedded code faster, using the Rust programming language, its async facilities, and the Embassy libraries. Documentation - API reference - Website - Chat Rust + async ❤️ embedded The Rust programming language is blazingly fast and memory-efficient, with no runtime, garbage collector, or OS. It catches a wide variety of bugs at compile time, thanks to its full memory- and thread-safety, and expressive type system. Rust's async/await allows for unprecedentedly easy and efficient multitasking in embedded systems. Tasks get transformed at compile time into state machines that get run cooperatively. It requires no dynamic memory allocation and runs on a single stack, so no per-task stack size tuning is required. It obsoletes the need for a traditional RTOS with kernel context switching, and is faster and smaller than one! Batteries included Hardware Abstraction Layers HALs implement safe, idiomatic Rust APIs to use the hardware capabilities, so raw register manipulation is not needed. The Embassy project maintains HALs for select hardware, but you can still use HALs from other projects with Embassy. embassy-stm32, for all STM32 microcontroller families. embassy-nrf, for the Nordic Semiconductor nRF52, nRF53, nRF54 and nRF91 series. embassy-rp, for the Raspberry Pi RP2040 and RP23xx microcontrollers. embassy-mspm0, for the Texas Instruments MSPM0 microcontrollers. embassy-mcxa, for NXP's MCX-A series of microcontrollers. esp-rs, for the Espressif Systems ESP32 series of chips. Embassy HAL support for Espressif chips, as well as Async Wi-Fi, Bluetooth, and ESP-NOW, is being developed in the esp-rs/esp-hal repository. ch32-hal, for the WCH 32-bit RISC-V(CH32V) series of chips. mpfs-hal, for the Microchip PolarFire SoC. py32-hal, for the Puya Semiconductor PY32 series of microcontrollers. ra-hal, for the Renesas RA family of microcontrollers. Time that Just Works - No more messing with hardware timers. embassy_time provides Instant, Duration, and Timer types that are globally available and never overflow. Real-time ready - Tasks on the same async executor run cooperatively, but you can create multiple executors with different priorities so that higher priority tasks preempt lower priority ones. See the example. Low-power ready - Easily build devices with years of battery life. The async executor automatically puts the core to sleep when there's no work to do. Tasks are woken by interrupts, there is no busy-loop polling while waiting. Networking - The embassy-net network stack implements extensive networking functionality, including Ethernet, IP, TCP, UDP, ICMP, and DHCP. Async drastically simplifies managing timeouts and serving multiple connections concurrently. embassy-ptp-driver provides a network-stack-independent interface for reading and adjusting PTP hardware clocks. Bluetooth The trouble crate provides a Bluetooth Low Energy 4.x and 5.x Host that runs on any microcontroller implementing the bt-hci traits (currently nRF52, nrf54, rp2040, rp23xx and esp32 and serial controllers are supported). The nrf-softdevice crate provides Bluetooth Low Energy 4.x and 5.x support for nRF52 microcontrollers. The embassy-stm32-wpan crate provides Bluetooth Low Energy 5.x support for stm32wb microcontrollers. LoRa - The lora-rs project provides an async LoRa and LoRaWAN stack that works well on Embassy. USB - embassy-usb implements a device-side USB stack. Implementations for common classes such as USB serial (CDC ACM) and USB HID are available, and a rich builder API allows building your own. Bootloader and DFU - embassy-boot is a lightweight bootloader supporting firmware application upgrades in a power-fail-safe way, with trial boots and rollbacks. Sneak peek use defmt::info; use embassy_executor::Spawner; use embassy_time::{Duration, Timer}; use embassy_nrf::gpio::{AnyPin, Input, Level, Output, OutputDrive, Pin, Pull}; use embassy_nrf::{Peri, Peripherals}; // Declare async tasks #[embassy_executor::task] async fn blink(pin: Peri<'static, AnyPin>) { let mut led = Output::new(pin, Level::Low, OutputDrive::Standard); loop { // Timekeeping is globally available, no need to mess with hardware timers. led.set_high(); Timer::after_millis(150).await; led.set_low(); Timer::after_millis(150).await; } } // Main is itself an async task as well. #[embassy_executor::main] async fn main(spawner: Spawner) { let p = embassy_nrf::init(Default::default()); // Spawned tasks run in the background, concurrently. spawner.spawn(blink(p.P0_13.into()).unwrap()); let mut button = Input::new(p.P0_11, Pull::Up); loop { // Asynchronously wait for GPIO events, allowing other tasks // to run, or the core to sleep. button.wait_for_low().await; info!("Button pressed!"); button.wait_for_high().await; info!("Button released!"); } } Examples Examples are found in the examples/ folder separated by the chip manufacturer they are designed to run on. For example: examples/nrf52840 run on the nrf52840-dk board (PCA10056) but should be easily adaptable to other nRF52 chips and boards. examples/nrf5340 run on the nrf5340-dk board (PCA10095). examples/stm32xx for the various STM32 families. examples/rp are for the RP2040 and RP235x chips. examples/mcxa266 run on the FRDM-MCXA266 board. examples/mcxa577 run on the FRDM-MCXA577 board. examples/std are designed to run locally on your PC. Running examples Install probe-rs following the instructions at https://probe.rs. Change directory to the sample's base directory. For example: cd examples/nrf52840 Ensure Cargo.toml sets the right feature for the name of the chip you are programming. If this name is incorrect, the example may fail to run or immediately crash after being programmed. Ensure .cargo/config.toml contains the
Read the full README on GitHub

What Hacker News says

7 sources
Unless you're overloading the |= to death that assignment isn't checking any of the things that are being checked (either at compile or runtime) in the rust code This specific example is from the concurrency chapter so it's already handling multiple threads and that's why all those checks are needed. This is a random example I found to blink a led on a rp2040: > let mut led_pin = pins.gpio25.into_push_pull_output(); > > loop { > led_pin.set_high().unwrap(); > delay.delay_ms(500); > led_pin.set_low().unwrap(); > delay.delay_ms(500); > } And this is how to do it using embassy, which is an async framework for embedded in rust: https://github.com/embassy-rs/embassy/blob/main/examples/rp/...
In How Rust can facilitate new contributors while decreasing vulnerabilities [pdf]
In esp-hal, they offer both sync and async I2C implementations, depending on what works best for an application. Since the async implementation is gated by a feature, it may not show up in the docs you linked. Async implementation: https://github.com/esp-rs/esp-hal/blob/main/esp-hal-common/s... You can also see the async feature mentioned here: https://docs.rs/crate/esp32s2-hal/latest/features There is a very brief example of using async i2c here: https://github.com/esp-rs/esp-hal/blob/main/esp32s3-hal/exam... (you can see that it is using `lis3dh_async`, which requires async i2c) Not specific to the ESP platforms, but Embassy offers a more useful example of async i2c here: https://github.com/embassy-rs/embassy/blob/main/examples/rp/... (and it would work the same on ESP)
In Rust on Espressif chips
At work, we have a non-async RTOS https://hubris.oxide.computer/ though it is a bit harder to use than "add a dependency in Cargo.toml" like most projects. The original designer of Hubris, Cliff, has his own async RTOS that he uses for personal projects. He recently has been writing some blog posts on this that may be of interest to you: * http://cliffle.com/blog/async-inversion/ * http://cliffle.com/blog/composed-concurrency-in-drivers/ The former is a general introduction to async, and the second is about applying it to write an I2C driver. There already are some general RTOSes for Rust, and they do tend to use async: * https://rtic.rs/2/book/en/ * https://github.com/embassy-rs/embassy (this one is used in the article) * https://tockos.org/
In Asynchronous Rust on Cortex-M microcontrollers
> others are just batshit-crazy from my pov (the macro system for instance) Ah yes, I won't disagree here; macros get very complex very fast. It's one of the more undercooked parts of Rust. > e.g. I don't really see the usefulness of async-await in a systems programming language This really depends on the task, but honestly it is genuinely useful. Even in places you wouldn't expect, e.g. in embedded: https://github.com/embassy-rs/embassy And AFAIK there are plans to use async Rust in the Linux kernel.
In I use C when I believe in memory safety

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.