Rust Just Got Better 🦀

Today’s Issue: Ferrous Systems Joins the SOAFEE Initiative, Arenas in Rust, and Intrusive Lists for Fun and Profit

Rust version 1.89.0 thumbnail

Hello Rustaceans

We’re midway through August, hope you’re having a good time, let’s learn.

In this issue, we’ll discuss the recent changes in version 1.89.0, present you a Q/A interview, spotlight an amazing Rust project, and share ten (10) incredible links of the week.

Here’s issue 80 for you!

THE MAIN NEWS

Rust Just Got Better 🦀

Last week was full of big announcements: Bevy celebrated its fifth birthday, Rust foundation released their 2025 Technology Report, and GitHub announced it will be merging into Microsoft with GitHub’s CEO stepping down. While I am not at all happy with this move, I leave with my fingers crossed.

Meanwhile after a 42-day wait since the last release, version 1.89.0 is finally available, bringing some top-of-the-line features with it. I’m starting to think the wait might’ve actually been worth it.

Let’s take a look at some of the features I’m most excited about, and who knows, you might love them too.

• First up, const generics got a neat trick. You can now use _ to infer values from context, like [false; _] in a function returning [bool; LEN]. This is a small but sweet win for cleaner code, especially in const/static declarations where you’re juggling complex expressions. But don’t get too excited; you can’t slap _ everywhere, signatures still demand explicitness.

• The mismatched lifetime syntax lint now warns you when lifetime elision hides sneaky lifetimes in types like std::slice::Iter. Think fn items(scores: &[u8]) -> std::slice::Iter<u8>. It’s a nudge to add '_ for clarity, saving you from head-scratching bugs. This lint refines the old elided_lifetimes_in_paths, striking a balance between helpfulness and not yelling at you for irrelevant lifetime noise.

The End of an Era (and Some Sweet SIMD)

It's a bit of a wake-up call for those still clinging to their Intel Macs. Apple is phasing out support for x86_64, and Rust is following suit.

The x86_64-apple-darwin target is being demoted to Tier 2, meaning it won't be guaranteed to pass automated tests. It's not an immediate death sentence, but consider this your friendly reminder to upgrade that Intel MacBook.

And for the performance nerds, this release also added a set of new x86 target features, including AVX512 and crypto intrinsics. If you're into data processing or anything else that needs to go fast, your day just got a lot better. Just be sure you have a CPU that can actually use them.

You can upgrade to this stable release with the terminal command `rustup update stable`, and enjoy the niceties of these new features.

---

---

RUST Q/A INTERVIEW 🦀

Q: What’s one feature you’d love to see added to Rust soon?

A: “The first one is the `auto_cfg` feature in rustdoc, which will automatically get `cfg` information of documented items and display them in the documentation. Like that, users can know just by reading the documentation under which conditions an item is available. I hope this feature will be available (as nightly first) in the next months. The implementation is done in https://github.com/rust-lang/rust/pull/138907.

The second one is the possibility to expand macros directly in the rustdoc source code pages simply by clicking on a button (and no JS is needed). You can test the feature here: https://rustdoc.crud.net/imperio/macro-expansion/src/lib/lib.rs.html . The implementation is here: https://github.com/rust-lang/rust/pull/137229”

About the Respondent: Guillaume Gomez is a Rustdoc team leader, member of the Rust dev-tools, documentation and docs.rs teams, and GNOME foundation member.

Connect with Guillaume: Blog, GitHub, Toot.cat, BlueSky.

---

---

PROJECT SPOTLIGHT 💡

Nyx

Nyx is a high fidelity, fast, reliable and validated astrodynamics toolkit library.

Written in Rust with Python bindings, it’s reliable, and already battle-tested on three lunar missions (at the time of writing). Yeah, it’s kind of a big deal.

Space mission design is a nightmare of complex math, and outdated tools. Nyx solves this by streamlining trajectory optimization and orbit determination, so you can focus on the cool stuff like plotting a lunar lander’s path without losing your mind.

Why Nyx is Awesome

• Blazing Fast - It uses Rust and LLVM’s lld linker to compile faster.

• Mission-Critical Cred - Nyx has been proven on lunar missions, so you know it’s not just some hobby project.

• Python & Rust Vibes - Write in Rust or Python whatever your vibe is, Nyx plays nice with both.

And the nice part is: Nyx is open-source on GitHub at https://github.com/nyx-space/nyx so you can tinker as you please.

---

---

AWESOME LINKS OF THE WEEK 🔗

1. The Rust nerds at Proton wrote how Rust is powering their Proton Authenticator, and shared the reasons behind choosing Rust in the first place.

2. Hubert wrote memory analysis in Rust, walking through tools and techniques he found invaluable during a witch-hunt for memory issues in the Forest project.

3. Yoshua Wuyts’s "placing arguments" highlights challenges with execution order, borrow checking, and API design, and proposes edition-dependent path resolution as a long-term solution for smoother adoption.

4. If you’ve been struggling to understand the Send and Sync traits, Cuong Le’s guide on Send/Sync might be the last write-up you’ll ever need.

5. “Wait! Don't spawn that task!” by Gabriel Steinberg discusses patterns for managing mutable state in concurrent applications, comparing mutexes, channels, and single-task approaches, and advocating for a single-task model using async/await for simplicity.

6. Jennings Zhang shared four approaches to compile-time data construction, using LazyLock, const fn, procedural macros, and build.rs comparing their trade-offs in flexibility, performance, type safety, and correctness.

7. The Self-Directed Research Podcast discussed in-depth about the use of intrusive linked lists, particularly in embedded systems where dynamic memory allocation isn’t available, and it’s genuinely worth a watch. [video]

8. “Arenas in Rust” article highlights using arenas and handles to manage circular references in data structures, bypassing direct pointers to achieve deterministic and secure memory management.

9. Nicholas Nethercote’s Speed wins when fuzzing Rust code with `#[derive(Arbitrary)]`details how updating the Arbitrary crate to version 1.4.2 brings small but meaningful compile-time improvements.

10. In other news Ferrous Systems has joined the SOAFEE initiative to help bring Rust’s safety, performance, and tooling to software-defined vehicles and embedded edge systems.

Bonus:

11. RustConf is coming up soon and you won’t want to miss it, especially since it’s online too and free. Get your ticket now before its late.

---

---

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.

Join for free and get 40% off when you upgrade. [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, BlueSky, Mastodon, Publication.

• ☕️ Support our editors by buying us coffee.

• 📨 Email us at rustaceanseditors@gmail.com for sponsorship, feedback or ideas.

I’ve been reading Yuval’s “Homo Deus” and it got me hooked. How far are you with your yearly reading goals?

That's all for now, Rustaceans.

John & Elley.