HN Reader

That is so good to hear. I feel Rust support came a long way in the past two years and you can do a functional Rust kernel module now with almost no boilerplate.

Removing the "experimental" tag is certainly a milestone to celebrate.

I'm looking forward to distros shipping a default kernel with Rust support enabled. That, to me, will be the real point of no return, where Rust is so prevalent that there will be no going back to a C only Linux.

After all the resistance to Rust in the Linux Kernel, it's finally official. Kudos to the Linux Rust team!

Does the removal of “experimental” now mean that all maintainers are now obligated to not break Rust code?

Does this mean that all architectures that Linux supports but Rust doesn't are straight in the bin?

This seems big. Is this big?

@dang title has been changed to "The (successful) end of the kernel Rust experiment", since there were complaints in the articles comments from the committee members that that was a sensationalization of what actually happened.

Happy to hear. We should embrace new things.

I'm mostly interested in being able to interact with the vfs and build a 9p rust client (in addition to the current v9fs) to support my 9p server [0].

Does anyone know what's the current state / what is the current timeline for something like this to be feasible?

[0] https://github.com/Barre/ZeroFS

What does this practically mean for Linux? Will core parts of it depend on Rust? How closely linked are drivers?

Rust in Linux always worried me because there is currently only one stable backend (LLVM) and only one compiler implementation that doesn't yet have a spec. I like that you can at least compile Linux with Clang and GCC, but there aren't even two options for Rust right now.

So what is written in Rust so far therein?

Hmm seeing as this looks to be the path forward as far as inkernel Linux drivers are concerned , adnfor BSDs like FreeBSD that port said drivers to their own kernel. Are we going to see the same oxidation of the BSD's or resistance and bifurcation.

I need to check the rust parts of the kernel, I presume there is significant amounts of unsafe. Is unsafe Rust a bit better nowadays? I remember a couple of years ago people complained that unsafe is really hard to write and very "un-ergonomic".

C++ devs are spinning in their graves now.

The title sounded worse than it is.

Not a system programmer -- at this point, does C hold any significant advantage over Rust? Is it inevitable that everything written in C is going to be gradually converted to safer languages?

This title is moderately clickbait-y and comes with a subtle implication that Rust might be getting removed from the kernel. IMO it should be changed to "Rust in the kernel is no longer experimental"

  > Mike: rachel and i are no longer dating
  >
  > rachel: mike that's a horrible way of telling people we're married

from the meme section on that page.

really? I recently read that "A 100% Rust kernel is now upstream in Linux 7.4"

Safety is good.

Oh dear can you imagine the crushing complexity of a future Rust kernel.

That's what you get with slippery slopes.

And yet, the Linux kernel's Rust code uses unstable features only available on a nightly compiler.

Not optimal for ease of compilation and building old versions of the Kernel. (You need a specific version of the nightly compiler to build a specific version of the Kernel)

And we're cooked.

Rust in the kernel is a self-fulfilling prophecy.

I guess it's time to finally try FreeBSD.

They had me in the first half of the article, not gonna lie. I thought they resigned because Rust was so complicated and unsuitable, but it's the opposite

I haven't had time to experiment with it yet. How is agent directed development doing with Rust 0-to-1 an 1-inf. product gen?

By the way, M$$$ has already making the transition of its driver writing in Rust

https://github.com/microsoft/windows-drivers-rs

maybe this will be good for the rest of the kernels, IllumOS/HaikuOS/ReactOS.

maybe

I’m curious how they’ll manage long term safety without the guarantees Rust brought. That tradeoff won’t age well.

Rust in the kernel feels like a red herring. For fault tolerance and security, wouldn’t it be a superior solution to migrate Linux to a microkernel architecture? That way, drivers and various other components could be isolated in sandboxes.

Why do Rust developers create so much drama everywhere? "Rewrite everything to Rust", "Rust is better than X" in all threads related to other languages, "how do you know it's safe if you don't use Holy Glorious Rust".

I'm genuinely not trolling, and Rust is okay, but only Rust acolytes exhibit this behaviour.

Completely tangential but it would be nice if could 'natively' run wasm.

This is great because it means someday (possibly soon) Linux development will slowly grind to a halt and become unmaintainable, so we can start from scratch and write a new kernel.

I never used linux because it was built using C++. Never have I cared what language the product was built it. The Rust community however wants you to use a product just because it's implemented in Rust, or atleast as one of the selling points. For that reason I decided to avoid any product that advertises using Rust as a selling point, as much as I can. Was planning to switch from Mac to a Linux machine, not anymore, I'm happily upgrading my mac.