🦀 Rust

Pointer Provenance in Rust vs C++

A discussion comparing pointer provenance handling in Rust and C++.

Inside DOMINION: a Rust runtime for local-first AI agents

DOMINION is an open-source, local-first AI agent workspace built as a Rust runtime.

The Rust Backend Ecosystem Is Growing. What Comes After Axum and Actix?

Discussion of how the Rust backend ecosystem is evolving beyond Axum and Actix.

5 Rust Projects That Could Change How Developers Build Software

Lists five Rust projects that may shift how developers build software.

Rust 1.100 Is Here: After 10 Years and 5 Failed Attempts, the “Never” Type (!) Is Finally Stable

Reports that Rust 1.100 stabilizes the never type after years of attempts.

What would you think about Native requires and ensures clauses in Rust?

Discussion of adding native requires and ensures clauses to Rust, referencing the vstd and Verus verification frameworks.

Lonewolf 0.3 – A standalone XMPP server written in Rust

Lonewolf 0.3 is released as a standalone XMPP server written in Rust.

Rust 1.100 and the Never Type: What Breaks, What Doesn’t, and Why It Matters

Explains the stabilization of Rust's never type after a long development period and what developers should check when upgrading.

Rust 1.100 Feels Like a Language Growing Up in Public

A commentary on the Rust 1.100 release and how the language is maturing.

Rewrote a desktop widget from Electron to egui: 7% to 1% CPU idle, 273 MB to 20 MB

A developer rewrote a desktop widget from Electron to egui in Rust, reporting large drops in CPU and memory use.

Plugin4Shell: a Git ref-resolution bug let attackers bypass SHA-pinning in 4 AI coding agents

A Git ref-resolution bug let attackers bypass SHA-pinning across four AI coding agents' plugin marketplaces.

Evaluating Crates.io for Distributing Packages of a New Rust-Compiled Programming Language

An evaluation of whether Crates.io is suitable for distributing packages from a new programming language that compiles to Rust.

tracing-systemd v0.4.2: format strings

A new release of the tracing-systemd Rust library adds format string support for logging to systemd journal.

Linux Is Embracing Rust. What Does That Mean for the Future of Systems Programming?

Rust is becoming an established part of Linux kernel development, with implications for memory safety in systems programming.

The Rust programming language has reached its 100th stable release

Reading Lean Side by Side: Introducing Taiyak

A developer introduces Taiyak, a browser tool that splits Lean 4 source code into declarations for side-by-side reading.

Macros and Metaprogramming in the Rust Language

Covers macros and metaprogramming in the Rust programming language.

I built a new programming language with a built-in 3D engine (Built with Rust)

A developer presents a new programming language with a built-in 3D engine, built with Rust.

Rust Fundamentals: Building Fast and Memory Safe Systems

An introduction to Rust covering building fast, memory-safe systems.

NVIDIA Just Made Rust GPU Programming More Serious. CUDA Oxide 0.3 Is Why

NVIDIA's CUDA Oxide 0.3 adds stable Rust support, experimental CUTLASS CuTe bindings, and Qwen model execution.

Tokio Changed How Rust Handles Async. What Could Replace the Next JavaScript Layer?

An analysis discusses how Tokio changed async handling in Rust and what might come next for web development.

I rewrote 7-Zip in Rust — here's what I learned about memory

Author describes rewriting the 7-Zip compression tool in Rust and the memory-safety lessons learned.

After rewriting a small Python service in Rust, the real win wasn't performance

A developer describes porting a Python service to Rust and what the real benefits turned out to be.

AWS Infinity: How Rust Can Keep 75,000 AI Agents in 8 GB of Memory

Describes an open-source Rust runtime from AWS and UC Berkeley that runs large numbers of AI agents in limited memory.

Building Valorex: A Fast, Memory-Efficient Desktop Browser in Rust

A project write-up describes Valorex, a memory-efficient desktop browser built in Rust.

Meet Orionis: The Async-First Python Framework Powered by Rust

Orionis is introduced as an async-first Python web framework with a core built in Rust.

Announcing Rust 1.100.0 | Rust Blog

Announces the release of Rust 1.100.0 from the Rust blog.

Rust Is Becoming Part of the AI Infrastructure Stack. Here’s What Developers Should Know.

Explains Rust's growing role in AI infrastructure and what developers should know about it.

Zellij 0.46.0 just released: Rust developers can now use it as a library!

Zellij 0.46.0 is released with the ability to use it as a Rust library.

Bringing Rust into Ubuntu at Scale: Interview with Jon Seager

Canonical's Jon Seager explains how Rust utilities were brought into Ubuntu at scale after uutils broke builds.

Move your problems to compile-time and get new capabilities out of it - Oli Scherer | EuroRust 2026

A EuroRust 2026 talk by Oli Scherer discusses moving problems to compile time in Rust and the resulting capabilities.

Systemd Wants Rust in, But its Core Will Have to Wait

Systemd is moving toward allowing Rust-written programs, though its core components must wait.

ztmux the pure Rust tmux superset

ztmux is a from-source port of tmux rewritten in Rust, covering the server, client, and grid components.

GitHub Rewrote Copilot in Rust. The 800,000 Lines Aren’t the Impressive Part.

GitHub rewrote its Copilot coding assistant in Rust, and the piece discusses the cost and tradeoffs of that replacement.

I replaced GitLab CE with a Git + .gitlab-ci.yml server in Rust that idles at ~10 MB. Some notes on keeping it small

Author describes building a lightweight Git and GitLab CI-compatible server in Rust that idles at about 10 MB of memory.

cel-rust finally has its own playground, using Wasm in the browser

cel-rust launches a browser playground running the Rust CEL implementation compiled to WebAssembly.

PaperPilot – Zero-Cloud, Pure-Rust PDF Engine with WASM and MCP

PaperPilot is a shared Hacker News project: a zero-cloud PDF engine written in pure Rust that runs via WebAssembly and exposes MCP.

Sanstun: A sans-IO, parallel-friendly WireGuard implementation in Rust

Sanstun is a sans-IO, parallel-friendly WireGuard implementation written in Rust.

Introducing Skif - a repository/monorepo linter written in Rust

A developer introduces Skif, an early-stage monorepo linter written in Rust, and shares its goals.

Rust's Type System is All You Need

A discussion post on Rust's type system and balancing performance with readability.

Debugging Rust in 2026

A discussion-style post about debugging Rust programs in 2026.

Building fine-grained version control for agents with Rust and Durable Objects

A post describes building fine-grained version control for agents using Rust and Durable Objects.