87 - Rust 1.100 Ships the Never Type.
Patience is paying off in Rust. The never type is stable after ten years and five failed attempts. All 13 Rust projects in Google Summer of Code passed their final evaluation. And while the language grows up, people keep testing its foundations, from Microsoft's audit of the standard library to a pointed critique of GPUI.
Featured sponsor
|
13 Rust Projects, 13 Successes: Google Summer of Code 2026
The Rust Project has wrapped up its third year in Google Summer of Code (GSoC), and all 13 projects passed their final evaluations.
What is Google Summer of Code? It is a Google-funded program where new open-source contributors work on real projects under the guidance of experienced mentors. Contributors submit proposals, spend several months writing code with the maintainers, and receive a stipend for their work.
So, what did they actually build?
- Kei Akiyama taught the Wild linker WebAssembly. It links SQLite, CPython and even SpiderMonkey, 2 to 15x faster than wasm-ld
- Vishruth Thimmaiah got Wild linking Linux kernel modules such as btrfs, 2 to 4x faster than GNU ld or LLD
- Mohamed Ali brought back priroda, a debugger for Miri: set breakpoints in gdb and step through the program that triggered UB
- Marcelo Domínguez made GPU kernel launches through
std::offloadtype-checked and safe - Ryosuke Yamano implemented impl and mut restrictions from RFC 3323, now on nightly with stabilization planned for 2027
Over three years, 40 of 41 Rust GSoC projects have passed. This year had fewer projects than 2025, mostly because of limited mentoring capacity.
Takeaways:
- Mentors are the bottleneck, so experienced contributors who can guide a newcomer for a summer make the program bigger
- Interested in taking part? The post links the project idea list and the guide for new contributors
Rust 1.100 Stabilizes the Never Type
Rust 1.100 is a nice round number, and it came with the never type, written !. It represents code that never returns a value, such as an infinite loop, a panic or a program exit. Rust can now use ! anywhere a type is expected, so you can write things like Result<T, !>, a result that can never fail. It took 10 years and 5 failed attempts to stabilize this tiny but powerful feature.
Infallible is now an alias for !. Getting there meant changing the never type fallback in editions before 2024, which can break code in rare cases. Cargo also gains dependency cooldowns: set a minimum publish age and it holds back versions that were published too recently.
Thinking in Traits
A great explainer by Matthias Endler. Thinking in Traits starts with a question most of us never ask: how does collect() know to build a Vec? The answer is FromIterator, and from there he works out why Rust favors composition over inheritance.
His counterexample is Java's SSLSocket. It inherited a half-close operation that some Android versions could not perform, which crashed OkHttp. In Rust you ask what a type can do, and a type implements only the traits it supports. He is honest about the bill too, since generic code costs compile time and binary size. The finale is collecting into Result<Vec<_>, _>, which stops at the first error with the same iterator expression.
A Critique of GPUI
Desktop apps are moving to native Rust GUI frameworks, and the author of A Critique of GPUI points out that Discord has announced a rewrite on Zed's GPUI. His argument is that the state models of GPUI and egui stop scaling in complex apps.
GPUI cannot see which field changed, so after a notify it re-renders every view without a cache. In his benchmark, one label change among 3,000 rows takes 8.4 ms with a cached view per row and 92 ms without. Making that precise takes an entity, a subscription and a guard per label, which he calls a signal graph built by hand. Read it with his disclosure in mind: he works on zgui, a signal-based framework that appears in his charts.
Opening a 50 GB Text File Without Reading It
Most editors read the whole file before they show you anything. Erkin Pardayev built BigText, an open-source Rust editor where every operation costs what is on screen and nothing more.
It memory-maps the file in windows and reads only the first megabyte to detect the encoding. The view is anchored to a byte offset instead of a line number. A sparse index keeps one line count per 64 KB block, 8 MB for a 50 GB log, and builds in the background while you scroll. The result: the first screen of a 50 GB file appears in about 31 to 35 ms, as fast as a 1 GB file.
Snippets
KetchUp, now BenchUp: an open-source SketchUp alternative A free 3D modeling app for woodworking and furniture design, written in Rust. It runs in a desktop browser or as an app on Windows, macOS and Linux, and it imports SketchUp geometry.
Firenook: Firebase emulators in Rust A drop-in replacement for the Firebase Local Emulator Suite that keeps your config and ports and needs no Java. On the project's own benchmark, writes are about 40x faster with a tenth of the memory.
How to speed up the Rust compiler in November 2026 Nicholas Nethercote's first month on compiler performance at Hexcat. A simpler span compression scheme cut the spans interned in incremental builds from 20 to 40% down to about 1%.
Memory Safety Bugs in Rust Standard Library Microsoft's FORGE Lab found soundness bugs in std and core where safe Rust could trigger undefined behavior. The post sorts them into three patterns of misplaced trust in unsafe code.
We are thrilled to have you as part of our growing community of Rust enthusiasts! If you found value in this newsletter, don't keep it to yourself — share it with your network and let's grow the Rust community together.
👉 Take Action Now:
Share: Forward this email to share this newsletter with your colleagues and friends.
Engage: Have thoughts or questions? Reply to this email.
Subscribe: Not a subscriber yet? Click here to never miss an update from Rust Trends.
Cheers,
Bob Peters
Want to sponsor Rust Trends? We reach thousands of Rust developers biweekly. Get in touch!