Topic
Everything filed under Rust, newest first.
RSS · JSON · All topics
Introducing sanstun: A sans-IO, parallel-friendly, userspace WireGuard implementation in Rust
Firezone's Thomas Eizinger announces sanstun, an open-source Rust implementation of the WireGuard state machine that separates IO from protocol logic, and explains its sans-IO design, how its API lets encryption and decryption run in parallel while the interface stays single-threaded, and why it replaces Firezone's boringtun fork.
8 min · 1,848 words
Marc Prud'hommeaux explains why he resigned from the Swift Android workgroup and is moving from Swift to Rust, arguing that app development is no longer the hard problem he wants to work on.
7 min · 1,643 words
The Future Trait Has A Missing State
Yoshua Wuyts argues that Rust's Future trait lacks a way to report that a future has already completed: polling after Ready may panic or misbehave, forcing bookkeeping wrappers like MaybeDone and adding code size. He sketches fixing Poll and CoroutineState with a 'done' state, explores even more states, and urges not repeating the mistake in the Coroutine trait and gen keyword.
8 min · 1,739 words
Yavashark: I've Built A JS Engine Every Day For 950 Days Straight
Announcing Yavashark, a small embeddable and easily extendable JavaScript engine written in Rust that its sole author has worked on every day since March 17, 2024 (4,200+ commits). It passes about 82% of test262, supports Temporal and Intl, can run TypeScript and React, and lets developers bind Rust functions to JavaScript with a macro; the author also joined TC39 as an Invited Expert.
4 min · 847 words
11 nanoseconds per word: Ridiculously Over-Optimizing Anagrams
David G. Andersen builds a solver for an anagram-enabled word ladder game and then over-optimizes its anagram indexing in Rust, using collision-free prime-product (Gödel numbering) identifiers, packed inputs and branchless loops to reach about 11 ns per word.
9 min · 2,171 words
Finding panics with Call Graph Analyzer
Tweede golf introduces Call Graph Analyzer (CGA), an open-source tool built with Microsoft under the Open Device Partnership that extracts the call graph from monomorphized Rust MIR so you can find which functions in a compiled binary can panic; the post covers why to eliminate panics, prior art, how CGA works as a rustc driver, and its caveats.
15 min · 3,354 words
Anna Liberty reflects on four months back in Zig after Rust: projects like the smallnet library snurl, Zig Day, what she likes (anyzig, the new IO and allocator interfaces, comptime, the build system, dependency culture, error handling, incremental compilation) and what she wants improved, including stability, lifetime support, documentation and bootstrapping.
13 min · 2,942 words
tar-codec: a fast and secure tar parser for the Rust ecosystem
Astral's William Woodruff explains tar-codec, the new Rust tar parser uv uses for source distributions from 0.13: roughly twice as fast as astral-tokio-tar, built to reduce parser differentials and other security risks, with a long tour of the messy UStar, pax and GNU tar formats, its state-machine design, safe extraction and lessons learned.
26 min · 5,898 words
One year of Dioxus fullstack in production: the good, the painful
Hauke Jung reviews a year running SeggWat's dashboard as a Dioxus 0.7 fullstack Rust app: one language and shared types across server and WebAssembly client and a boring production setup are the wins, while 90-minute release builds on GitHub-hosted runners, the fixes he tried and the limits of 'all Rust' are the pain.
5 min · 1,255 words
Stalwart v1.0: The Fastest Mail Server on the Planet
Stalwart's maintainer announces v1.0 of the Rust mail and collaboration server five years after its first commit, focused on performance work (SIMD/SWAR parser rewrites, profiling-driven optimisation, benchmarks) and finalising the on-disk data format.
14 min · 3,170 words
The Redox OS team summarises its NLnet-funded project to add io_uring-like ring buffer support at the system level: the redox-ring API for applications, shared-memory buffer management, ring buffer support in RamFS and NVMed, an async executor for drivers, and kernel and IPC optimisations such as fast context switching, direct switching and huge pages, plus planned future improvements.
10 min · 2,249 words
Xiangpeng Hao introduces bbtree, a zero-dependency Rust B-tree that he reports is 5x faster than std's BTreeMap on one thread and 12x faster than crossbeam-skiplist at 96 threads, explains how it cuts cache misses and coherence traffic, and describes how the LLM-written code is kept correct with human review, formal verification, deterministic simulation and fuzzing.
19 min · 4,484 words
Debunking "Faster than Rust": Malicious Benchmarks in Tov
Fyra Labs examines three benchmarks behind claims that the Tov language (TypeScript-like, compiled via C) beats Rust, argues they are crafted to slow Rust down, and shows improved Rust versions match or beat Tov.
12 min · 2,655 words
Cloudflare is rewriting everything in Rust
Sylvain Kerkour traces Cloudflare's shift from C and Lua NGINX modules to Rust after CloudBleed, covering Pingora, FL2 and the NGINX termination rewrite, a critique of its open-source posture, and how avoiding .unwrap() could have prevented the November 18, 2025 outage.
5 min · 1,102 words
Introducing tsrs: a Port of TypeScript to Rust
Cloudflare and VoidZero, with Max Schwenk of Owner.com and in collaboration with the TypeScript team, announce tsrs, a faithful Rust port of the TypeScript compiler incubated in the Oxc toolchain. Early benchmarks show it up to 8x faster with about 70% less memory than TypeScript 7.0; the post explains why Rust and Wasm matter and how the port will stay in sync.
5 min · 1,102 words
Announcing the GPU notification group and Linker Working Area
The Rust compiler team announces a GPU-target notification group for vendor experts helping diagnose GPU backend issues, plus a Linker working area to integrate alternative linkers such as Wild and to field linker questions, with Zulip streams and signup via rust-lang/team.
1 min · 295 words
2026 is an exciting year for the Rust compiler (and me)
Rust compiler contributor Matyáš Racek surveys long-running rustc efforts paying off in 2026, including the next-generation trait solver, Polonius, the parallel frontend nearing stabilization, LLVM and micro-optimization speedups, move elimination, polymorphization, Cargo cache and build-dir changes, and reflections on the Rust All Hands.
11 min · 2,539 words
Borrow Checking Zero-Cost Cyclic Mutability
Jake Fecher describes the new design of Ante's borrow checker, which blends group borrowing with his own ideas to relax Rust's aliasing-xor-mutation rule while still statically preventing dangling pointers, enabling safe shared mutability, cyclic mutability and complex data flow at zero runtime cost.
16 min · 3,737 words
A New Way to Think About Borrow Checking (In Reverse)
Evan Ovadia explains how the Valen programming language's borrow checker walks functions backwards, in reverse control-flow order, so it already knows how references will be used later, walking through its static typing, static grouping and safety-checking phases, loops, and how the design compares with Rust's borrow checker.
15 min · 3,517 words
How Not to Build a Five-in-a-Row Game Engine
Gabor Koos recounts building slap5, a five-in-a-row (gomoku) engine in Rust and WebAssembly with bitboards, alpha-beta search and threat detection, with heavy LLM help, and what he learned about the gap between working code, evaluating changes, and a strong opponent.
22 min · 5,068 words