Topic

Rust

Everything filed under Rust, newest first.

Showing 81–100 of 109 articles

  • Benchmarking Wild vs Mold

    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:

    Blog post · Performance · Programming · Rust · Open Source

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

    Announcement · Security · Rust · Open Source

    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.

    Blog post · Programming · Rust · Systems Programming · Open Source

    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.

    Blog post · Rust · Programming · Engineering · Systems Programming

    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.

    Blog post · AI Agents · Rust · Engineering · Performance

    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!

    Blog post · Open Source · Web Development · Rust

    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.

    Guide · Rust · Tokio · Async Programming · Performance

    1 min · 295 wordsagent-written

  • I made a build profiler to understand Bun's compile times

    Lalit Maganti built buildprof, an open-source Linux tool that records every process spawned during a build and renders them on a shared timeline. He used it to investigate the 5x speed difference between Bun's Zig and Rust builds, tracing the bottleneck to Full LTO in the linker and a downloaded WebKit library that amplified it.

    Blog post · Performance · Build Tools · Rust · Zig

    1 min · 318 wordsagent-written

  • Guest Post: Rust Is Tier-1 Language at Microsoft

    Victor Ciura from Microsoft DevDiv announces that Rust has achieved Tier-1 language status at Microsoft, meaning it now has a fully paved path from local development to production. The post introduces rustc_codegen_utc, a new Rust code-generation backend that connects the Rust compiler to Microsoft's native MSVC toolchain.

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

    1 min · 244 wordsagent-written

  • Introducing CUDA Rust: Two Tracks for Writing GPU Kernels

    In September 2026, NVIDIA announced it is leaning into native GPU programming in Rust. CUDA C++ and CUDA Python are mature, enterprise-grade toolchains, and NVIDIA will be growing and maturing CUDA Rust into 2027 and beyond The systems layer of AI spans inference engines, serving infrastructure, drivers, and agent runtimes, and it churns constantly as models and techniques change. More and more of it is written in Rust, which catches whole classes of bugs at compile time…

    Announcement · Rust · Hardware · Programming · Performance

    11 min · 2,528 words

  • React Now Rusted All The Way Out

    Master.dev describes switching a 1,036-file React Router codebase from the Babel-based React Compiler to the new Rust-native version available via oxc, achieving a 17.6x speedup in the compiler phase and a 2.4x overall build improvement. The post also covers how to migrate using both the official Vite plugin and an alternative for React Router framework mode.

    Blog post · React · Rust · Vite · JavaScript

    1 min · 264 wordsagent-written

  • Dropping Swift entirely from our Bevy iOS crates

    Rustunit explains dropping Swift from Bevy iOS crates in favor of objc2—why the Swift glue went away, what the new crates look like, and what it means for Bevy-on-iOS maintainers.

    Changelog · Rust · Mobile · Open Source · Programming

    4 min · 988 words

  • Visualizing Rust's Vtables: How dyn Trait Works In Memory

    A Rust learner coming from C++ examines how dynamic dispatch works in memory, contrasting Rust's wide pointer approach, a data pointer paired with a vtable pointer, with C++'s in-object vtable pointer. The post also explores zero-sized types, object safety rules, and the specific situations where dynamic dispatch is necessary.

    Blog post · Rust · Memory Layout · Systems Programming · C++

    1 min · 299 wordsagent-written

  • simple is not small

    A software developer argues that simplicity and smallness are distinct properties that the programming community often conflates. Drawing on Rich Hickey's definition of simplicity as absence of coupling, the post shows that a classic Unix pipeline can be small but tightly coupled, while a large program like Google Drive can feel genuinely simple to its users.

    Blog post · Software Design · Complexity · Unix · Clojure

    1 min · 278 wordsagent-written

  • Developing provably correct Rust code with Verus

    Many open-source and industry software projects, including several here at Amazon, are embracing the Rust programming language, since it provides performance and flexibility similar to that of the C programming language, while its clever type system automatically prevents a variety of bugs and security vulnerabilities. The result is fast code that's more correct and secure than average.

    Research · Rust · Research · Security · Programming

    6 min · 1,443 words

  • This Month in Redox - August 2026

    # This Month in Redox - August 2026 ##### By Ribbon and Ron Williams on Redox OS is a complete Unix-like general-purpose microkernel-based operating system written in Rust. August was a very exciting month for Redox! Here’s all the latest news. Sorry for the delayed report, a combination of busy development, time off, conference attendance, other work, and various random factors got in the way. ## Donate to Redox If you would like to support Redox, please consider donating or buying some merch! - Donate - Patreon - Merch has moved from Teespring to Amaze Commerce:…

    Changelog · Open Source · Rust · Systems Programming

    9 min · 2,040 words

  • How I managed multi-agent worktrees in a large Rust codebase

    Manuel Tumiati walks through six failure modes of running many AI agents across git worktrees in a large Rust repo—shared targets, locks, orphaned artifacts—and the fixes that made it workable.

    Blog post · Rust · AI Agents · Programming · Developer Tools

    18 min · 4,149 words

  • Testing WebGPU data layouts with Facet

    Matt Keeter shows how Facet reflection plus naga lets Rust unit tests catch WGSL/Rust struct layout mismatches—padding on mat3x3, dynamic arrays, and field offsets—before GPU hangs force a reboot.

    Tutorial · Rust · Programming · Tutorials · Hardware

    6 min · 1,444 words

  • What Zig felt like, coming from Rust

    A Rust developer's first real Zig project: how the language feels for systems work—manual memory, comptime, error handling, and where it differs from Rust's ownership model and tooling.

    Essay · Programming · Zig · Rust · Systems Programming

    11 min · 2,535 words

  • The making of a very fast SPI flasher

    localcc builds an Xbox 360 dual-NAND modchip and pushes an RP2040-based SPI flasher as fast as possible, replacing the SPI peripheral with PIO programs written in Rust, profiling with Tracy, and optimizing the USB path to approach the ~29 second theoretical read limit through the SMC.

    Blog post · Hardware · Embedded · Rust · Performance

    12 min · 2,770 words