🦀 What’s New in Rust 1.95.0
Today’s issue: The Symposium Project, Rewriting a C++ Frontend in Rust, and the Edge of Safe Rust
Hello Rustaceans!
In this issue, we’ll discuss the latest Rust release, share a useful Rust tip, spotlight a project, and highlight 10 awesome links of the week.
Here’s issue 116.
MAIN NEWS
What’s New in Rust 1.95.0
If there’s one thing last week made painfully clear, it’s that AI breaches are still way more common than anyone wants to admit. On the Rust side of things, Rust 1.95.0 got released with with a ton of genuinely great upgrades.
The most notable feature is the new cfg_select! macro. Think of it as a standard-library answer to cfg-if, but with a more declarative, match-like structure. It lets you express compile-time configuration branching cleanly and locally, without stacking #[cfg] attributes everywhere.
For teams maintaining cross-platform or multi-target crates, this reduces cognitive overhead and makes intent clearer. It’s the kind of polish that gradually replaces ecosystem crates with first-party solutions.
Pattern matching also got a meaningful upgrade: if let guards are now usable inside match arms. This builds on earlier let chains work and enables more expressive matching logic without splitting control flow across multiple constructs.
The compiler still doesn’t consider these guards for exhaustiveness checking, so you don’t get stronger guarantees, but ergonomically, it’s a win for writing more readable matching logic in complex pipelines.
A large portion of the release is API stabilization, especially around MaybeUninit, Cell, atomics, and collections.
The *_mut methods for Vec, VecDeque, and LinkedList stand out: they allow mutation during insertion without extra lookups or unsafe juggling.
Combined with expanded MaybeUninit conversions, this signals continued investment in low-level, allocation-aware patterns, useful for performance-sensitive systems, allocators, and data-structure-heavy code.
Atomic types also gained update and try_update, which reduce boilerplate around CAS loops. This is subtle but impactful for concurrent code: fewer hand-rolled retry loops, clearer intent, and less room for mistakes.
Const-context expansion continues steadily, allowing more APIs to be evaluated at compile time. It’s incremental, but over time this trend is pushing Rust toward more powerful compile-time computation without nightly features.
On the flip side, Rust 1.95 removes stable support for custom JSON target specs. Practically, this only affects advanced users already relying on nightly to build core/std, but it’s a reminder that some lower-level extensibility remains intentionally gated.
My take: The standard library is clearly absorbing proven ecosystem ideas (cfg-if, better atomics ergonomics), which is a good sign for long-term stability.
If you’re maintaining production Rust, upgrading is low-risk and gives you small but meaningful improvements, especially in cross-platform code and concurrent systems.
RUST TIP 🦀
Last week we shared a tip on how to use #[repr(transparent)] + #[repr(C)] for newtype FFI safety. Now on to this week’s tip.
#[inline(never)] + #[inline(always)] used surgically
Most people overuse #[inline]. The real power is #[inline(never)] on cold error paths and wrapper functions so the hot path stays in one function for better codegen and cache behavior.
Also: #[target_feature(enable = “avx2”)] + unsafe {} functions for SIMD when std::simd isn’t enough.
Check out the docs Code generation attributes.
PROJECT SPOTLIGHT 💡
Beetroot
Beetroot is the clipboard manager Windows should have built.
It solves the usual clipboard sins: pathetic 25-clip limit that vanishes on restart, zero search worth a damn, and that special pain when you need to actually do something with the stuff you copied.
What makes it actually fun to use:
5-phase fuzzy + regex search. That somehow finds your crap even when you can’t spell it right, complete with source app icons and window titles.
Background AI transforms. Hit a prompt, the menu vanishes instantly, and a notification pings when it’s done. Queue as many as you want.
AI Vision that doesn’t suck. Drop a screenshot, handwritten note, or receipt and get it read, described, or data-extracted using cloud or local models.
Beetroot is free, local-first, and available at https://github.com/ayarotsky/diesel-guard.
AWESOME LINKS OF THE WEEK 🔗
Alejandra González(Clippy team member) published a (not) full list of all the popular, cool projects and companies that use Rust.
Rust India Conference 2026 talks are finally on YouTube, because nothing ships faster than recorded videos… eventually. [video]
Niko Matsakis announced the first release of the Symposium project, which lets Rust crates ship agent skills and extensions, auto-installed via dependencies, giving authors direct control over AI-assisted developer workflows.
Bedford, Chatham, and Gatlin from Cloudflare wrote about making Rust workers reliable by adding panic unwinding and abort recovery, preventing crashes, preserving state, and ensuring safe WebAssembly execution.
Brian Anderson wrote “Exploring Rust Dependency-Toolchain Compatibility” showing how dependency chains quietly break backward compatibility; shrinking viable compiler support window to roughly two years.
NearlyFreeSpeech took their battle-hardened C++ frontend, looked it in the eye, and said, “yeah… we’re rewriting you in Rust.” The result? A more reliable system, thanks to obsessive testing and a slow, no-drama rollout instead of a YOLO deploy.
Jon Gjengset was interviewed by Mathias Endler about mission-critical Rust systems, Helsing’s Rust bet, and what lessons from his years of Rust education have shaped the way he writes and thinks about production code. [video]
Jaxx497 open-sourced NoctaVox, a lightweight Rust TUI music player for people who think GUIs are optional. Built with Ratatui, obviously.
Catherine West wrote The Edge of Safe Rust, explaining how Rust’s ownership model makes cyclic pointers challenging, and how safer alternatives like generational indexing can help manage them.
Samuel Onoja wrote how building an inode-style paged vector in Rust proves inefficient compared to standard vectors, but offers benefits for specific, append-heavy workloads.
Bonus
RustConf 2026 conference early bird registration is ending this Wednesday. Unless you enjoy overpaying, now’s a great time to register.
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.
Join for free and get 40% off when you upgrade. [affiliate]
X | BlueSky | Mastodon | GitHub | LinkedIn | Buy me coffee | hello@rustbytes.com
My weekend was packed with activities. Hope you had a great one as well!
See you next week!
John & Elley.