Best of Rust — March 2026

1. 1
   Article

   Bitfield Consulting·5w

   My Rust dev setup in 2026 — Bitfield Consulting

   A Rust developer shares their 2026 development setup, centered around four main tools: Zed editor (fast, native, with rust-analyzer LSP integration and optional AI), ChatGPT (used as a pair programmer, code reviewer, and teacher rather than code generator), Wispr Flow (voice-to-text input for all apps), and Nushell (a structured-data shell written in Rust). The author emphasizes a minimal, low-maintenance setup, skipping Homebrew and heavy configuration in favor of tools that work well out of the box. Rust's built-in toolchain (rustup, Cargo, rust-analyzer) handles most development needs.

   68

   4
2. 2
   Article

   Kitty says hi.·5w

   Beautiful CLI prompt with Starship

   Starship is a minimal, fast, and highly customizable shell prompt written in Rust that works with any shell. It uses a separate TOML configuration file at ~/.config/starship.toml and comes with sensible defaults, 50+ modules for languages and tools, and community presets. The post walks through a personal Starship configuration including custom prompt characters with color-coded exit codes, right-aligned timestamps, Node.js and Rust version display, and the useful `starship explain` subcommand that breaks down each prompt component.

   45

   1
3. 3
   Video

   Code to the Moon·5w

   1000x Faster Than Your Database??? SpacetimeDB Explained by Creator Tyler C.

   Tyler Cloutier, creator of SpacetimeDB at Clockwork Labs, explains the architecture and performance characteristics of SpacetimeDB, a database originally built to power the MMO BitCraft Online. Key technical insights include: transactions execute inside the database (eliminating network hops), a thread-per-core model keeps data in L1 CPU cache, and interactive transactions are traded away for extreme throughput. Benchmarks show 4,000 TPS with Node+Postgres vs 104,000 TPS with SpacetimeDB (TypeScript reducers) and 167,000 TPS with Rust reducers. The conversation covers the database's real-time subscription model (streaming query derivatives to clients), ACID durability guarantees via pipelined async disk writes, the new SpacetimeAuth OIDC system in v2.0, and honest limitations including no interactive transactions, incomplete Postgres compatibility, and single-node write architecture. Tyler also responds to criticism from Vicent Marti, clarifying that the alleged data-loss issue was based on a misreading of the codebase.

   41

   1
4. 4
   Video

   Awesome·6w

   Rust is quietly taking over...

   Rust's influence is growing far beyond its market share. Two major case studies illustrate this: Ladybird browser rewrote parts of its JavaScript engine from C++ to Rust using LLM-assisted translation (25,000 lines in ~2 weeks, zero regressions across 60,000+ tests), and WhatsApp replaced a 160,000-line C++ media library with ~90,000 lines of Rust, now deployed to billions of devices across Android, iOS, and more. Both cases highlight Rust's value at high-risk security boundaries. However, a counterpoint is raised via the 'Farewell Rust' blog post: Rust is poorly suited for web development due to slow feedback loops, template ergonomics, and dynamic SQL friction. The takeaway is that Rust excels as a containment layer for systems-level, security-critical code, but is not a universal solution.

   40

   5
5. 5
   Article

   Tokio·4w

   Introducing dial9: a flight recorder for Tokio

   dial9 is a new runtime telemetry tool for Tokio that captures a full timeline of runtime events — individual polls, parks, wakes, and Linux kernel events — rather than just aggregate metrics. Built to diagnose production-only performance issues, it helped identify kernel scheduling delays of 10ms+ on an AWS service, fd_table lock contention causing 100ms+ polls during startup, and a global mutex in backtrace::trace. With under 5% overhead, it can run continuously in production. Setup requires wrapping the Tokio runtime with TracedRuntime and traces can be viewed in a browser-based viewer or stored to S3.

   34

   2
6. 6
   Article

   Lobsters·6w

   Rust zero-cost abstractions vs. SIMD

   A full-text search query on turbopuffer was taking 220ms instead of the expected ~50ms. Profiling revealed that over 60% of runtime was spent in a merge iterator, not in BM25 ranking. The root cause: Rust's zero-cost iterator abstraction, while compiling each individual call efficiently, prevented the compiler from vectorizing or unrolling across calls due to the recursive nature of `next()`. The fix was a classic database technique — batched iterators — where `next_batch()` fills an array of 512 KV pairs at once, giving the compiler a tight inner loop it can auto-vectorize with SIMD. The result: the benchmark dropped from 6.5ms to 110μs (60× faster), and the production query latency fell from 220ms to 47ms. The key lesson: 'zero-cost' means the abstraction compiles away per call, not that it has no effect on the compiler's ability to optimize across calls.

   34

   2
