Goodbye Async-Std, Welcome Smol
Today’s Issue: I Can’t Believe That’s Legal Rust, Memory Safety for Web Fonts, and Extending Futures in Rust
Hello Rustaceans! 🦀
Welcome to another edition of Rust Bytes newsletter.
In this issue, we’ll discuss why async-std was deprecated and what to do next, challenge you to reverse a word in-place without reallocating, spotlight an amazing Rust project, and share some incredible links of the week.
Here’s issue 59 for you!
A Message for You
In our 49th issue of this newsletter, we celebrated our first anniversary (December 18) and we promised a compilation of all the challenges and tips we’ve shared throughout the newsletter, combined into one book.
Well, the compilation is now ready. You can now get it for free in EPUB, PDF, or website format. It contains 45+ challenges, quizzes, and tips to get your hands dirty writing Rust. If you’re generous enough to support us, you can pledge any amount you’d like.
The book is also open-source on GitHub, so if you encounter any issues, feel free to create an issue or submit a pull request (PR), and we’ll be more than happy to assist.
Now onto our main thing.
THE MAIN THING
Goodbye Async-Std, Welcome Smol
The Rust standard library (std) still lacks native support for asynchronous operations, meaning if you need support for async functionality you must rely on third-party crates like async-std, tokio, monoio, or smol.
These crates provide async executors, enabling execution of asynchronous code in Rust.
However, there has been a significant shift in the async Rust ecosystem: async-std, a popular crate for async programming, has been officially deprecated.
Josh Triplett the maintainer of async-std, shared the news on GitHub, marking the end of an era for the project.
The async-std team has recommended that all users and crates built on async-std migrate to smol, a lightweight and efficient alternative that shares a similar API structure.
Why the Shift from Async-std to Smol?
Async-std was created to mirror the Rust standard library (std) as closely as possible, but in an async context, offering familiar APIs with the power of async/await.
It provided features like single-allocation task creation, an adaptive lock-free executor, and a threadpool, for high throughput with low latency.
However async-std had already been using smol’s executor under the hood for some time.
This overlap, combined with smol’s simpler design and active maintenance, makes it a natural successor.
Smol prioritizes simplicity and predictable performance, especially in terms of tail latency, over raw throughput, a trade-off that many users would prefer.
Unlike tokio, which is often seen as an opinionated ecosystem, smol is a tiny, unopinionated set of async building blocks.
This flexibility allows smol-based systems to run within tokio (but not vice versa), making it a better choice for crate authors.
What Does This Mean for Async-std Users?
If you’re currently using async-std in your projects, the transition to smol should be straightforward.
The two crates share a similar API layout, meaning most of your existing code can be adapted with minimal changes.
For example, a simple async-std task like this:
use async_std::task;
async fn say_hello() {
println!("Hello, world!");
}
fn main() {
task::block_on(say_hello())
}can be rewritten with smol as:
use smol::block_on;
async fn say_hello() {
println!("Hello, world!");
}
fn main() {
block_on(say_hello());
}The smol crate is designed to “just work” without requiring you to manually set-up an executor.
The deprecation of async-std marks the end of a chapter, but it also paves the way for a more consolidated async Rust ecosystem.
The async-std team’s decision to recommend smol shows their dedication to the Rust community’s long-term health, choosing unity over a fragmented ecosystem.
Long live async-std—catch you in the next life, or perhaps in a parallel async universe.
RUST CHALLENGE 🦀
Last week, we shared with you a useful Rust Tip on efficiently swapping values without cloning.
Let's move on to this week’s challenge.
Reverse Words In-Place
Write a Rust function that takes a mutable string sentence as input and reverses each word in-place, while keeping the order of the words the same.
Words are separated by a single space, and you must preserve leading and trailing spaces if they exist.
Do not use any external crates, stick to the standard library. The function should modify the input string directly and not allocate a new string.
Test your solution on Rust Playground. Once completed, please share your code and tag us either on Twitter, BlueSky, Mastodon, or reply to this email.
PROJECT SPOTLIGHT 💡
KANI : Rust Verifier
The Kani Rust Verifier is a bit-precise model checker for Rust.
Built for the Rust programming language, Kani uses bit-precise model checking to ensure your code stands up to scrutiny especially in those tricky, unsafe corners where Rust’s usual safety nets don’t reach.
Think of it as a supercharged proofreader for your Rust projects, catching bugs that traditional testing might miss.
What Problem It Tries to Solve
Rust is loved for its performance and safety guarantees, but those guarantees don’t cover everything.
Unsafe code blocks where developers bypass the compiler’s checks for flexibility can introduce subtle bugs like null pointer dereferences, panics, or arithmetic overflows.
Even safe Rust can have logical errors or runtime issues that slip past unit tests.
Kani tackles this by providing a way to prove your code’s correctness beyond what the compiler or traditional testing can achieve, bridging the gap between Rust’s static assurances and real-world reliability needs.
What Makes Kani Tick
Kani doesn’t guess, it verifies with exactness, catching edge cases that fuzzers or tests might overlook.
Specially designed to handle Rust’s “unsafe superpowers,” making it a lifesaver for low-level systems programming.
Works with Cargo, uses familiar harness syntax, and even hooks into GitHub Actions for CI, verification feels like testing, but stronger.
With kani::any(), you’re not just testing a few values, you’re proving behavior across all possibilities, no exhaustive enumeration needed.
Applied to projects like Firecracker and the Rust Standard Library, proving its chops on complex, high-stakes codebases.
The Kani Rust Verifier project is open-source on GitHub at https://github.com/model-checking/kani.
AWESOME LINKS OF THE WEEK 🔗
Rust v1.85.1 is here. This release fixes combined doctest compilation issues along with several other minor improvements. Also the Rust team is hiring for a Rust program manager.
Christian Visintin wrote a fantastic article on extending futures in Rust—it’s so good, we promise.
Dominik Röttsches, Rod Sheeter, and Chad Brokaw from Google’s Chrome team authored Memory Safety for Web Fonts, discussing why Chrome transitioned from FreeType to Skrifa (written in Rust) and highlighting key technical improvements enabled by this shift.
Niko Matsakis wrote about Rust in 2025: Language interop and the extensible compiler.
Daniel Cumming released an in-depth guide on How the Rust Compiler Works. He covers concepts such as the Abstract Syntax Tree (AST), Typed High-Level Intermediate Representation (Typed HIR), LLVM Intermediate Representation (LLVM IR), and all the fun stuff. [video]
Wojciech Daniło released crabtime, a crate that offers a novel way to write Rust macros, inspired by Zig’s comptime.
The RustNYC meetup is happening this Wednesday, March 26th. Michael Gattozzi will present a talk titled 'I Can’t Believe That’s Legal Rust.' Hurry and reserve your spot—see you there. [meetup]
Nicholas Nethercote’s How to Speed Up the Rust Compiler offers insights that might just stop you from ever complaining about Rust’s compile times again.
Malware Decoded wrote an interesting article on running code before main in Rust. If you're obsessed with security, don’t skip this.
The talented Rustaceans at Devolutions open-sourced IronRDP - a Rust implementation of the Microsoft Remote Desktop Protocol (RDP).
CodeCrafters: Become a Better Rust Engineer
CodeCrafters created amazing Rust courses that push your skills beyond the basics.
You’ll have fun building real-world projects from scratch, including Git, Docker, Redis, Kafka, SQLite, Grep, BitTorrent, HTTP Server, an Interpreter, and DNS.
The courses are self-paced, so you can learn at your own speed.
If you’re itching to level up your Rust skills, these courses are perfect for you.
Here’s what makes CodeCrafters stand out:
Learn by building projects that challenge you beyond just implementing CRUD features.
Strengthen your fundamentals by working on awesome low-level projects.
Get really good at reading and writing idiomatic Rust code.
Join a community of talented engineers from MAANG companies and learn best practices from the pros.
Plus, take part in monthly contests for a chance to win exciting prizes.
You can get your CodeCrafters fees fully reimbursed through your corporate Learning & Development (L&D) budget.
Be sure to check with your employer about tapping into your L&D budget to save money and make this a no-brainer opportunity to level up your skills.
Don't take our word for it. See what others have to say. [affiliate]
SUPPORT RUST BYTES👋
You're Rust Bytes biggest fans, and we love to see it.
Here’s how you can help spread the word:
❤️ Recommend Rust Bytes to your friends.
🤳 Connect with us on our socials: X, Rustaceans Publication.
📨 Email us at rustaceanseditors@gmail.com for sponsorship, feedback or ideas.
☕️ Buy us coffee to support our editors.
I am reading The Beginning of Infinity by David Deutsch and its enlightening. Would highly recommend.
That's all for now, Rustaceans.
John & Elley.