Linus Torvalds talks AI, Rust, & why Linux is the only thing that matters

Original Article ↗ Hacker News Discussion ↗

Rust’s slow and contentious adoption in the Linux kernel is exposing a deep rift between long-time C developers and those pushing for memory-safe, modern tooling. Commenters debate Rust’s complex syntax and type system, whether its benefits justify added complexity and social friction, and how hostile reactions have already driven at least one key maintainer to step down. Many see memory safety as essential for the kernel’s future, but differ on whether it should come via incremental Rust integration into Linux or entirely new Rust-based kernels.

Rust syntax and type system

  • Several C/C++ developers like Rust’s safety but strongly dislike its syntax, especially deeply nested generic types (e.g., Result<Either<...>>), which they compare to “ugly” modern C++ template code.
  • Others argue these types encode valuable information at a glance (errors vs new vs existing objects) and are standard ML-style algebraic data types.
  • Debate over “over-typing”:
    • One side warns that very strong, highly specific types can make code rigid and painful to evolve.
    • The other side argues strict types are desirable in low-level code and that strong typing plus good tooling can safely guide refactoring.
  • There is discussion about whether language-level sugar (e.g., union-like A | B) would help, and about differences between ADTs and union types for exhaustiveness checking.

Rust in the Linux kernel: culture and conflict

  • A major Rust-for-Linux maintainer stepped down, citing ongoing “nontechnical nonsense.”
  • Multiple comments link this to pushback from long-time C-only kernel developers, including a widely discussed conference exchange where a senior developer framed Rust as a “religion” and Rust bindings as “second-class citizens.”
  • Some see that tone as rude, hostile, and discouraging to contributors; others defend it as a blunt but technically grounded warning that C refactoring will not be constrained by Rust bindings.
  • There is debate over whether kernel developers should proactively help Rust maintainers (e.g., giving heads-up on API changes) vs. treating breakage as entirely the Rust team’s responsibility.

Memory safety, users, and long-term viability

  • Pro-Rust commenters emphasize that most kernel CVEs are memory safety issues and that Rust could significantly reduce such bugs, even if outright panics are now rare.
  • Skeptics argue Linux is already very stable for users and that introducing Rust risks fragmenting the developer base or excluding contributors who only know C.
  • Some view Rust as essential for attracting a new generation of systems programmers, given the shrinking pool of expert C developers; others claim C is simple enough and that Rust’s complexity may slow development.

Alternatives and “Rust kernels” vs Linux integration

  • A recurring argument: instead of fighting over Rust in Linux, proponents could build a new, fully memory-safe kernel in Rust and try to outcompete Linux.
  • Counterarguments:
    • Re-creating a production-grade Linux alternative is seen by many as a multi-decade, massively expensive effort, unlike the 1990s context in which Linux emerged.
    • Improving Linux incrementally with Rust (e.g., for new drivers, embedded kernels, or specific subsystems) yields security benefits today.
  • Mentioned alternatives include Zig (once mature) and various Rust-based OS projects, but none currently match Linux’s maturity or adoption.