7. 7
   Article

   Collections·3w

   Ubuntu 26.04 LTS beta is out now, with GNOME 50, Linux 7.0, and no more X11

   Ubuntu 26.04 LTS (Resolute Raccoon) is now in beta ahead of its April 23, 2026 stable release. Key changes include the removal of X11 sessions in favor of Wayland-only (with Xwayland compatibility), GNOME 50 with stable VRR support, and Linux kernel 7.0. New default apps include Resources (system monitor), Showtime (video player), Loop (Rust-based image viewer), and Tixis (GTK4 terminal). Rust is expanding into core utilities with sudo-rs and uutils included by default. The toolchain updates bring Python 3.14, GCC 15.2, and OpenJDK 25. GPU support covers NVIDIA 590 and AMD ROCm, now available in official repos. ARM64 joins x86 as a supported architecture. Beta images are available for testing.

   52

   7
8. 8
   Article

   Collections·3w

   Canonical joins the Rust Foundation as a Gold Member

   Canonical has joined the Rust Foundation as a Gold Member at $150,000/year, earning a seat on the Board of Directors alongside Google, Amazon, Meta, and Microsoft. The move formalizes Canonical's existing Rust commitments: Ubuntu 25.10 ships uutils (a Rust rewrite of GNU Coreutils) and sudo-rs instead of their GNU counterparts, and Ubuntu 26.04 LTS will include the latest Rust compiler and Cargo. Canonical's stated governance priorities include improving the Rust developer experience on Ubuntu, keeping toolchain packages current, and addressing security concerns around the crates.io registry — particularly relevant for regulated environments dealing with unknown transitive dependencies.

   30

   2
9. 9
   Article

   Lobsters·4w

   kdwarn: Introducing pgtui, a Postgres TUI client

   pgtui is a Postgres TUI client written in Rust that lets users interact with a PostgreSQL database from the terminal. Built with ratatui, sqlx, and the toml crate, it supports browsing relations, paginated data viewing, sorting, filtering with WHERE clauses, inserting and editing records via a terminal editor, deleting records, multi-column primary key support, and managing multiple database connections. The project originated from the idea of writing content in TOML/markdown and storing it in a database.

   30

   1
10. 10
    Article

    Hacker News·6w

    Nobody ever got fired for using a struct

    A performance investigation at Feldera revealed that SQL tables with hundreds of nullable columns caused significant serialization overhead when mapped to Rust structs. The root issue: rkyv's ArchivedString loses Rust's niche optimization, forcing an explicit Option discriminant, and with 700+ optional fields the archived struct ballooned to 2x the in-memory size. The fix introduces a bitmap-based serialization layout that strips Option wrappers from the archived format and records nullability in a compact bitfield. A further sparse layout stores only present values with relative pointers, dramatically reducing disk I/O for wide, mostly-null rows. The customer's throughput was restored after serialized row size dropped by roughly 2x.

    29
11. 11
    Article

    It's Foss·4w

    Vykar is a New Open Source Backup Tool That's Faster Than Borg, Restic, and Kopia

    Vykar is a new open source encrypted backup tool written in Rust, developed by the BorgBase team and released under GPL-3.0. It features deduplication via FastCDC, compression with LZ4 or Zstandard, AES-256-GCM or ChaCha20-Poly1305 encryption, a first-party desktop GUI with system tray support, a WebDAV server for browsing snapshots, and concurrent multi-client backup support. Performance benchmarks against a 49 GiB dataset show Vykar completing backups in 61 seconds versus Borg's 268, Restic's 138, and Kopia's 85, with similar advantages in restore times and CPU usage. The tradeoff is higher memory usage (623 MB vs Borg's 236 MB). Configured via a single YAML file, it supports local filesystem, S3-compatible storage, SFTP, and REST server backends. Pre-built binaries are available for Linux, macOS, and Windows.

    27

    1
12. 12
    Article

    Hacker News·3w

    GitHub - t8/hypura: Run models too big for your Mac's memory

    Hypura is a storage-tier-aware LLM inference scheduler for Apple Silicon that enables running models larger than physical memory by intelligently placing tensors across GPU, RAM, and NVMe tiers. It supports three inference modes: full-resident (model fits in GPU+RAM), expert-streaming for MoE models like Mixtral (exploiting sparsity so only 2/8 experts fire per token, achieving 99.5% neuron cache hit rate), and dense FFN-streaming for large dense models like Llama 70B. On an M1 Max 32 GB machine, it runs a 31 GB Mixtral at 2.2 tok/s and a 40 GB Llama 70B at 0.3 tok/s — both of which crash vanilla llama.cpp with OOM. It exposes an Ollama-compatible HTTP API, builds with Cargo (Rust), and requires no manual tuning as pool sizes and prefetch depth are computed automatically from hardware profiling.

    37

    1
