Rust Weekly #8: Rust 1.100 Lands, Ladybird's Rust Overtakes C++, and Microsoft's AI Audit Exposes Trust Hazards in std

Rust · Weekly #8

Rust Weekly #8: Rust 1.100 Lands, Ladybird's Rust Overtakes C++, and Microsoft's AI Audit Exposes Trust Hazards in std

rustRustLanguage WeeklyMemory SafetyCompilers

Sources:GitHub Releases + 官方博客 + HN

📦 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:

ChangeRules and implementation adjustmentsPractical 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:

  1. 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 -Zthreads value 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%.
  2. View types lowered to the HIR stage (PR #165565): The View variant — the core abstraction behind partial borrowing — is now wired into TyKind, with phase one of view types subject to !Sized constraints. 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 std and core, including an unwinding-safety defect in MapWindows::clone (PR #156501) and a boundary conflict between process::exit and 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 Ord or size_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 deferred cp, mv, and rm have 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.
  • 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-ld while 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:
    1. 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.
    2. 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.

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:
    1. 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.
    2. 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_in gives 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:
    1. 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.
    2. 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

  1. 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.
  2. 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.