Linux 0.11 rewritten in idiomatic Rust, boots in QEMU

Original Article ↗ Hacker News Discussion ↗

An early Linux 0.11 kernel has been rewritten in idiomatic Rust and made to boot in QEMU, prompting debate over code size, readability, and whether Rust’s safety and abstractions justify the added complexity. Many suspect large parts were generated by AI, raising questions about the educational value, authenticity, and long-term maintainability of such rewrites. More broadly, commenters argue over the growing trend to “Rust-ify” existing C and Zig codebases with LLM assistance, weighing memory safety and modernization against hype, tooling dependence, and cultural fatigue.

Scope of the Rewrite and Line Count

  • Commenters note the Rust repo has many more lines than the original C sources (initially ~50k vs ~8–12k SLOC).
  • Others point out that:
    • A breakdown shows ~15k lines for the kernel; the rest are tools, utilities, and userland programs.
    • Comments, tests, and extra abstractions in Rust contribute to the size.
    • Verbosity differences are debated: some see Rust as more explicit/verbose, others say it can be as concise or shorter than C for equivalent functionality.

AI Involvement and “Slopware” Concerns

  • Multiple commenters suspect large parts were generated by an LLM (based on README style, emojis, and “idiomatic abstractions” language).
  • Some see this as acceptable or even ideal for a toy / proof-of-concept project that no one will run in production.
  • Others are frustrated by AI-generated “token projects,” seeing them as low-effort self-promotion and less impressive than human-authored rewrites.
  • There is concern that AI rewrites often just move unsafe patterns into “unsafe Rust” without true safety gains.

Rust Idiomaticity, Readability, and Safety

  • Some commenters find the Rust fork implementation similar or even shorter than C for specific syscalls (e.g., fork).
  • Others criticize the Rust version as “onerous”:
    • Many lines serve abstractions, error handling, or language constraints rather than core logic.
    • Heavy use of nested closures and complex type inference is seen as hurting readability and requiring strong tooling.
  • Supporters argue Rust’s explicit enums, types, and borrow checking reduce classes of bugs and can justify rewrites.

Purpose and Value of the Project

  • Widely acknowledged as a toy / educational / proof-of-concept effort (Linux 0.11 is not practically useful today).
  • Some see value in:
    • Demonstrating that a kernel can be “Rustified.”
    • Exploring AI-assisted large rewrites and workflows.
  • Others argue the educational value is lost if an LLM did most of the coding.

Broader Rust and LLM Backlash

  • Several comments express fatigue with:
    • Constant “X rewritten in Rust” announcements.
    • The combination of Rust evangelism and AI-generated rewrites.
  • Counterpoints emphasize:
    • Rust’s growing role in replacing unsafe C, including in userland and kernels.
    • That experimentation and “fun” side projects should still be encouraged.