13. 13
    Article

    Hacker News·5w

    The Cost of Indirection in Rust

    Function call indirection in Rust async code is almost never a real performance concern. The Rust compiler in release mode frequently inlines extracted helper functions, producing identical assembly to inlined code. The actual costs worth worrying about are I/O, locks, and allocations — not function call boundaries, which cost only a few CPU cycles. Real indirection overhead only matters in tight inner loops, with dyn Trait dynamic dispatch, or in explicitly performance-critical paths. The post argues that premature inlining sacrifices code readability, testability, and maintainability for no measurable gain, and recommends using profilers like callgrind or perf to verify actual bottlenecks before optimizing. The right approach is to extract well-named functions, trust the optimizer, and only reach for #[inline] when profiler data justifies it.

    24

    1
14. 14
    Article

    Pointers Gone Wild·6w

    A Recursive Algorithm to Render Signed Distance Fields

    Signed Distance Fields (SDFs) define 3D objects via mathematical functions and can be combined in powerful ways, but rendering them via raymarching is computationally expensive. A novel recursive divide-and-conquer algorithm is proposed and implemented in Rust that subdivides the view frustum into smaller quads, advancing all rays in a patch simultaneously and recursively splitting only when near a surface. This approach achieves 3–4x fewer rays per pixel and triples frame rate on a simple scene. An extension using linear interpolation for flat patches reduces samples to below one per pixel, reaching 100 FPS on a single M1 CPU core. The technique relates to the known but obscure GPU concept of 'cone marching' using multi-pass shaders. The results suggest CPU-based SDF rendering for real-time 3D games may be within reach with further optimization and multi-core usage.

    23
15. 15
    Article

    Rust·5w

    Announcing rustup 1.29.0

    Rustup 1.29.0 has been released with concurrent component downloads and unpacking during downloads, significantly improving toolchain installation performance. New host platform support has been added for sparcv9-sun-solaris and x86_64-pc-solaris, along with automatic PATH configuration for tcsh and xonsh shells. Quality-of-life improvements include fallback to PATH-based rust-analyzer binaries, treating empty environment variables as unset, and distinct exit codes for rustup check. Update via `rustup self update` or `rustup update`.

    22

    3
16. 16
    Article

    Trevor Lasn·5w

    Why I Chose Rust for 0xInsider

    A solo developer explains why they chose Rust to power 0xInsider, a real-time financial intelligence terminal for prediction markets. With no QA team or on-call rotation, they rely on Rust's compile-time guarantees to catch concurrency bugs, SQL schema mismatches, and unhandled API response shapes before they reach production. The post covers specific architectural patterns: 190+ SQL queries verified at compile time via SQLx, priority scheduling with Tokio's biased select, bounded mpsc channels for WebSocket backpressure, deterministic resource cleanup via Drop, separate typed database pools to prevent cross-contamination, and a 30% memory reduction from swapping in jemalloc. The entire system ships as a single binary. Tradeoffs acknowledged include steep learning curve, borrow checker friction, and slow compile times.

    21

    6
17. 17
    Video

    DevOps Toolbox·4w

    FZF Was Enough. Then I Found Television.

    Television (tivi) is a Rust-based fuzzy finder that goes beyond FZF by introducing a channel-based architecture. Each channel is a configurable picker with a source command, preview pane, and key-bound actions. Out of the box it handles files, text search, git repos, branches, env vars, and directories. Running 'tv update-channels' pulls in a large community cable library covering AWS, Docker, Kubernetes, npm, SSH hosts, Homebrew packages, and more. Custom channels are easy to build via TOML templates. The author demonstrates replacing seven separate utilities (Ranger, kubectx, log viewers, etc.) with TV channels, integrating it with Nushell for Ctrl-R history and Ctrl-T smart completion, and embedding it inside tmux via a floating window plugin. Criticisms include awkward default key bindings with too many Ctrl and F-key combos, no leader-key support, a broken directory preview out of the box, and limited CLI flag composability. Despite these gaps, the author considers it a keeper and a meaningful step forward for terminal workflows.

    23

    1
18. 18
    Article

    Hacker News·4w

    Ubuntu 26.04 Ends 46 Years of Silent sudo Passwords

    Ubuntu 26.04 LTS 'Resolute Raccoon' (due April 23, 2026) will display asterisks for each character typed at a sudo password prompt, ending over 46 years of silent password input. The change comes via sudo-rs, a Rust rewrite of the classic C sudo that Canonical adopted as default in Ubuntu 25.10. The upstream sudo-rs project enabled the pwfeedback option by default, and Canonical cherry-picked the patch into 26.04. Proponents argue the security trade-off is negligible since password length is already visible at graphical login screens, while critics call it a break from historical security practice. Users who prefer the classic silent prompt can restore it by adding 'Defaults !pwfeedback' to their sudoers file via visudo.

    18
