Last updated on

Why I Still Prefer C++ Over Rust

Introduction

Rust has become the darling of many developers, especially in systems programming and game dev circles. Tools like Cargo and engines like Bevy give Rust an edge in safety and developer experience. I gave it a fair try, but after weeks of testing and building small prototypes, I always found myself coming back to C++.

Here’s why C++ still feels like home for me.

My Background

I’ve been working with C++ for years. From Qt desktop apps to Unreal Engine projects and even quick prototypes with Raylib, I’ve grown comfortable with its explicit control. I know how memory is handled, how execution order flows, and how every line of code interacts with the rest of the system.

This level of clarity and predictability is something I value more than abstract safety guarantees.

The Appeal of Rust

Rust has a lot going for it:

  • Cargo makes project setup and dependency management effortless.
  • cargo new, cargo run, and cargo test streamline workflows.
  • Built-in safety with ownership, lifetimes, and the borrow checker.

For newcomers, this is fantastic. Compared to wrestling with CMake, vcpkg, or Conan, Rust feels like a modern dream.

But tooling alone isn’t enough to convince me.

The Bevy Experience

Bevy is a popular Rust game engine based on Entity Component System (ECS). ECS can be powerful, but it adds layers of abstraction.

  • In C++: change a property, and the effect is immediate.
  • In Bevy: changes are filtered through systems, and unless you manage execution order, results can be unpredictable.

Debugging becomes harder because you’re juggling Rust’s borrow checker and ECS scheduling at the same time. For me, this uncertainty is frustrating.

The Cost of Rust’s Safety

Rust’s safety features are real — fewer crashes, safer memory usage. But they also come with a price:

  • The borrow checker often feels like it’s fighting you.
  • Complex application logic becomes harder to express.
  • Combined with ECS frameworks like Bevy, the mental overhead is even heavier.

Why C++ Still Works for Me

C++ gives me:

  • Immediate feedback — no scheduling, no hidden execution flow.
  • Mature ecosystems — libraries, frameworks, and decades of battle-tested tools.
  • Fine-grained control — memory, performance, and execution exactly how I want it.

And let’s not forget: modern C++ is evolving fast. With C++17, C++20, and C++23, we already have stronger type systems, safer patterns, and cleaner syntax that cover many of Rust’s advantages.

Tools like CLion, CMake, vcpkg, and Conan bring a workflow closer to Cargo while keeping full control in the developer’s hands.

Final Thoughts

Choosing a language is always about trade-offs. Rust is excellent, and for large teams or safety-critical systems it might even be the best choice. But for me — working on game dev, tools, and frameworks — C++ remains unmatched.

I want clarity, predictability, and direct control. Rust gives me safety, but at the cost of productivity and simplicity. That’s a trade I’m not ready to make.

So for now, despite the hype around Rust, I’ll keep sticking with the language that has shaped my workflow for years: C++.