<p><strong>TLDR:</strong> Rust 1.95.0 landed this week with two long-requested features: the <code>cfg_select!</code> macro and if-let guards in match arms. Tailscale released an experimental Rust reimplementation of its core networking stack. <a href="http://NearlyFreeSpeech.NET" target="_blank" rel="noopener nofollow">NearlyFreeSpeech.NET</a> finished a full C++ to Rust migration of their production HTTP frontend after testing against 150 million real requests. Servo 0.1.0 is now on <a href="http://crates.io" target="_blank" rel="noopener nofollow">crates.io</a> with a new LTS track aimed at embedders.</p>
<hr>
<h2>Rust 1.95.0 is stable</h2>
<p><code>cfg_select!</code> is now a built-in macro for compile-time conditional configuration, doing what the <code>cfg-if</code> crate has handled for years without the external dependency. If-let guards in match arms are also stable, cleaning up a class of workarounds that have been annoying people for a long time. The release also stabilizes atomic update methods, <code>MaybeUninit</code> array conversions, <code>core::hint::cold_path</code>, and new <code>Layout</code> methods. The Linux kernel already has support in place for 1.95.</p>
<h2><a href="http://NearlyFreeSpeech.NET" target="_blank" rel="noopener nofollow">NearlyFreeSpeech.NET</a> ships their C++ to Rust migration</h2>
<p>This is a real production migration story, not a toy project. Their <code>nfsncore</code> server handles every HTTP request on their hosting platform. The nine-step process included fuzz testing with hundreds of millions of inputs, log replay testing, side-by-side proxy testing, and statistical analysis of 150 million requests before staged rollout. The Rust version runs about 2% slower than C++ but ships with better telemetry and error reporting. They also found and fixed bugs in the original C++ during proxy testing, which is the kind of thing that makes the whole exercise worthwhile.</p>
<h2>Tailscale releases tailscale-rs</h2>
<p>This is an experimental Rust reimplementation of the core Tailscale networking stack, mirroring the tsnet Go library API so you can embed Tailscale directly into applications. It includes FFI bindings for Python, Elixir, and C, plus an axum integration crate. Current limitations are significant: no peer-to-peer NAT traversal, no DNS resolution, no exit nodes. It works over DERP relays only. The Go implementation continues in parallel. Tailscale is explicitly asking for community feedback to shape the roadmap toward 1.0.</p>
<h2>Servo 0.1.0 lands on <a href="http://crates.io" target="_blank" rel="noopener nofollow">crates.io</a> with an LTS track</h2>
<p>Servo is now available as a <a href="http://crates.io" target="_blank" rel="noopener nofollow">crates.io</a> dependency for the first time, which removes the friction of tracking the project repository manually. More practically, they’re introducing a six-month LTS release cadence with a nine-month support window and security-only patches. If you’re evaluating Servo as a CEF alternative, that predictability matters more than the version number.</p>
<hr>
<h2>Also notable</h2>
<ul>
<li><strong>Rust for Linux 7.1</strong> adds the experimental <code>CONFIG_RUST_INLINE_HELPERS</code> Kconfig option, which inlines C helpers into Rust code similarly to LTO but scoped to C helpers only; the Rust null block driver runs ~2% faster with it enabled, and it requires Clang with a matching LLVM major version.</li>
<li><strong>Zero-copy GPU inference from WebAssembly on Apple Silicon</strong> chains mmap, Metal’s <code>makeBuffer(bytesNoCopy:)</code>, and Wasmtime’s <code>MemoryCreator</code> trait to share Wasm linear memory directly with the GPU; RSS overhead is 0.03 MB vs 16.78 MB for the copy path, and KV cache snapshot restore is 5.45x faster than re-prefill at 24 tokens.</li>
<li><strong>Rust threads on the GPU</strong> from VectorWare maps <code>std::thread</code> to GPU warps, with Warp 0 running main and additional warps woken on <code>thread::spawn()</code>; the approach prevents warp divergence by construction and theoretically unlocks rayon and tokio for GPU use.</li>
<li><strong>Debloating async Rust</strong> covers practical techniques for reducing state machine bloat: avoid marking functions async unnecessarily, return <code>impl Future</code> directly instead of wrapping, use <code>FutureExt::map</code> for postambles, and pass references rather than moving large variables into futures.</li>
<li><strong>Zatat</strong> is a Rust WebSocket server implementing the Pusher Channels protocol v7; on a €3.99/mo Hetzner VM it handles 10,000 concurrent connections vs Laravel Reverb’s ~1,000, and processes ~46k HTTP events/sec vs Reverb’s ~2.7k.</li>
<li><strong>Tail calls in Rust</strong> has a project goal targeting stabilization in 2027; the main blocker is incomplete LLVM backend support on WebAssembly and PowerPC, with recent fixes landed for x86_64, loongarch, and riscv.</li>
<li><strong>Maki</strong> is a Rust TUI coding agent running at 60 FPS that indexes files into tree-sitter skeletons instead of reading full files, saving ~165 tokens per turn, with multi-tier subagents and automatic context compaction.</li>
<li><strong>rust-analyzer changelog #323</strong> fixes Cargo <code>[env]</code> variable override behavior, spurious import completions in qualified paths, and stale diagnostics with custom check commands.</li>
<li><strong>Random Forest ML on GPU</strong> for a bioinformatics variant caller flattens tree data into a BFS array with 16-byte nodes for GPU-friendly access, uses two WGSL compute shaders for inference, and applies wgpu’s <code>MAPPABLE_PRIMARY_BUFFERS</code> for zero-copy unified memory on Apple Silicon.</li>
</ul>


Rust language updates, async patterns, and systems programming.

Rust Digest

Rust 1.95.0 is now stable, introducing the built-in `cfg_select!` macro, if-let guards in match arms, atomic update methods, and other stabilizations. The Linux kernel already has support in place. NearlyFreeSpeech.NET completed a full C++ to Rust migration of their production HTTP frontend, validated against 150 million real requests, with the Rust version running ~2% slower but offering better telemetry. Tailscale released an experimental Rust reimplementation of its core networking stack (tailscale-rs) with FFI bindings for Python, Elixir, and C, though it currently lacks NAT traversal and DNS. Servo 0.1.0 is now on crates.io with a six-month LTS cadence. Additional highlights include zero-copy GPU inference from WebAssembly on Apple Silicon, Rust threads mapped to GPU warps, async Rust debloating techniques, and a high-performance Rust WebSocket server outperforming Laravel Reverb by ~17x on concurrent connections.

Rust 1.95 ships cfg_select! and if-let guards, Tailscale rewrites its core stack in Rust