🦀 Windows ARM Goes Tier 1

Today’s issue: Rust Binary Analysis, Rewriting PyTorch in Rust, and the State of SIMD in Rust in 2025

Nov 09, 2025

Hello, Rustaceans

We’re into the second week of November, hope your first week was nothing short of productive. Let’s keep that momentum going.

In this issue, we’ll discuss the latest release of Rust version 1.91.0, present you a challenge, spotlight an amazing project, and share 10 incredible links of the week.

Here’s issue 92 for you!

MAIN NEWS

Windows ARM Goes Tier 1

There are two things that get Rustaceans truly hyped: one is hearing that yet another beloved tool’s been rewritten in Rust, and two is seeing a new Rust release announcement. So when Rust 1.91.0 released last week, the community collectively lost it over the flood of fresh features and const-ready APIs.

We, however, decided to wait for the hype to cool before bringing you a proper rundown with a few spicy extras.

Here’s what’s actually worth getting excited about in this release.

Windows ARM64 is now Tier 1 - Yep, finally. Rust now gives full test coverage and prebuilt binaries for aarch64-pc-windows-msvc. This is good news for Surface Pro users alike to stop feeling like beta testers.

Dangling Pointers, Beware - A new lint now warns you when you try returning a raw pointer to a local variable, because Rust loves you, even when you’re being unsafe.

Const All the Things - TypeId::of is finally const. Same for OsString::new, PathBuf::new, and a bunch of array functions. The “compile-time everything” dream inches closer, though you still can’t compare TypeIds in const contexts. Baby steps.

Other notable changes that came with the release includes.

Path and PathBuf can now be compared directly to String and &str with no more ugly conversions.
core::array::repeat is stable for cleaner test setups.
Arithmetic gets beefed up with carrying_add, and borrowing_sub. Perfect for your math-heavy micro-optimization.
Cargo adds a build-dir config, a quietly massive quality-of-life tweak for anyone who’s tired of spelunking through target folders.

This release feels more infrastructure solidifying. The compiler team’s clearly in its polish and promote era, shoring up platforms, tightening safety rails, and sanding off those long-standing features.

It’s not flashy, but it’s the kind of update that makes you quietly smile the next time something “just works.”

RUST CHALLENGE 🦀

Last week we had you solve the Flatten Nested Lists challenge. Good job Richo, 𝕂oneko, Daniel Sánchez, Philipp, Dibash, Atul, Adarsh, The Baltimore People Eater, and fistons. Now, on to this week’s challenge.

Grouped by Frequency

Given a list of integers, return a vector of vectors where each inner vector contains all numbers that appear the same number of times, grouped by frequency.

The groups should be ordered by decreasing frequency, and each group’s numbers should be sorted in ascending.

Image: Assert test for Rust Bytes Challenge Issue #92: Grouped by Frequency

Test your solution on Rust Playground. Once completed, please share your solution and tag us either on X, BlueSky, Mastodon, LinkedIn, or reply to this email.

GPUI Component

GPUI Component are UI components for building fantastic desktop applications using GPUI.

GPUI Component project gives you a sleek, native-feeling toolkit for building desktop apps that actually look good.

Devs love performance but usually end up sacrificing design when building GUIs. GPUI Component makes beautiful, snappy, and themable UIs feel as natural in Rust as structs and enums.

Here’s what makes it awesome:

Native vibes - It combines macOS and Windows-inspired controls with shadcn/ui’s aesthetic, basically, elegance meets power tools.
Over 60 components out of the box - Buttons, tables, modals, editors - if it clicks, scrolls, or blinks, it’s probably already in there.
High-performance everything - GPUI gives you virtualized tables and lists that handle massive datasets.

GPUI Component is still in active development, but it’s already powering real apps like Longbridge Pro.

If you’ve been hunting for a Rust-native UI kit, GPUI Component is the crate to consider.

The Rust Foundation Team Announced the Foundation’s Maintainers Fund for consistent, transparent support to Rust developers amid open-source sustainability challenges.
JonathanMagambo just open-sourced OtterLang, an indentation-sensitive programming language with an LLVM backend. It compiles straight to native binaries, built with a focus on simplicity and performance.
The recordings from EuroRust 2025 conference are now live. Time to binge-watch and catch up on everything you missed.
Mario M’s tutorial on Rust Binary Analysis 101 builds an obfuscated Rust malware sample with XOR encryption and anti-debug tricks using PEB checks, providing binaries for static RE practice.
The state of SIMD in Rust in 2025 surveys SIMD in Rust, x86/ARM/WASM support, compatibility challenges, and Rust approaches like autovectorization, crates like wide/pulp, and intrinsics.
Elijah Potter slashed Harper’s Rust compile times by 71% through disabling LTO, boosting codegen units to fight slow compile times and speed up dev iteration. Don’t skip this please.
Tucker did the reasonable thing by rewriting PyTorch in Rust and documenting it all from tensor structs and broadcasting rules to DAG-based ops like matmul for neural nets.
The nerds at Centricular blogged about “Linking and Shrinking Rust Static Libraries,” tackling cross-platform Rust plugin bloat in GStreamer. They introduce dragonfire, a tool that deduplicates static libs via LLVM-ar, slashing sizes by up to 44x.
Csongor Kiss wrote about “Trait-Constrained Enums in Rust” emulating Haskell’s GADTs via type equality witnesses, trait constraints, and specialization to build a typed expression evaluator.
How Many Options Fit into a Boolean? contains Notes on Niche Optimizations in Rust, and a Few Updates.

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:

❤️ Recommend Rust Bytes to your friends.
🤳 Connect with us on our socials: X, BlueSky, Mastodon, LinkedIn.
☕️ Buy our editors a coffee.
📨 Email us at rustaceanseditors@gmail.com for sponsorship, feedback or ideas.

Been jamming to some slow tunes while editing this piece. Have a great week ahead.

That's all for now, Rustaceans.

John & Elley.

Rust Bytes