A debate around Rust's integration into the Linux kernel has surfaced, with Linus Torvalds pushing back on strict rustfmt rules. He called the practice "completely crazy" for prioritizing style over practical maintainability.

While Torvalds remains a proponent of Rust in the kernel, his critique raises a key question: how will Rust’s tool-driven development philosophy adapt to the pragmatic demands of massive, long-standing C codebases?

In today’s Rust recap:

> Linus Torvalds pushes back on strict rustfmt rules

> Rewriting SQLite from scratch in Rust

> Solving crate abandonment with a community model

> The future of variadic generics in Rust

Linus Torvalds vs. rustfmt

The Recap: Linus Torvalds has pushed back against the enforcement of strict Rust formatting rules in the Linux kernel, calling the practice "completely crazy" for prioritizing style over practical maintainability.

Unpacked:

  • Torvalds’ main issue is with rustfmt's automated rules, which he argues can create messy diffs and actually harm long-term maintainability, especially with use statements.

  • This is part of a broader critique of development practices that hinder efficiency, as he also criticized poorly formatted text in commit messages in the same discussion.

  • The pushback isn't anti-Rust; Torvalds has previously overridden maintainer objections to advance Rust's integration, signaling his focus is on pragmatic implementation, not the language itself.

Bottom line: This debate highlights the tension between Rust's modern, tool-driven ecosystem and the kernel's deeply pragmatic development culture. The outcome will likely influence how Rust is adopted in other large, mission-critical C codebases.

Rewriting SQLite in Rust

The Recap: The team behind Turso is undertaking a complete rewrite of SQLite in Rust, aiming to preserve the database's legendary reliability while adding modern features for today's high-performance applications.

Unpacked:

  • SQLite's decades-old synchronous design creates limitations, so the rewrite introduces an asynchronous I/O architecture to better support environments like web browsers and object storage.

  • Unlike SQLite's closed development, the new fork, libSQL, embraces an open contribution model and has already attracted over 150 contributors to push the database forward.

  • The switch to Rust enables core architectural improvements like concurrent writes using MVCC, native vector search, and live materialized views for more demanding, real-time workloads.

Bottom line: This project modernizes one of the world's most deployed databases for the next wave of edge and AI-driven applications. By combining SQLite's simplicity with Rust's performance and safety, developers get a compelling tool for building fast, reliable systems.

A Fix for Fork-and-Abandon

The Recap: A recent proposal suggests the Rust ecosystem could solve the persistent problem of abandoned crates by adopting a community-driven model successfully used by the Julia language.

Unpacked:

  • When popular crates are abandoned, developers face the cycle of fragmentation, leading to multiple competing forks like ffmpeg-next and ort that create confusion and dilute maintenance efforts.

  • The Julia community addresses this by moving packages into self-organized GitHub organizations grouped by domain, such as BioJulia for biology or JuliaData for data science tools.

  • This approach helps in centralizing development efforts, ensuring repositories remain accessible even if the original author steps away and fostering a stronger sense of shared ownership.

Bottom line: Adopting a similar model would shift the maintenance burden from single individuals to collaborative communities. This could significantly improve the long-term health and stability of the entire crate ecosystem.

Rust's Next Frontier: Variadic Generics

The Recap: A detailed analysis explores the long-running discussion around adding variadic generics to Rust, outlining the massive ergonomic wins for libraries and the complex design questions that remain unsolved.

Unpacked:

  • The feature would eliminate boilerplate for libraries like Bevy, which currently require manual trait implementations for functions accepting a variable number of tuple parameters.

  • Developers could finally write min(1, 2, 3, 4) instead of nested calls, as variadics would allow extending standard library functions like std::cmp::min and std::iter::zip to handle any number of arguments.

  • Major design hurdles remain, with the community and lang team still debating syntax, variadic lifetimes, and interactions with const generics, as detailed in the official design notes.

Bottom line: Variadic generics promise to drastically simplify APIs for many common Rust patterns, shifting complexity from library users to the compiler. Finalizing the design will be a significant milestone for the language's expressive power.

The Shortlist

Ubuntu plans to migrate to the Rust version of Coreutils in its upcoming 25.10 release, aiming to improve memory safety for foundational command-line tools.

Redox OS detailed its 2025-2026 roadmap, highlighting multi-threaded performance enhancements, server variants, and expanded hardware support to position itself as a secure alternative to Linux.

Servo gained a new experimental GTK widget, allowing developers to embed the Rust-based web engine directly into desktop Linux applications.

A new project is using a novel Rust-based algorithm to calculate every possible viewshed on Earth, with the goal of finding the planet's longest line of sight.

Reply

or to participate

Keep Reading