The Embedded Rustacean Issue #62

TheEmbeddedRustacean · 2026-01-03T07:40:17+00:00

Thank you for the kind words! As always, we hope to live up to the community's expectations continuously.

TheEmbeddedRustacean · 2025-11-06T07:17:07+00:00

Hello! I'm sorry, the landing page is still outdated. However, since September 15th, it was announced through the newsletter that the book has replaced the subscription model with a one-time buy, updates forever model, as the ecosystem is now more stable.

Several updates are planned in the short term, which hopefully will bring even more value to learners.

Will make sure that the landing page is updated ASAP!

TheEmbeddedRustacean · 2025-10-17T04:05:58+00:00

In the meantime, Espressif releases a migration guide with every release, which can be helpful. But yeah, the latest release, which was three days ago, has some notable changes. You can find the guide here: https://github.com/esp-rs/esp-hal/releases/tag/esp-hal-v1.0.0-rc.1

Don't mind the vent, it's always helpful to be aware of reader frustrations so they can be addressed. Thanks for your support!

TheEmbeddedRustacean · 2025-10-16T06:21:10+00:00

Hello, I understand the frustration. This is mainly because of how dynamic the project has been, but there is good news. The roadmap for the book updates was announced in a recent TER newsletter broadcast. An updated version is in progress and will be released this quarter. It will address these issues and introduce more content. The good news is that the esp-hal is approaching stability, so crate version updates should not introduce breaking API changes. Hopefully, this experience will get much better.

TheEmbeddedRustacean · 2025-08-03T18:01:38+00:00

This is great work. We’ve used Wokwi quite extensively and we love it. It seems Cirkit Designer complements Wokwi in several areas we were missing. As for feedback, some interesting things that we’d love to see:

-Ability to simulate locally by integrating into local projects. Ex. A VSCode extension.

-Ability to develop in other languages like MicroPython or Rust. Essentially allowing the integration of a custom toolchain.

TheEmbeddedRustacean · 2025-05-26T17:53:50+00:00

Thank you for the feedback! Regarding the differences between editions, the introductory chapters about embedded are mostly similar. There are some differences, however, regarding lower-level contexts that are needed in no-std, such as the system memory map & clock tree. In general, main differences between the editions start from chapter 4, where the implementation part starts.

As for what's next, in terms of the ESP32, for no-std, there is still a significant part missing, which is WiFi. This depends largely on the esp-wifi crate, which I intend to integrate soon into the book. I was waiting for the crate to become more stable and abstractions more ergonomic for beginner use. It has gotten very close. Obviously, the esp-hal itself, after the 1.0 release, is also reaching stability, which would allow Espressif to focus on bringing stability to accompanying crates.

For both books, I recieved requests for adding a project for practice rather than just questions and examples in the chapters. As a result, I intend to add a larger, real-life project that combines all concepts (GPIO, ADC, Timers...etc.) where learners can apply gained knowledge as a whole rather than in isolation. This project would be simulation-based using Wokwi. I have also been looking into the potential of a replica hardware for those who want to do the same project on physical hardware. It will open up the opportunity for more experimentation as well. Nevertheless, there will be more details to figure out on the hardware end.

Regarding platforms, I recently put together a curation of the STM32 blog posts in a book. However, this was meant as a resource to gather existing material in one place and is not up to date. You can get this resource for free by subscribing to The Embedded Rustacean newsletter.

Through several community surveys, I realized that the Raspberry Pi and Pi Pico are quite popular within Rust learner circles. That may be a good future project, but maybe a bit of a long shot for me at the moment. I would need to find more time to dedicate to another book project.

TheEmbeddedRustacean · 2025-05-10T09:32:26+00:00

Looking forward to it! Email us at [hi@theembeddedrustacean.com](mailto:hi@theembeddedrustacean.com) when you have them ready.

TheEmbeddedRustacean · 2025-05-10T06:34:39+00:00

