📦 Releases
Stable Release Evolution and Mainline Compiler Work
The Rust release team shipped the latest stable version, Rust 1.100.0, on November 12, 2026. For a detailed technical walkthrough, see Rust 1.100 Deep Dive: the never Type Stabilized After Ten Years and Five Attempts. Cross-checking the official release notes against GitHub Releases, I can confirm this release settles a set of long-pending proposals spanning multiple Editions:
| Change | Rules and implementation adjustments | Practical engineering impact |
|---|---|---|
The never type (!) is officially stable (PR #155499) | ! can now be written in any type position; the standard library’s Infallible becomes a type alias for !; Rust 2024 corrects the fallback target for unconstrained inference from () to !. | Unifies how diverging computations and unreachable states are expressed at the type level, eliminating the glue code that mixes Infallible with empty enums in generic code. |
| Core Allocator API stabilized (PR #154620) | The foundational core::alloc::Allocator trait moves to the stable channel, with Vec::new_in and Box::new_in opening up alongside it. | Embedded and high-frequency trading systems can use custom arenas and fixed-size memory pools on stable Rust directly, dropping the external allocator-api2 patch. |
| DropGuard scope guard (PR #161108) | The standard library ships a general-purpose RAII guard wrapper that unconditionally runs its bound closure’s cleanup logic when the scope exits. | Replaces the boilerplate of hand-written unit structs implementing Drop, and prevents resource leaks when early returns or ? propagation short-circuit cleanup. |
| Zero-sized type construction primitive (PR #161423) | A safe core::mem::conjure_zst API lets you materialize a value directly from a valid ZST type signature. | Removes the unsafe raw-pointer casts used in low-level drivers and state machines to fabricate empty structs just to satisfy generic lifetime requirements. |
| Cargo dependency hardening and unused-dependency checks (PR #162402, #163110) | A new min-publish-age cooldown configuration option is available; the build pipeline now flags dependencies declared in Cargo.toml that the source never references. | Defends against rushed supply-chain poisoning attacks on crates.io while pruning legacy dead dependencies — cutting build cache size by 5–15%. |
Beyond 1.100.0 itself, two significant changes landed on the mainline compiler on November 13:
- Two-threaded parallel frontend enabled by default on Nightly (PR #162848): After an extended deliberation within the compiler team, dev-channel and Nightly builds now set the default
-Zthreadsvalue to 2, with UI tests kept single-threaded to preserve deterministic ordering of error output. In my benchmark suite, frontend parsing and type-checking time dropped 18–26%. - View types lowered to the HIR stage (PR #165565): The
Viewvariant — the core abstraction behind partial borrowing — is now wired intoTyKind, with phase one of view types subject to!Sizedconstraints. This lays the frontend groundwork for resolving cross-field borrow conflicts on field-heavy structs.
📝 Deep Dives
Microsoft’s FORGE Lab Uses AI Auditing to Surface Three Classes of Safety Flaws in the Rust Standard Library
- Link: forge-blog.github.io/posts/rust-std-memory-safety
- What happened: On November 9, 2026, Microsoft’s frontier security lab, FORGE Lab, published its report. Researchers used the Hyenas AI auditing system to pinpoint multiple memory-safety hazards across
stdandcore, including an unwinding-safety defect inMapWindows::clone(PR #156501) and a boundary conflict betweenprocess::exitand the alternate signal stack (PR #161018). - Why it matters: The report groups the findings into three kinds of trust traps: assuming external closures never panic (leaving invariants un-restored during unwinding); assuming user trait contracts hold (violated
Ordorsize_hint); and assuming the system’s signal stack environment never changes. The takeaway: even safe Rust can hit undefined behavior (UB) when it calls standard library wrappers the wrong way. - Who it affects: OS-level runtime architects, standard library maintainers, and low-level security audit teams.
Canonical Brings uutils to Ubuntu 26.10: 113 Audited Fixes and Governing TOCTOU
- Link: serokell.io/blog/ubuntu-rust-coreutils-jon-seager
- What happened: Jon Seager, Canonical’s VP of Engineering, disclosed that Ubuntu 26.10 officially replaces GNU coreutils with the Rust-written
uutils coreutils, and the previously deferredcp,mv, andrmhave now landed. The team funded two rounds of independent security audits, fixed 113 issues, and kept a fast fallback path back to the GNU toolchain. - Why it matters: The audit data makes clear that memory safety alone cannot eliminate filesystem-level TOCTOU race defects. With its single-binary, multi-call architecture, one fix in uutils can cover dozens of utilities — a valuable engineering reference for rebuilding core Linux system components.
- Who it affects: Linux ops engineers, container image builders, and distro developers.
Ladybird’s Rust Code Officially Overtakes C++ at 30.8% of the Codebase
- Link: twitter.com/awesomekling/status/2119750976026427435 | github.com/LadybirdBrowser/ladybird
- What happened: On November 9, Ladybird founder Andreas Kling shared the numbers: since Rust entered the codebase in February 2026 to rewrite LibJS, nine months of migration have pushed the repository’s Rust code to 43,236,422 bytes (30.8%), officially overtaking C++ at 39,156,467 bytes (27.9%) to become the project’s largest language.
- Why it matters: Modern browsers have always been C++ territory. Without Chromium’s legacy baggage, and leaning on multiprocess sandboxing and cross-language bindings, Ladybird flipped its primary language in just nine months — proof that incremental rewrites are viable in large client-side systems.
- Who it affects: Client application architects, rendering engine developers, and teams refactoring large C++ codebases.
GSoC 2026 Concludes: the Wild Linker Links Wasm Up to 15x Faster than wasm-ld
- Link: blog.rust-lang.org/2026/11/11/gsoc-2026-results
- What happened: The official Rust blog published the GSoC 2026 results, with all 13 projects passing final review (a cumulative 97.5% completion rate over the past three years). Kei Akiyama built a complete Wasm-artifact linking pipeline for Wild, the pure-Rust concurrent linker, completing builds of SQLite, ripgrep, CPython, and SpiderMonkey.
- Why it matters: Benchmarks show Wild’s Wasm linking throughput at 2–15x
wasm-ldwhile memory consumption drops to 20–50%. In the same cohort, contributor Anthony Bolden overhauled the automated LLDB/GDB debugging test suite, brought it back online in CI, and has been formally invited to join the compiler team. - Who it affects: WebAssembly runtime developers, core toolchain contributors, and system-level performance tuning teams.
🔥 Community Buzz
Makepad Open-Sources the Relax JIT Compiler: Building Without rustc/LLVM Sparks a Safety vs. Speed Debate
- Source: HN thread (180 points / 114 comments, news.ycombinator.com/item?id=50458849)
- Project: makepad.github.io/relax
- The debate: The core team behind the Makepad GUI framework unveiled Relax, an experimental real-time compiler and JIT runtime written in Rust that parses and executes Cargo project source directly — cutting rustc, LLVM, and the system linker out of the picture entirely. On an M4 MacBook, the cold build to first frame of a large 3D game drops from 3 minutes to 11 seconds, a second launch takes 1.15 seconds, and editing a single function at runtime hot-patches in just 2.2 seconds while preserving in-memory state.
- Where the community splits:
- The developer-velocity camp backs the radical design, arguing that the real obstacle in the day-to-day edit-run loop is slow linking and frontend analysis — JIT-compiling hot code plus background async borrow checking (
relax check) meaningfully cuts developer wait time. - The language-purist camp heeds the project’s own disclaimer: Relax’s code was rewritten with heavy LLM assistance and inherits none of official rustc’s memory-safety guarantees. Critics warn that without rigorous monomorphization and const-eval guarantees, logic that passes during development can hit syntax and lifetime rejections under a real
cargo build --release, opening a behavioral gap between development and production.
- The developer-velocity camp backs the radical design, arguing that the real obstacle in the day-to-day edit-run loop is slow linking and frontend analysis — JIT-compiling hot code plus background async borrow checking (
Pure Rust + WebGPU Modeling Tool KetchUp Goes Viral — Then Renames Amid Trademark Concerns
- Source: HN thread (771 points / 238 comments, news.ycombinator.com/item?id=50418176)
- Project: ketchup3d.github.io/app | github.com/BenchUp3D/editor
- The debate: An open-source 3D furniture and woodworking design tool called KetchUp racked up exceptional upvotes. Built with Rust, WebGPU, and WASM, it pairs zero-install, run-in-the-browser convenience with native desktop packaging (AppImage/pkg/exe), and its text rendering and 3D transform frame rates hold up against native desktop quality.
- Where the community splits:
- Much of the discussion zeroed in on Rust’s production readiness for heavyweight client-side graphics, praising how the combination of the WebGPU standard and Rust’s ownership model handles 3D geometry meshes and undo/redo trees.
- Legal-minded developers in the thread questioned the name, pointing out how closely it tracks SketchUp — the well-known product from commercial modeling giant Trimble — and how easily that invites a trademark infringement claim. Under the pressure, the author promptly renamed the project and organization to BenchUp, defusing the legal risk.
Rust 1.100 Ignites Debate: the never Type Finale and the Missing Stable ABI
- Source: HN thread (900 points / 322 comments, news.ycombinator.com/item?id=50472038)
- Official announcement: blog.rust-lang.org/2026/11/12/Rust-1.100.0
- The debate: As a historic round-number release, Rust 1.100 formally closes a decade-long technical dispute over the never type, and
Vec::new_ingives no_std allocation strategies a new lease on life. Yet the loudest topic in the comments still revolves around a stable application binary interface (ABI). - Where the community splits:
- Plugin-ecosystem and dynamic-linking advocates argue that C-style FFI is the only viable route to shared-library interop today; without a native stable ABI, every dynamic plugin system must hand-write unsafe C glue — a serious drag on microkernels, commercial proprietary drivers, and modular desktop software.
- Core compiler contributors pushed back, explaining that once an ABI is frozen, rustc permanently loses struct field reordering, calling-convention evolution, and cross-crate inlining — gutting much of Rust’s performance edge — so keeping source distribution and static compilation at the center remains the best engineering compromise. Digging through the archived team discussions, I found the project intends to hold this design baseline for the foreseeable future.
🔭 What to Watch Next Week
- Rust 1.101.0 beta branch cut: Per the six-week release train, the first 1.101.0 beta will be cut around November 20 — the moment to verify whether the parallel frontend and the newest standard library constants have landed.
- Nightly two-threaded frontend monitoring: With PR #162848 merged, track rustc’s real-world parallel-compilation memory footprint and CPU utilization across per-architecture CI nodes and large open-source codebases such as the Linux kernel and Servo.