Topic

Rust

Everything filed under Rust, newest first.

Showing 21–40 of 109 articles

  • 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.

    Announcement · rust · networking · open-source · security

    8 min · 1,848 words

  • On Leaving Swift for Rust

    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.

    Essay · rust · programming-languages · apple

    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.

    Blog post · Rust · Programming Languages · Async

    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.

    Announcement · JavaScript · Programming Languages · Open Source · Rust

    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.

    Blog post · performance · rust · algorithms

    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.

    Blog post · Rust · Embedded · Developer Tools

    15 min · 3,354 words

  • Four Months of Zig

    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.

    Blog post · Zig · Programming Languages · Rust

    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.

    Blog post · Rust · Python · Security · Open Source

    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.

    Blog post · Rust · Web Development · Build Systems

    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.

    Announcement · Open Source · Programming · Email · Rust

    14 min · 3,170 words

  • Ring Buffers Project Summary

    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.

    Blog post · Operating Systems · Rust · Open Source

    10 min · 2,249 words

  • bbtree: fastest ordered map

    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.

    Research · Rust · Databases · AI · Performance

    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.

    Blog post · Programming · Rust

    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.

    Opinion · Rust · Infrastructure · Security · Programming

    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.

    Announcement · TypeScript · Rust · WebAssembly · Developer Tools

    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.

    Announcement · Rust · Compilers · Open Source · Announcements

    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.

    Blog post · Rust · Programming Languages · Performance · Open Source

    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.

    Blog post · Programming Languages · Rust · Compilers · Systems Programming

    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.

    Blog post · Programming · Programming Languages · Rust · Systems Programming

    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.

    Blog post · Rust · WebAssembly · Game Development · AI Coding

    22 min · 5,068 words