Rust, the language design of lies

Let me say this up front so the comments don't catch fire: I like Rust. The borrow checker is a genuinely brilliant idea and the tooling is a delight. My problem isn't the language. It's the marketing — the bit where "memory safe" is sold as an absolute when it's really a spectrum with some very large holes at the edges.

Safe, until it isn't

Safe Rust is safe. But unsafe exists, it's in the language for a reason, and you don't have to go far to find it. The instant you call into C — and you will — every guarantee the compiler made evaporates at the boundary. The borrow checker has no idea what that foreign function does to your pointers.

The whole world is still C

Your shiny Rust binary links libc, probably OpenSSL, your operating system's libraries, graphics drivers, database clients. Underneath the safe wrapper is a mountain of C that Rust cannot reason about. A safe Rust binding over an unsafe C library is exactly as safe as the C library — which is to say, not. You've put a seatbelt on the passenger seat and left the driver's side bare.

unsafe is load-bearing

Pull on the thread and you'll find unsafe blocks holding up a surprising amount of the ecosystem — in the standard library, in the most-downloaded crates, anywhere performance matters. "Safe" Rust very often stands on unsafe foundations that you, the application author, never audit and mostly never see.

I still reach for it

None of this makes Rust bad. It makes the slogan dishonest. Memory safety is a property of the whole system — your code, your dependencies, the C beneath them, the unsafe blocks you trusted — not a magic badge the language hands you at compile time. Use Rust. Enjoy the borrow checker. Just don't believe the brochure that says you've left memory bugs behind forever. You've made them rarer and pushed them to the edges. That's a huge win. It is not the same as "safe".