rustc
Fewer than 5 people recommend it so far, so there's no written verdict. Here is what commenters said.
Why people recommend it
“Those are all what Rust developers (who were or still are quite advanced C++ devs, btw, not people who are afraid of using raw ptrs) get freely from the Rust compiler.”
“rust compiler is a very good guardrail & feedback mechanism for AI”
Caveats and dissent
“rustc is also awfully shoddy”
“A bug as careless as can be.”
Show 2 more
“the Rust compiler fail to implement the rules of Rust the language”
“It was annoying after buying Rust to learn that you can't play on official servers on Linux.”
Often compared with
Who recommends it in their own words
From the makers not counted in the ranking
“improve the user experience of rustc itself”
“I'm working on a project in Rustc to speed up compile times”
“In the Rust toolchain we've done the same”
“Rust Compiler (rustc) Contributor”
Threads where it came up
- Today, we hacked what we'd set out to hack: the iPhone 1 mention
- C++26 Contracts: Introduction to Preconditions and Postconditions 1 mention
- Show HN: Proa – A Rust web framework with fast SSR and multi-target rendering 1 mention
- Problems with the Rust Language 1 mention
- Valen's Memory Safety: A New Kind of Borrow Checking 1 mention
- How to speed up the Rust compiler in September 2026 1 mention
Also written as Rust, Rust compiler. Data: rustc.json. Quotes are verbatim; the verdict and theme labels are written by a model from these comments, and every clause links to its sources.
All comments 23
It might not be a magic security wand, but so many critical vulnerabilities in software trace their origins to memory unsafe code and things like "use after free". "~70% of the vulnerabilities Microsoft assigns a CVE each year continue to be memory safety issues" - Microsoft [1] "We adopted Rust for its security and are seeing a 1000x reduction in memory safety vulnerability density compared to Android’s C and C++ co
“rustc is also awfully shoddy”
“A bug as careless as can be.”
“since rustc has CUDA now”
“then rustc will be able to produce the patches directly”
“the Rust compiler fail to implement the rules of Rust the language”
> whereas a Rust object only has identity if it has a non-zero size. Rust also has the complication that function pointers are not guaranteed to have an unique identity; If multiple functions compile to the same code, the compiler is allowed de-duplicate them. The documentation [0] also warns it's also possible for the compiler to create multiple versions of the same function. And while I've absolutely seen the compi
this one may actually be solvable, but I kinda timed out on it. okay, so I'm doing distributed systems, and my primary abstraction is a large stream that I'm using to connect components across machines. its kind of mandatory that I implement back pressure for these streams, because awful things can happen if I don't. ok, I have a large local container of records that I want to stream over a back pressured channel. no
“Those are all what Rust developers (who were or still are quite advanced C++ devs, btw, not people who are afraid of using raw ptrs) get freely from the Rust compiler.”
I would add that Rust also has naming guidelines and sticking to them removes or at least minimizes the occurrence of another common topic of discussions on PRs/reviews. In the article, if you were to mention & follow them GetUser() in Go becomes user() in Rust[1], not get_user(). [1] https://rust-lang.github.io/api-guidelines/naming.html#getter-names-follow-rust-convention-c-getter
“Not the same niche as Rust or Ada.”
> But this is all moot as long as compilers are still not conforming to the provenance model with respect to integer and pointer casts anyway and this breaks Rust too! Rust having decided something just means they life in fairy tale world, while C/C++ not having decided means they acknowledge the reality that compilers haven't fixed their optimizers. I think this is a bit of a mischaracterization. While there can of
“rustc already tracks various compilation-related benchmarks”
“rust compiler is a very good guardrail & feedback mechanism for AI”
“rustc 1.93 (with `-O`) does the correct thing for size=1”
> you can still ignore the return value Only when you don't need the Ok value from the Result (in other words, only when you have Result<(), E>). You can't get any other Ok(T) out of thin air in the Err case. You must handle (exclude) the Err case in order to unwrap the T and proceed with it. > It also litters your code with branches, so not ideal for either I-cache or performance. That's simply an implementation/ABI
“the emitted code is not the same as gcc or clang when using SIMD intrinsics by default”
“rustc refuses to compile this code due to multiple mutable borrows of `v`”
Two questions: Why was the fix to this unsafe memory safety bug [0] only changes to code outside of unsafe Rust blocks?[1][2] Why does the Rustonomicon[3] say the following? > This code is 100% Safe Rust but it is also completely unsound. Changing the capacity violates the invariants of Vec (that cap reflects the allocated space in the Vec). This is not something the rest of Vec can guard against. It has to trust the
https://steveklabnik.com/writing/does-unsafe-undermine-rusts-guarantees/
“It was annoying after buying Rust to learn that you can't play on official servers on Linux.”
The number is memory vulnerabilities. Not if they are exploitable. The numbers comes from this part of the article: This near-miss inevitably raises the question: "If Rust can have memory safety vulnerabilities, then what’s the point?" The point is that the density is drastically lower. So much lower that it represents a major shift in security posture. Based on our near-miss, we can make a conservative estimate. Wit
Since it seems that Rust programmers are unable to provide a definition for "memory safety", here is what more mature and academically minded people think: https://blog.adacore.com/memory-safety-in-rust Notice that in-bounds indexing is included, same as in the definition from this submission that I quoted at you.