19. 19
    Article

    Collections·6w

    Rust 1.94.0 Release: Key Features and Enhancements

    Rust 1.94.0 is now available with several notable additions. The `array_windows` method is stabilized for slices, enabling iteration over constant-length windows with better type inference. AVX-512 FP16 and AArch64 NEON FP16 intrinsics are also stabilized. On the Cargo side, configuration files now support an `include` key for modular config management, and the TOML parser has been upgraded to v1.1 with multi-line inline tables, trailing commas, and new escape characters. Additional API stabilizations include mutation methods for `LazyCell` and `LazyLock`, `Peekable::next_if_map`, and new math constants like Euler's gamma and the golden ratio. Upgrade via `rustup update stable`.

    16

    1
20. 20
    Article

    Hacker News·4w

    Rewriting our Rust WASM Parser in TypeScript

    A team built a custom DSL parser in Rust compiled to WASM, then discovered the bottleneck wasn't computation but the WASM-JS boundary overhead. Attempting to skip JSON serialization via serde-wasm-bindgen made things 30% slower due to fine-grained boundary crossings. Rewriting the parser in TypeScript eliminated the boundary entirely, yielding 2.2-4.6x faster per-call performance. They also fixed an O(N²) streaming problem by caching completed statement ASTs, reducing total streaming cost by 2.6-3.3x. Key lessons: WASM shines for compute-bound tasks with minimal interop, not for frequently-called parsers on small inputs where boundary overhead dominates.

    18

    1
21. 21
    Video

    Code to the Moon·5w

    Rust Was Critical for SpacetimeDB

    The creator of SpacetimeDB explains why Rust was the only viable language choice for building the database. Key requirements included fine-grained allocation control (transactions must complete within microseconds, ruling out garbage-collected languages like Go), and compile-time memory safety guarantees essential for a multi-tenant environment where user code runs inside the database via WebAssembly. C and C++ were considered but lack Rust's safety properties. Zig was noted as an interesting alternative but not yet mature enough on safety.

    15

    2
22. 22
    Article

    KubeSquad·3w

    Instrumenting Rust TLS with eBPF

    Instrumenting rustls with eBPF for L7 traffic capture is non-trivial because rustls separates TLS operations from socket I/O, unlike OpenSSL. On the write path, the OpenSSL-style correlation still works. On the read path, the order is inverted: the syscall fires before plaintext is available, requiring reverse correlation by stashing the file descriptor on recvfrom and attaching it later when reader.read fires. An additional gotcha is that Rust's Result<usize> return convention stores success/error in rax and byte count in rdx, not rax alone. Symbol detection is also tricky due to unstable Rust name mangling, requiring pattern-based scanning rather than exact name matching. These techniques are implemented in Coroot, an open source eBPF-based observability tool, enabling automatic TLS decryption for hyper, axum, sqlx, tokio-rustls, and other rustls-backed libraries with no code changes.

    13
23. 23
    Video

    YouTube·3w

    Linus Torvalds On Rust In Linux #shorts #linux #rust #knowledge #programmer

    Linus Torvalds shares his personal take on Rust in the Linux kernel. While he remains a C person at heart, he acknowledges that Rust hasn't done anything obnoxious enough to make him actively dislike it — a lukewarm but notable acceptance from the Linux creator.

    12

    1
24. 24
    Article

    This Week in Rust·4w

    This Week in Rust 643 · This Week in Rust

    Issue 643 of This Week in Rust covers the latest updates from the Rust community including new project/tooling releases (loadgen-rs, pgtui, Avian Physics 0.6, Cot v0.6), observations and walkthroughs on topics like inline assembly, WebAssembly components, Docker image optimization, and code coverage. The compiler performance triage reports a quiet week with neutral overall performance. 427 PRs were merged, with notable changes to the standard library, Cargo, Clippy, and Rust Analyzer. New RFCs include crate deletion allowances and a Rust Foundation Maintainer fund proposal. Upcoming Rust events worldwide are listed, and the quote of the week reflects on why LLM-generated PRs don't fully contribute to the health of an open source project.

    10
25. 25
    Article

    InfoWorld·6w

    What I learned using Claude Sonnet to migrate Python to Rust

    A hands-on account of using Claude Sonnet (via an AI coding IDE) to migrate a Python blogging system to Rust. The author shares three key lessons: you must know both source and target languages well to catch subtle issues the AI misses; expect significant iteration through prompt-generate-test cycles; and take full responsibility for every line of generated code. Notable failures included Claude omitting authentication checks on nearly all admin routes, producing garbled output mid-session, and inconsistently applying shell syntax. The conclusion is that AI coding tools can accelerate migration work but cannot substitute for developer expertise in both languages.

    10

    1