🦀 10 Predictions We’re Mostly Serious About
Today’s issue: Rust 1.93.0 Got Released, How Gama Space Is Controlling Satellites in Orbit With Rust, and Someone Turned the Rust Type System Into a Game
Hello, Rustaceans!
In this issue, we’ll make our 2026 predictions for the Rust ecosystem, present you a Rust tip, spotlight an amazing crate, and share 10 incredible links of the week.
Here’s issue 103
MAIN NEWS
10 Predictions We’re Mostly Serious About
It’s January 2026, and prediction season is upon us.
As proud Rustaceans, we’re gazing into our crystal ball powered by “cargo tarot”, to forecast what’s next for our favorite crab-themed language.
We’re confident enough in these to bet fake internet points on them.
Here are our 10 bold takes:
1. Async matures, memes evolve. The Fearless Concurrency slogan gets a gentle retirement. Async/await finally feels natural to most devs, and the community embraces a new tagline: “Graceful Concurrency, Because Blocking Is So 2020.”
2. Tokio stays king, but simpler. No quantum entanglement (yet). Instead, Tokio doubles down on ergonomics with better diagnostics and a just works mode for common cases. Spawn_blocking becomes the new “I give up” button everyone secretly loves.
3. Cargo becomes the monorepo darling. JS devs fleeing npm lockfile hell continue migrating backend services to Rust. Cargo’s fast, reproducible builds win over enterprises quietly, no drama, just results.
4. Pinning drama cools. Self-referential structs remain a niche battleground, but new crates and compiler hints make Pin feel less like a puzzle. Meanwhile, frameworks like Leptos and Dioxus eat more UI market share with “no-pin-required” abstractions.
5. Rust remains the internet’s favorite programming language. It’s been at the top of the “most loved” charts for nearly a decade now, and honestly? There’s no sign it’s giving up the seat this year either. The crown fits, and Rust knows it.
6. Proc macros go mainstream. Derive macros become the new hotness. Tools like darling and syn battle for dominance, letting devs auto-generate more boilerplate than ever. “Why write it when you can derive it?”
7. Bevy hits 1.0 and thrives. Bevy reaches stable with massive momentum in games and visualization tools.
8. Unsafe becomes... safer? Systems programmers push boundaries in embedded and kernel work, but new lints and patterns make unsafe blocks smaller and more auditable. The “unsafe supremacy” flex fades as safe abstractions catch up.
9. Production adoption surges silently. Rust in tutorials stays beginner-friendly, but real-world usage explodes in unsexy places: internal tools, billing systems, CLI utilities, firmware. The gap between “tutorial Rust” and “shipping Rust” widens, and that’s a good thing.
10. Community stays weird and wonderful. More in-person meetups, better mentorship programs, and zero major schisms. We’ll still argue about edition cycles and naming conventions, but underneath it all: Rust keeps getting better, one crab step at a time.
There you have it, our mix of satire and sincere hopes for 2026.
RUST TIP 🦀
Last week we shared a Rust tip on marking small hot-path methods in traits. Now on to this week’s Rust tip.
#[non_exhaustive] + private fields for future-proof structs
When designing library structs/enums that you might extend later: #[non_exhaustive] plus a private field blocks direct struct literals, forcing users to use a constructor you control.
So you can safely add new public fields later without breaking existing code.
#[derive(Debug)]
#[non_exhaustive]
pub struct Config {
pub timeout: Duration,
pub retries: usize,
// Force construction via builder/new()
_private: (),
}See the Rust reference on the non_exhaustive attribute.
PROJECT SPOTLIGHT 💡
Pake
Pake is the little tool that turns any webpage into a proper desktop app.
This Rust + Tauri powered crate solves the eternal pain of “I just want a native-feeling wrapper without selling my soul and 500MB of disk space to Electron.”
Here are the features that make Pake quietly smirk at the competition:
Tiny - We’re talking ~5MB install size. Yeah, nearly 20× smaller than your average Electron catastrophe.
Blazing fast & sips RAM - Rust backend means snappy performance and memory usage that won’t make your laptop beg for mercy.
Bonus toys likes shortcuts, immersive windows, drag & drop, ad-blocking, even style tweaks if you’re feeling fancy.
Give it a spin at https://github.com/tw93/Pake.
AWESOME LINKS OF THE WEEK 🔗
Rust 1.93.0 is out with bundled musl updated to 1.2.5 (better DNS reliability in static builds), global allocators can now safely use thread-local storage, and `cfg` attributes are supported directly on individual `asm!` lies. More details in the next issue. Also, a crates.io development update has been released.
VectorWare achieved a world first: Rust’s full standard library now runs on GPUs via hostcalls, enabling file I/O, printing, and time access directly from GPU code.
Albert Garde open-sourced Rustorio, a factorio-inspired game where the gameplay is the Rust type system. If it compiles and doesn’t panic, congrats, you shipped a factory.
Sebastian Scholz from Gama Space discusses using Rust for reliable, safety-critical embedded software in solar sail spacecraft. [video]
A Rustacean released a high-performance, concurrent ordered map for Rust. It stores keys as
&[u8], handles variable-length keys without breaking a sweat, and builds a trie of B+trees inspired by the Masstree paper.Wojciech Danilo (Founder / CEO Ferrisoft) wrote “Introducing fixed_num, financial focused decimal for Rust”.
RustNationUK is happening on 18–19 February 2026. You can get your tickets for two full days of Rust talks, hallway-track networking, and the kind of socials where unsafe stories are told in confidence.
The Rust Foundation published 2025 in Review, their high-level look at what they accomplished last year, in collaboration with the Rust Project and with support from their members.
PgDog replaced Protobuf with direct C-to-Rust bindings in pg_query.rs. The result? Query parsing is now 5× faster, deparsing is 10× faster, and somewhere a serializer just lost its job.
Andrew Brinker wrote how Rust culture prioritizes precise semantic guarantees in APIs, disentangling ambiguities for composability and robustness, as seen in Linux kernel integration.
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]
SUPPORT RUST BYTES
You’re Rust Bytes’ biggest fans, and we love to see it.
❤️ Recommend Rust Bytes to your friends.
🤳 Connect with us on our socials: X, BlueSky, Mastodon, LinkedIn.
☕️ Buy our editors coffee.
📨 Email us at rustaceanseditors@gmail.com for sponsorship, feedback or ideas.
How’s the first month of 2026 treating you so far?
That's all for now, Rustaceans.
John & Elley.
Prediction #9 about the widening gap between tutorial Rust and shipping Rust is spot-on. Working with afew teams last quarter, the ones scaling production services hit friction not in syntax but in profiling async contention and managing dependency chains under real load. That unsexy infra work doesn't make tutorials, but it's wher e most of the value lives.