A new experiment by Anthropic saw autonomous agents generate a 100,000-line C compiler using Rust. By utilizing the language's ownership model as a safety net, the system successfully built a functional Linux kernel without direct human coding.

This project highlights how strict compiler guarantees are improving the viability of autonomous code generation at scale. As agents handle more boilerplate infrastructure, will Rust become the default choice for machine-written systems?

In today’s Rust recap:

> Anthropic agents write a C compiler in Rust

> NetBSD opts out of Rust kernel integration

> ClickHouse CTO discusses Rust/C++ interoperability friction

> Rust 2026 roadmap aims to simplify the borrow checker

Anthropic AI Writes 100k-Line C Compiler In Rust

The Recap:
Anthropic deployed a team of 16 autonomous AI agents to write a 100,000-line C compiler in Rust, successfully building the Linux 6.9 kernel for roughly $20,000 in API costs.

Unpacked:

  • The system ran 16 parallel Claude Opus 4.6 instances that autonomously managed git locks and utilized Rust’s ownership model as a guardrail to prevent memory safety issues during code generation.

  • To verify the generated compiler's accuracy without human oversight, the agents treated GCC as a ground-truth oracle and ran extensive test suites to identify and fix bugs iteratively.

  • Despite achieving a 99% pass rate on standard test suites, the resulting compiler produces code that is less efficient than optimized GCC output and currently lacks its own linker.

Bottom line:
This project demonstrates that Rust's strict compiler guarantees are uniquely improving the viability of large-scale autonomous code generation. Systems developers can expect AI agents to increasingly handle boilerplate-heavy infrastructure tasks while humans focus on high-level architecture and optimization.

NetBSD Rejects Rust Kernel Integration

The Recap:
The NetBSD core team has firmly decided against integrating Rust into the base operating system kernel, prioritizing their motto "Of course it runs NetBSD" over the benefits of memory safety. This decision highlights the friction between modern language tooling and legacy hardware support, as detailed in recent community discussions.

Unpacked:

  • NetBSD supports over 50 hardware architectures—including vintage systems like VAX and Alpha—where the Rust compiler toolchain currently lacks the necessary support to function reliably.

  • Developer Benny Siegert explained that Rust's six-week release cycle creates a severe versioning mismatch with NetBSD's multi-year support model, as shipping a stable-but-old Rust compiler would render it useless for compiling modern crates.

  • The team also cited the circular dependency created by the Rust compiler being written in Rust, which imposes significant bootstrapping challenges on exotic hardware that lacks the resources found in the Linux or Windows development ecosystems.

Bottom line:
This rejection underscores a significant lingering gap between modern memory-safe languages and the extreme portability requirements of legacy computing environments. While Rust dominates modern systems development, C remains the only viable option for projects prioritizing universal hardware support over strict memory guarantees.

ClickHouse CTO: The “Weird” Reality of Mixing Rust into a C++ Giant

The Recap:
ClickHouse CTO Alexey Milovidov shared the gritty details of integrating Rust into their massive database at FOSDEM 2026, revealing that despite the hype, only 2% of the runtime is Rust due to significant build system friction.

Unpacked:

  • Despite the industry enthusiasm for rewriting legacy systems, Milovidov clarified that 98% of the codebase remains in C++ because replacing stable, existing libraries provided little immediate return on investment.

  • The team encountered unexpected infrastructure challenges, such as the memory sanitizer failing on the Delta kernel library because it did not provide the necessary symbols for the tooling to function correctly.

  • Integrating the two languages using Corrosion resulted in complex dependency conflicts, including a case where the build system accidentally included two different versions of OpenSSL.

Bottom line:
Integrating Rust into established C++ architectures creates significant "glue" complexities that can complicate testing and build pipelines. Engineering teams should weigh these infrastructure costs against language benefits before attempting partial migrations.

Rust Unveils 2026 Roadmap: “Beyond the &” and Annual Goals

The Recap:
The Rust project has released the first draft of its 2026 goals, marking a strategic shift from six-month iterations to an annual planning cycle designed to support more ambitious, long-running technical initiatives.

Unpacked:

  • The new annual planning cycle aims to solve the fragmentation of previous years by allowing teams to focus on large-scale improvements that require sustained effort rather than rushing to meet short-term deadlines.

  • A primary flagship theme, "Beyond the &", focuses on simplifying the borrow checker experience to make writing Rust feel more like using a garbage-collected language without sacrificing performance.

  • To prevent burnout, the proposal introduces a structured capacity model where teams categorize requests as small, medium, or large to ensure team capacity is not exceeded by ambitious feature requests.

Bottom line:
This shift suggests the language is prioritizing long-term stability and deep ergonomic improvements over rapid feature iteration. Developers can expect a more predictable roadmap that tackles deep-rooted usability challenges like the borrow checker learning curve.

The Shortlist

System76 prepares the stable release of its Rust-powered COSMIC Desktop, implementing a custom Iced toolkit to deliver a memory-safe, high-performance alternative to established Linux interfaces.

Slint shipped version 1.15, adding dynamic grid layouts and improved Python type hinting to the GUI framework while enhancing Android and iOS platform support.

Protify launched a new library that inverts the traditional Protobuf workflow, enabling developers to define models in native Rust and compile them to proto files with Serde-like ergonomics.

Aegis demonstrated a distributed firewall built on libbpf-rs, utilizing XDP to filter packets at the driver level for sub-100ns latency without the overhead of a service mesh.

Zerocopy released version 0.8.37, expanding its safe transmutation toolkit to support complex sized-to-unsized casts with static checks for alignment requirements.