In this thread: people who believe the myth of the safe C programmer. The one who has memorized the spec and is able to hold endless context in their brain while writing code. They themselves are C compilers.
this post was submitted on 24 Nov 2025
83 points (96.6% liked)
Linux
10229 readers
891 users here now
A community for everything relating to the GNU/Linux operating system (except the memes!)
Also, check out:
Original icon base courtesy of lewing@isc.tamu.edu and The GIMP
founded 2 years ago
MODERATORS
Alex Gaynor recently announced he is formally stepping down as one of the maintainers of the Rust for Linux kernel code with the removal patch now queued for merging in Linux 6.19.
Alex Gaynor was one of the original developers to experiment with Rust code for Linux kernel modules. He's drifted away from Rust Linux kernel development for a while due to lack of time and is now formally stepping down as a listed co-maintainer of the Rust code. After Wedson Almeida Filho stepped down last year as a Rust co-maintainer, this now leaves Rust For Linux project leader Miguel Ojeda as the sole official maintainer of the code while there are several Rust code reviewers.
top 22 comments
sorted by:
hot
top
controversial
new
old
You're kidding yourself if you think most people in this thread are actually programmers. Most people here wouldn't know the difference between C and Rust code if they saw it, let alone be able to write anything in either language.
I think that there are certain attitudes that mainly occur to people outside the domain. Like how people endlessly shit on open-source projects, but few of those people are ever actually at the wheel of one.
If only there were a few alternatives to Rust for system development with a syntax that isn't a marriage of flesh between OCaml and C. Unfortunately none exists, because if I say otherwise, rustacerans will accuse me of "FUDposting", and some will even try to dig up some dirt about me, to ruin my life and to ultimately force me off the web, because shame is good, except if they're the target of said shame.
So we're left with a language that:
- Was marketed as a functional programming language until people started to "FUDpost" about how functional programming has its own issues (optimization, etc.), so the Rust team quickly tried to course correct and market it as a "multi paradigm" language. It is "FUD" if you ask why it's still const by default. If only Oracle found out about this tactic, to market Java as a "multi paradigm programming language", because you can just "opt out from OOP aspects", then tell its usiers that "packaging classes are just good practice".
- Makes many optimizations very ugly if not impossible.
- Makes memory unsafe operations ugly, to "disintensivise the programmer from them".
- Has a pretty toxic userbase, which is only being called out by Lunduke-style toxic morons with anti-woke brainrot, and for the wrong reasons. No, the problem isn't that many people in the Rust community are often trans, and that the code of conduct aren't a selection of Bible-verses, but that a portion of Rust users weaponize callouts, with this callout weaponization actually coming from 4chan and other sites that pioneered networked harassment.
I'm surprised that you didn't mention Zig. It seems to me to be much more popular than either C3 or D's "better C" mode.
It is “FUD” if you ask why it’s still const by default.
I'd be curious if you could show any examples of people asking why Rust is const by default being accused of spreading "FUD". I wasn't able to find any such examples myself, but I did find threads like this one and this one, that were both quite amiable.
But I also don't see why it would be an issue to bring up Rust's functional-programming roots, though as you say the language did change quite a lot during its early development, and before release 1.0. IIRC, the first compiler was even implemented in OCaml. The language's Wikipedia page goes into more detail, for anyone interested. Or you could read this thread in /r/rust, where a bunch of Rust users try to bury that sordid history by bringing it to light
Makes memory unsafe operations ugly, to “disintensivise the programmer from them”.
From what I've seen, most unsafe rust code doesn't look much different compared to safe rust code. See for example the Vec implementation, which contains a bunch of unsafe blocks. Which makes sense, since it only adds a few extra capabilities compared to safe rust. You can end up with gnarly code of course, but that's true of any non-trivial language. Your code could also get ugly if you try to be extremely granular with unsafe blocks, but that's more of a style issue, and poor style can make code in any language look ugly.
Has a pretty toxic userbase
At this point it feels like an overwhelming majority of the toxicity comes from non-serious critics of Rust. Case in point, many of the posts in this thread
Understandable. I'd have been admitted to the asylum (again) after just a few hours of 'working' with Rust.
What? Rust syntax is fucking awful. Ugly, unlogical, unreadable. The build process is fucked up as well.
Yeah, after working so long with the elegant simplicity of C and C++, I just don't think I can tolerate a crappy hacked together language like Rust.
It's ok. It seems a bit ad-hoc to me compared to some of the higher-level academic languages I like (Haskell, Scala, Clojure, Chapel, etc). It's much simpler than C++, and more expressive than C though.
If you're trying to write C code in Rust for a few hours you haven't really given it a proper go. You're just fighting the compiler. Believe me, I've been there. It was just the learning curve before I put aside my pride and adjusted how I wrote code.
If you can learn to read int (*funcs[])(void*, void*), you can learn to read Rust.
Coming from managed languages I found syntax weird, but got more comfortable in few days 🤷♂️ If you're used to one language, then usually the other looks weird initially
Skill issue.
I wonder when this tumor that is rust will be cut out from kernel.org
it's funny that Linus doesn't think of rust as a tumor, but rather acknowledges that more and more code in the kernel will be written in rust. this was just over a week ago.
May I ask why you consider it a tumour?
Mostly because of the mindset of the developers that want to memory safe everything regardless of being ABI or just API compatible.
What if the ABI/API compatibility stays the same? I don't really follow Linux development that closely but has that been an issue with the current progress made with Rust in Linux?
I don't write Rust but I don't really see the problem as long as things are tested properly and development moves slow enough as to not break things
If it stays compatible, and the same licensing model sure, I can deal with it. But it wont (as demonstrated uutils breaking ubuntu updates because of timestamp shenanigans) and certainly won't as already demonstrated with any rust rewrite (moving the License from GPL to MIT.)