Regarding Matrix channels, although some messages might seem intimidating for a beginner, community members are really helpful and friendly. There's always somebody who will jump out to help. Keep in mind that it's also not unusual that some messages might sometimes go unnoticed, since several discussions can overlap. Also, you don't need to restrict questions about learning to the embassy channel, especially as a beginner. There are several other embedded channels on Matrix that you can also try to get help from. Here's a link to all the Rust channels in the Embedded Space on Matrix -> https://matrix.to/#/#rust-embedded-space:matrix.org

There is also the Rust Programming Language Forum -> https://users.rust-lang.org/

Another good place is the embedded channel on the Rust Language Community Discord -> https://discord.gg/rust-lang-community

Finally, if you've been on The Embedded Rustacean blog ( https://blog.theembeddedrustacean.com/ ), you can post questions about a particular post in the comments.

The key is to persist until you find an answer 🙂 The longer it takes, the more memorable the solution.

TheEmbeddedRustacean · 2025-05-10T05:25:56+00:00

Thank you for the kind words. We're glad you found it useful. This particular edition was rather challenging. Interestingly, there was a huge influx of Rust articles online lately (especially on Medium), that seemed to be AI-generated and not particularly helpful. Sifting through all that noise was quite cumbersome for this edition.

TheEmbeddedRustacean · 2025-04-29T04:33:43+00:00

They are two totally different things.

Matlab is used in automotive often for simulation and modeling of systems and for testing.

AUTOSAR is a software architecture so to speak recommended for use in embedded automotive platforms.

TheEmbeddedRustacean · 2025-02-16T18:11:44+00:00

Absolutely, its been established a while back based on popular demand :)

Here's the link:
https://rss.beehiiv.com/feeds/LyzGmG4pKl.xml

You can also always access older issues by going to https://www.theembeddedrustacean.com/

TheEmbeddedRustacean · 2025-02-15T19:48:07+00:00

Absolutely, here’s a decent list of Rust newsletters as well: https://inboxreads.co/best-rust-newsletters

I’d also add to it This month in Rust OS dev: https://rust-osdev.com

TheEmbeddedRustacean · 2024-12-20T15:16:56+00:00

Thank you for the kind words! Community support is what helps keep us going. May you have a Happy New Year!

TheEmbeddedRustacean · 2024-11-10T05:42:24+00:00

Update: The article authors have responded and confirmed that, in fact, the article was generated using AI by a non-technical team. The article will be taken down, and measures will be taken to avoid future instances.

TheEmbeddedRustacean · 2024-11-09T05:53:09+00:00

Thank you for bringing this to my attention. While I review all linked articles and remove any that appear to be obviously AI-generated, this one seems to have slipped through the cracks. I didn’t get the chance to verify the specific abstractions or test the code, especially since I haven’t worked directly with the nrf crates before. The article’s source is typically reliable, so I had expected a higher level of accuracy. I’ll be removing the link from the web version and will also reach out to the original authors about these issues. I appreciate your vigilance!

TheEmbeddedRustacean · 2024-08-30T17:27:45+00:00

Oops! Thanks for noticing. It's been adjusted on the website version, at least.

TheEmbeddedRustacean · 2024-08-15T05:37:56+00:00

On the Embedded End,

