root@amaltsev >:~/blog$ grep -l "rust" -r ~/blog
27 posts on rust.
root@amaltsev >:~/blog$ grep -l "rust" -r ~/blog
This final article connects the embedded AI device to the real world. It describes how inference results leave the MCU, travel through MQTT and HTTP, land in a Rust backend.
The TinyML lifecycle on a microcontroller, from dataset preparation and model training to TensorFlow Lite Micro on bare metal, with the model bound into Rust firmware through a custom FFI wrapper.
This article covers the hardware I use in my AI device project, why I chose it, and how I structured the firmware in Rust.
This series covers the building of an ESP32-S3 device with ML built right into the firmware, along with the decisions, compromises, and challenges that came up along the way.
This project converts raster images into cross-stitch and needlepoint patterns. The output is a structured, printable and editable SVG pattern, with full control over the size and the color palette.
A playground for the micro:bit v2.21: GPIO, I2C, SPI, UART, ADC and PWM experiments on the nrf52833.
A step-by-step template for a Cortex-M Rust project: config.toml, rust-toolchain.toml, memory.x, probe-rs, defmt and the panic handler.
Software development runs in a cycle: write, run, check, fix. On a desktop, debugging is simplified by built-in logs, breakpoints and step-by-step code execution directly in the IDE.
In general, developing programs for an MCU is aimed at obtaining some information from the surrounding world, performing necessary calculations with this data and interacting back.
A playground for the Raspberry Pi Pico W: Wi-Fi, GPIO, I2C, SPI, UART, ADC and PWM experiments on the RP2040.
Firmware for hardware that cannot be patched in the field has a different cost of failure than an application you can restart.
GPIO stands for general purpose input/output. It is a type of pin found on an integrated circuit that does not have a specific function.
Rust handles memory through its type system, and a handful of questions follow.
This is the second part of my exploration into the stages and optimizations of Rust compilation, focusing now on embedded systems development.
Embedded Rust firmware is size constrained because the microcontroller has very little memory to spend.
Rust turns source code into a machine-executable binary through a pipeline of intermediate representations.
An Anchor program that stores and updates user-defined key-value entries on-chain, a small favorites manager.
Two Anchor programs where one calls the other through a CPI, with a System Program transfer alongside it.
A minimalist on-chain guessing game built with Rust and Anchor: the contract picks a number, the player guesses it.
A minimal native Rust Solana program that increments and decrements an on-chain counter owned by the user's keypair.
RestOn is an agent that generates backend code from a text query. It is built in Rust on top of Actix-web.
How to manage Rust with rustup: release channels, toolchain overrides, components and build profiles.
A multi-threaded HTTP server written with the Rust standard library only: thread pool, TCP listener and static file serving.
An async RESTful notes service built with Actix-Web, Tokio, SQLx and SQLite: the architecture, the routes and the setup.
A terminal inventory manager built with Rust and Cursive: create, list and delete items, persisted in a flat JSON file.
A keyboard-driven Pomodoro timer built with Rust and Cursive, with a configurable session length and a minimal interface.
A Rust and wasm-bindgen experiment: build a WebAssembly tax calculator and serve it from a static page.
~/blog: 27 matches
root@amaltsev >:~/blog$ cd ~/blog && ls -la
The whole directory is one click away. Every post, filed by subject.
Four channels, all of them read. Pick the one that suits the question.
Where to start: a short question goes to Telegram, a brief goes to email.
No match.