What do you fear most after deploying IoT devices at scale? Memory vulnerabilities hidden deep in the firmware that make devices freeze or run wild, driving up after-sales and maintenance costs. This problem deserves particular attention on Wi-Fi chips. Chip firmware has to process "untrusted input" arriving over the air, and any memory-access flaw can become a potential attack entry point. That is why the Linux kernel, Android and Chromium have all been adopting Rust: it eliminates memory hazards at compile time while balancing safety and performance, offering a new option for resource-constrained embedded development.

Realtek has officially released the Ameba Rust SDK, providing Rust-based embedded firmware development support for IoT applications. It supports the RTL8721F and covers hardware peripherals, Wi-Fi networking, and the development toolchain. Its core architecture offers the following:

A pure Rust runtime environment: Taking advantage of the dual-core hardware architecture, low-level Wi-Fi protocol processing and wireless communication are handled by a dedicated network core, while the application core focuses on running Rust firmware, providing a clean, highly reliable native Rust environment;
End-to-end support from peripherals to wireless networking: Unlike MCU solutions that only cover basic peripherals, Ameba extends Rust's safety guarantees to the Wi-Fi protocol and network stack, fully enabling Wi-Fi connectivity, TCP/IP communication and OTA upgrades, so Rust development covers application scenarios from hardware control to wireless networking;
Deep integration with the open-source Rust ecosystem: Compatible with the embedded-hal 1.0 standard, allowing you to reuse the rich set of general-purpose peripheral drivers from the Rust community.

Let's start with a live demo on real hardware, simulating a typical IoT scenario of "device status reporting and command delivery":

Wi-Fi connectivity and bidirectional MQTT communication in Rust

In the demo, the RTL8721F development board is compiled and flashed with a single command. After connecting to Wi-Fi and obtaining an IP address, it connects to an MQTT broker, establishes a session and subscribes to ameba/cmd. The board then publishes a status counter every two seconds, which the subscriber displays in sync. Another client acts as a publisher and sends a control command to ameba/cmd; the board receives it and prints it to the serial log in real time.

System Architecture and Standards Support

The Ameba Rust SDK uses a strict no_std bare-metal design, targeting IoT applications with limited SRAM and demanding requirements for memory footprint and execution efficiency.

At the hardware architecture level, the SDK fully leverages the dual-core design of the RTL8721F: the network core (NP) runs precompiled C firmware to ensure the efficiency of the low-level Wi-Fi RF and MAC layers, while the application core (AP) runs Rust firmware, providing native Rust development capability.

To keep the code compatible with the open-source Rust ecosystem, the SDK driver layer fully adopts the community's latest embedded-hal 1.0 standard interfaces and is built on the Embassy cooperative async runtime. Developers can implement cooperative multitasking with Rust's native async/await syntax, without the thread-stack overhead of a traditional RTOS. This saves SRAM and lets constrained MCUs handle concurrent tasks with ease.

Protocol Stack and Hardware Abstraction Layer

For network communication, the SDK integrates smoltcp, the lightweight TCP/IP stack from the Rust ecosystem, and supports the Embassy-net async networking framework. Developers can directly use mature Rust networking components to implement DHCP and TCP/UDP communication, and build IoT applications based on STA connections or basic SoftAP mode, without redeveloping the network protocol stack from scratch.

For the complex network authentication step of a Wi-Fi connection, the Wi-Fi driver on the application core implements the WPA2-PSK 4-way handshake and PBKDF2 key computation in pure Rust. This process involves computationally intensive key derivation (4096 PBKDF2 iterations), ciphertext unpacking and state machine transitions, and is one of the places in a wireless protocol stack where buffer overflows most easily occur in traditional C code. Implementing the authentication logic natively in Rust prevents many classes of memory-access errors at compile time, further improving the security of wireless connections.

At the hardware abstraction layer (HAL), the SDK implements drivers for 11 common peripheral types, including GPIO, UART, SPI, I2C, ADC, GDMA, Timer, Watchdog, RTC, Thermal and CAN, together with ready-to-run example projects, greatly lowering the barrier to evaluation and porting. For the C functions already burned into the chip ROM, the SDK introduces a zero-overhead ROM FFI binding mechanism that jumps directly to them through static symbol mapping, providing a safe wrapper without any additional Flash usage.

Automated Toolchain

To simplify cross-compilation and firmware packaging, Realtek has also released an official build toolchain: the project generator ameba-generate and the build orchestration tool xtask. Developers can generate a standard project through an interactive menu or the command line, then use standard Cargo commands to automate the whole flow of Rust compilation, symbol trimming and flashing image (app.bin) generation.

Open-Source Ecosystem

So, is it actually reliable? It is real Rust, it really runs, and it really fits into the ecosystem.

The WPA2 4-way handshake and PBKDF2 key derivation are implemented in pure Rust on the application core, with the source code publicly available;
Rust controls peripherals and Wi-Fi networking, with ready-to-run example projects

embedded-hal 1.0 and Embassy, following the community's mainstream interfaces

From project generation, compilation and packaging to flashing and running, the Ameba Rust SDK now forms a complete development loop. The repository is open, and you are welcome to evaluate and try it out. Tell us in the Issues what you most want it to support first!