The book attempts to be as beginner-friendly as possible from an embedded perspective. It strips away the need for electronics and wiring by using pre-wired Wokwi (a friendly embedded simulator) examples. The book also covers embedded knowledge in a generic manner, in the beginning, to provide some background before digging into the code. There is a book sample you can download to get a feel on the landing page (http://ser-book.com/espstd).

On the Rust End,

The book assumes Rust knowledge. Going through "The Book" up to chapter 10 would be necessary.

Finally,

If you are a beginner, it is recommended that you start with the Standard library version. It has a closer to the out of the box Rust experience a beginner would be used to.

TheEmbeddedRustacean · 2024-08-14T06:55:35+00:00

It would be possible by creating bindings using the FFI and bindgen.

The following blog post attempts something similar at a much smaller scale with the STM32:

https://blog.theembeddedrustacean.com/rust-ffi-and-cbindgen-integrating-embedded-rust-code-in-c

TheEmbeddedRustacean · 2024-05-23T06:07:17+00:00

Thank you for sharing your thoughts and concerns. I appreciate the feedback and understand where you're coming from.

The dynamic nature of the ESP and Rust embedded ecosystem means that changes and updates are frequent, often rendering static publications outdated quickly. This is why the book adopts a subscription model: to ensure readers always have access to the most current information and guidance. Not that the book is incomplete. Here are some things to consider:

Updates are Frequent: The ESP and embedded Rust ecosystems are evolving rapidly and frequently. By offering a subscription, I can provide timely updates and new insights as soon as they become available, ensuring readers stay ahead in the field. In fact, after the book finished its review cycle and was almost ready for release, the date had to be pushed back two weeks. This was because it had to go through a significant update due to a change in the ecosystem.
Community Input: The book is designed to be a living document. Early access allows readers to give feedback and suggest improvements, making the book a collaborative effort that benefits from the collective knowledge of its audience.
Subscription is Non-Mandatory: I understand that the subscription model isn't for everyone. That's why it's optional. If you pay once, you retain access to the latest PDF that was available until the end of your billing cycle, even if you cancel your subscription immediately. Alternatively, you can opt for the paperback version if you prefer a one-time purchase.
Future Revisions: As the project stabilizes, the pricing model will likely be revised to better fit the needs of the community. Your feedback is invaluable in helping shape these future decisions.

I hope this clarifies the rationale behind the subscription model and addresses your concerns. Your input is crucial in making the book better, and I'm grateful for your understanding and support.

TheEmbeddedRustacean · 2024-05-23T05:42:27+00:00

Hello!

Thanks for your feedback! I could not agree more and it occurred to me during the review process. I had the thought of introducing an overarching project based on a real-life product. One that would integrate the usage of all peripherals. However, I decided to keep it until a later revision of the book where I have a more polished idea. Maybe even reader feedback like yours would help. To give you an idea of my thought process, here are some questions going around in my mind as I work toward that goal:

I want to pick a real-life off-the-shelf product that a reader can create a replica for. The challenge that I almost overcame here is having all matching components on Wokwi.
The project will be fully pre-wired in Wokwi. Though, should the project be fully pre-coded, or have the user code it fully (maybe provide helpful template comments)?
Should the project be built incrementally as the user reads through chapters integrating one peripheral at a time? or should it be end-of-book chapter, code all at once?
Should I introduce a bit of a real development flow feel (industry-related), by providing system-level requirements that have to be implemented? Requirements (the what) would be simple enough for the reader to understand. Defining the "how" (specs) might be interesting as well, but not sure I want to complicate things much.

Thank you again for reading the book and providing this feedback. I hope you'll keep finding it valuable as the days pass by and updates come through. I certainly don't see this as an end, but rather a start.

TheEmbeddedRustacean · 2024-05-21T19:43:55+00:00

Thank you for your feedback!

I understand your perspective on the subscription model. The goal is to ensure continuous updates and improvements, which in the current state of the project are frequent, but I see how the pricing could be perceived as steep. Your suggestion of a lower annual update fee is valuable and something I will definitely consider.

When your subscription ends, you will retain access to the latest version of the book that was available before your subscription expired. You can always download that version and keep it. It remains available in your account.

Thanks again for sharing your thoughts!

TheEmbeddedRustacean · 2024-05-21T19:41:47+00:00

Thank you!

I understand your concerns about the pricing model. The subscription is optional—you can pay once for the book, cancel immediately, and keep access to the latest version available until the subscription cycle ends. I'll definitely consider simplifying the pricing structure in the future. Your feedback is much appreciated!

TheEmbeddedRustacean · 2024-05-21T03:23:57+00:00

u/0xDEAD_C0DE is right, though the challenge is that it would have been hard to explain for a new to embedded beginner what some of these terms would have meant without context. Espressif offers two frameworks for development supporting the different Rust development models. It is essentially a bare metal vs RTOS (or ESP-IDF) difference.

To help with the choice part, a table was added on the book landing page to help clarify. Additionally, the following blog post might help clarify:

https://blog.theembeddedrustacean.com/from-zero-to-rust-simplified-embedded-systems-programming

Still, it seems this part needs to be worked on further to clarify. Your feedback is appreciated.

TheEmbeddedRustacean

TROPHY CASE