Conflating Utility in Kernel and OS?
I'm not a Kernel developer. I've written C code back in the day to communicate with serial and parallel ports, and I've recently dabbled with Rust on a user-facing application. So my opinion is admittedly poorly informed.
There are things that are awesome about Rust. Pattern-matching enums, and implementations like Option and Result are great. Using serde to handle JSON is awesome, I don't have to "guess" whether something is a string, a number, etc. Unlike C#, I don't have to worry about a library I'm using really does have nulls properly. Very good things all around, excluding ambiguity around async handling (to tokio or not to tokio...) and error handling (why do we even need thiserror, anyhow, etc.?)
But... in a kernel universe where I imagine you are communicating directly with registers, swapping and paging memory, triggering and responding to interrupts (if that's even a thing anymore), it seems like you'd have to be plugging in "unsafe" in enough places that you are short-circuiting a lot of of the safety that Rust is trying to provide.
Rust seems like a very good fit for the OS, stuff can be built and deployed independently, and where you are directly communicating with user space and getting thrown "who knows what?" Rust's micro-management of typing, ownership, etc. seems very well suited to this corner of the universe. Maybe efforts should be focused on leveraging Rust in the OS, and further refining the language before trying to use it in the kernel.