Why a 35‑Year C Veteran Says Rust Revitalized His Love for Coding

Rust Enters the Linux Kernel

Linux’s kernel, built on tens of millions of lines of C, has long resisted new languages. In a recent episode of the Rust in Production podcast, core maintainer Greg Kroah‑Hartman (driver core, USB, TTY, stable kernels) and Google Android Rust team member Alice Ryhl discuss the historic integration of Rust into the kernel.

Re‑building Trust: A Social Challenge

Both speakers agree that the biggest obstacle is not technical but sociological. The kernel’s operation depends on trust among thousands of contributors: developers are expected to fix bugs when they arise, not to write flawless code. Rust’s strict type system forces C maintainers to clarify pointer ownership, lifetime, and mutability, turning implicit assumptions into explicit contracts and strengthening that trust.

“Rust makes programming fun again.”

Unexpected Benefits for Existing C Code

When Rust bindings are written, the compiler demands precise definitions. For example, a classic C pointer return:

// Classic C pointer return
struct device *get_device_info(void);

In C the ownership, borrowing, and lifetime are ambiguous, leaving developers to infer semantics. Rust wrappers must specify whether the pointer is an Arc, a Box, or a simple reference, compelling C authors to clean up their interfaces. Greg notes that this “reverse pressure” often leads to direct improvements in the original C code.

Why Drivers Are the Hardest Part

A common misconception is that core subsystems (scheduler, memory allocator) are hardest; Greg asserts that drivers are actually the toughest because they consume the entire kernel’s resources. Writing a Rust driver requires binding every underlying C module (memory allocation, I/O, networking, file systems) to Rust.

Memory Allocation Constraints

Linux’s allocator is context‑sensitive (e.g., GFP flags for interrupt context, NUMA‑aware pools). The standard Rust alloc crate cannot satisfy these constraints, so the Rust‑for‑Linux team stripped std and created a custom alloc library tailored for kernel use.

Klint: Compile‑Time Sleep Checks

The kernel forbids sleeping while holding certain locks or in interrupt context. Mistakes cause deadlocks that are hard to debug. The Rust‑based compiler plugin Klint scans code paths at compile time and emits errors if a prohibited sleep‑triggering function is called in such contexts, achieving a level of safety beyond traditional C static‑analysis tools like Coccinelle.

Personal Reflection: Rust’s Healing Effect

Greg, after 35 years of C, describes how Rust eliminated the “meta‑cognitive overhead” of manually tracking pointer lifetimes and ownership. He says Rust handles the painful, error‑prone details, allowing him to focus on business logic without fearing memory bugs. This transformation restored his enjoyment of programming.

Conclusion

The Linux kernel’s greatness lies not merely in its C codebase but in its open, pragmatic engineering culture. When superior tools like Rust appear, the community embraces them, improving both the language ecosystem and the underlying C code. The discussion ends with applause, underscoring the collaborative spirit that drives such deep system‑level evolution.