Topic
Everything filed under Rust, newest first.
RSS · JSON · All topics
How to speed up the Rust compiler in September 2026
How to speed up the Rust compiler in September 2026 My last post](https://nnethercote.github.io/2026/07/31/how-to-speed-up-the-rust-compiler-in-july-2026.html) on the Rust compiler’s performance was two months ago and a lot has happened since then. Overall progress The measurements for the period 2026-07-29 to 2026-09-28 can be seen here](https://perf.rust-lang.org/compare.html?start=1a833e16546c2eb012758ddd499964fd8afee29e&stat=wall-time&tab=compile&end=c1070d69382b8d2f2eb65119c738a77d9e324c9e&
5 min · 1,212 words
Rust is the answer to the wrong question
Rust is the answer to the wrong question The below was 100% written by a human. TL;DR: porting an app to another language is merely an anecdote. One shoting an application from scratch optimizes the easy part initial authoring and completely misses the point on the hard part: maintenance. Repeated onshots are not the answer to security vulnerabilities.
5 min · 1,063 words
Deser: Rethinking Rust Serialization
Armin Ronacher revisits Deser, an experimental Rust serialization library that inverts Serde’s visitor recursion into heap-backed sinks/emitters—trading some performance for lossless buffering, composable adapters, XML namespaces, and no stack overflow on deep nests.
2 min · 492 words
An update on Angular’s TypeScript 7-powered Compiler
The Angular team explains ngp, a hybrid preprocessor that rewrites parts of the Angular compiler in Rust with Oxc, decoupling transforms from TypeScript to prepare for TypeScript 7 and native tooling.
6 min · 1,431 words
Rusty thoughts on "Parse, don't validate"
Eli Bendersky revisits Alexis King's 'Parse, don't validate' idea through a Rust lens—how types can carry parsed invariants, where validation still sneaks in, and practical patterns for keeping illegal states unrepresentable.
6 min · 1,485 words
The state of SIMD in Rust in 2026
A lot of progress was made since last year, and I made some of it! After [last year's survey](https://shnatsel.medium.com/the state of simd in rust in 2025 32c263e5f53d) I started contributing to the SIMD library that seemed the most promising. One thing led to another, and now I'm a maintainer of Fearless SIMD. To avoid a conflict of interest, I invited authors of other libraries ( std::simd , wide , pulp , macerator ) to review and provide feedback on a draft of this article.
25 min · 5,668 words
Blinking a Blue Pill LED with Rust, from scratch
A from-scratch Blue Pill walkthrough in Rust without a HAL: wiring and flashing, the reset vector, volatile GPIO writes, delay loops, and the assumptions a working blink can hide.
22 min · 5,155 words
Why Buran Had Four Computers, Not Three — and What a Lean Proof Adds
**Date:** September 24, 2026 · **Author:** Dmitrii Zatona - Buran’s flight computer was four identical Biser-4 machines running the same programs synchronously. A comparison scheme blocked a failed one, and the design had to survive any two failures (Section 1). - Four is what two failures cost if a failed channel is found by comparing outputs alone. It is not the 3f + 1 of Byzantine agreement, which is a different problem (Sections 2 and 3).
33 min · 7,503 words
Topcoat is pushing the boundary of server applications with Rust
Two monthshttps://tokio.rs/blog/2026-07-22-announcing-topcoat ago, we Julienhttps://github.com/pikaju and Ihttps://github.com/carllerche announced Topcoathttps://github.com/tokio-rs/topcoat, a batteries-included full-stack Rust framework. It includes views, components, mailers, an ORM Toastyhttps://github.com/tokio-rs/toasty, and more. Topcoat aims to make building web apps with Rust as productive as any other language. We have been hard at work shipping features, so it is a good time to talk about what is new.
9 min · 1,958 words
Syncing Rust GCC backend or how to test Murphy's law
Thanks! This blog post is about the Rust GCC backend (not to be confused with gccrs which is a Rust front-end for the GCC compiler), how we synchronize its repository with Rust's and how everything went so wrong that it took us 2 months to be able to finally make it.
7 min · 1,507 words
Linebender ships fearless_simd 1.0: safe Rust SIMD that covers autovectorization, portable abstractions, and intrinsics access—reflecting on design goals after eight years from the original prototype.
4 min · 999 words
Max Woolf shows how iterative agentic coding—prompting agents to repeatedly speed up Rust code—produced solutions faster than established libraries, with concrete methodology and caveats.
22 min · 5,140 words
Saving another 100TB of RAM with math (and Rust)
Cloudflare explains how math-heavy redesigns and Rust in Pingora cut another ~100TB of RAM across their global network by shrinking hot in-memory structures without sacrificing correctness.
14 min · 3,157 words
Mold has recently updated their linker benchmarks and included Wild for the first time. These benchmarks show Wild being substantially slower than Mold in contrast to Wild’s most recently published benchmarks from our last release on August 4th. This post is an attempt to understand why there’s such a difference in the benchmark results. Mold’s benchmarks were run on two machines:
4 min · 958 words
Be alert: targeted attacks on prominent Rustaceans
We believe that there is an ongoing campaign targeting rust-lang members and owners of popular crates that is attempting to compromise devices and accounts in order to use them to publish malware. A video call is set up for something positive — maybe for a job, maybe for a project, maybe for a contract opportunity — and then that's used as a vector to either get the target to install something on their computer (such as a purportedly missing audio codec) or execute another command (for example, via putting a command on the clipboard).
1 min · 276 words
The Golden Spike, and Resurrecting the Vale(n) Programming Language
Evan Ovadia describes patching rustc so Valen can call Rust generics, implement Rust traits from Valen closures, and borrow-check across the boundary—true Rust interop beyond the C ABI.
17 min · 3,809 words
Why building a Rust LSP is hard
A deep dive into why implementing a Rust language server is unusually hard: incremental analysis, macro expansion, borrow checking at IDE latency, and lessons from building Rust Glancer alongside rust-analyzer.
26 min · 6,056 words
Migrating the GitHub Copilot runtime to Rust, using Copilot
Stephen Toub recounts porting GitHub Copilot’s agent runtime from TypeScript/Node to 800k+ lines of production Rust with Copilot agents across 128 incremental PRs, and what the performance and process lessons were.
64 min · 14,699 words
One Year of Sponsored Servo Development
Last September, the Servo project announced that long-time maintainer Josh Bowman-Matthews (@jdm) would work part-time on improving the Servo contributor experience, entirely funded by the monthly donations on OpenCollective and GitHub. In his own words, here is a look back over the past year!
1 min · 333 words
Principles for fast Tokio applications
A practical guide to building low-latency, high-throughput applications on the Tokio async runtime, written from experience debugging real production systems. The post covers measuring schedule latency, the fairness-versus-batching trade-off, mutex pitfalls, isolating Tokio workers from other threads, and when multiple runtimes make sense.
1 min · 295 wordsagent-written