> Its compilation is slow. I mean SLOW. Slower than C++.

No way. Maybe Rust 1.0, but it's steadily improved and it's definitely faster than C++ now.

> It’s complex. Just as complex as C++.

True, but the problem with C++'s complexity is that you have to memorise all of it or you'll accidentally invoke UB. It's so complex that is basically impossible.

Rust is complex but most of the time the compiler will tell you if you got it wrong. There are exceptions of course (lots of async footguns) but it's still night and day.

> Memory safety is not that sacred. In fact, for many applications malfunctioning is better than crashing

Not sure I really need to counter this...

> When handling lots of mutable shared state (GUI, DB, stateful services, OS/hardware), the performance of native Rust memory model is subpar, and non-native unsafes just leave you with slow compilation, high complexity, and no memory safety in the end — which makes Rust practically meaningless for heavy mutable state jobs.

Not totally clear what he's getting at here. Maybe the ergonomics of GUI style programming which are still being figured out? Hardly a deal breaker though is it? There are plenty of C/C++ GUI libraries with terrible ergonomics and the only one that is actually great (Qt) had to use a custom language extension for decades to achieve that.

> So, is the Rust bad or good? It’s neither. It’s a mediocre programming language with thousands of man-month put into its development

I would love to hear what he thinks a good programming language is, because I can easily pick more holes in any other language than he has.

This anti-Rust zealotry is super tedious.

Grrr. Clueless people keep saying that. People have been verifying programs for over forty years now. Formal correctness in terms of not violating assertions is possible for most useful programs. As someone pointed out about the Microsoft Static Driver Verifier, if you're program is anywhere near undecidability, it has no business being in the kernel. This not a legit criticism.

Personally my biggest complain from Rust is that I wish it was more readable. I've seen function signatures that seemed straight out of C++.

Had to buy a new laptop because of this.

Node JS has had vulnerabilities in the past: https://www.cvedetails.com/cve/CVE-2021-22940/

Go is also not Memory safe: https://www.ralfj.de/blog/2025/07/24/memory-safety.html

Yeah, just another data leak, no biggie.

It's still quite rough around the edges, but Crystal is a fun choice for this type of thing. If you want a readable high level language and sane package manager that compiles to reasonably performant machine code, it's worth a look.

I honestly can't find a polite way to describe this statement. It's incorrect in a way that feels insulting. It's not the language's fault that you called the `crash()` function. Every language has a way to terminate execution, and for good reason. It's not even wrong for a server to crash; that's how you pass the error up to the infrastructure layer for handling. The problem here existed at a system design level, not a language level.

For the author to paraphrase this (bad) critique like this:

> You cannot get 99.999% reliability with Rust — it crashes all the time.

is outright dishonest and insulting to me as a reader.

Rust also forces me to really think how the data is layed out in my program (is it on the heap or stack), I have to engineer the program before I write a single line of code or else the borrow checker will yell at me.

Other things I like about rust is, I can write unit tests in the same file as the implementation, this is build in to the language. I also like cargo, clippy, rust doc, rust format. No runtime, compiles to a single binary, support of a variety of platforms and a great community that values high quality secure software.

The only thing I hate about rust is async. I don't use async in my own projects, I just use threads, Rust is great for doing threads (Arc, Mutex, RwLock...)

Edit: fix typos

The author dismisses these defects, but try telling a financial institution that it's "only" corrupt user data when the books don't balance. Explain to an aerospace company that acting sporadically is just fine.

Then I discovered that C++ has a very cool feature that Rust doesn't have: jobs.

Now, I no longer search for Rust positions.

It's true that it's easier to write correct async code using immutable shared data or unshared data.

However, it's very hard if not impossible to do fast and low memory concurrent algorithms without mutable shared state.

How is `T` broken? How are the other things broken?

No matter what language you use, most of the code running between what you wrote and the hardware will be written in C. Your choice for the 1% on top is not very consequential. There is still a huge attack surface area no matter what.

> People create lies to gain power and money. Which is kinda what I was supposed to do, but for random reasons I went rogue and chose sanity instead.

> I am anti-bullshit.

These "contrarian for the sake of being contrarian" vibes naturally flow into this Rust post. Rust has a ton of faults, but this is was a very shallow critique.

- Compile speed. Why do people care so much? Use debug for correctness and iterating your code. You're hardly going to change much between runs, and you'll get an incremental compile. Let rust-analyzer tell you if there are errors before you even try compiling. Let your CI do release optimization in its own time, who cares if CI is slow?

- The cloudflare bug was not caused by rust. Every language needs some way to say "hey this thing is invalid", and that's what happened when the list of AI tools got too long (or whatever their business issue was). Making the app panic was a design choice, not a language choice. Every language has a way to not handle errors.

- Things having unsafe {...} does not make them unreliable. On the contrary, if you run into a memory issue in a rust program, you know where to look for it. The problem in c++ was that the whole program was unsafe, and you then had no way to narrow it down. Memory safety errors are like type errors: a large class of errors that are worth checking for. If you're writing good c++, you have a linter that checks similar things anyway, and if you're disciplined, you've also upgraded warnings to errors. FWIW, I do think the marketing over-emphasizes memory management, because there are a lot of these hard learned lessons that are default in rust but optional in c++.

- Mutable shared state: make bad designs hard to write. Mutable shared state is another one of these eternal bug sources. Use channels and pass messages.

Honestly, it reads like a lot of critiques of Rust: people haven't spent enough time with it, and are not over the learning curve yet. Of course everything is cumbersome before you're used to it.