Should You Learn C++ in 2026? The Uncomfortable

Here's a question I've been hearing since the late 1990s: "Is [insert established language] dead?"

The language changes. The question doesn't. COBOL was supposed to die after Y2K. Java was going to kill C++. JavaScript was a toy. Python was too slow. And yet here we are, and all of them are still running production systems worth billions of dollars.

So when a video from Let's Get Rusty asks whether C++ is still worth learning in 2026, my first instinct is to roll my eyes. But then I watched it, and honestly, it's a more nuanced take than the usual "old language bad, new language good" content that floods developer circles.

The video creator makes a point worth sitting with: "There is more C++ code running in production right now than almost any other language. Billions and billions of lines across every major tech company, every gaming studio, every trading firm."

That's not hype. That's just math. Every Unreal Engine game. Every high-frequency trading system. Most of Chrome. The rendering engines behind the visual effects in basically every movie you've watched in the last decade. That's all C++, and it's not getting rewritten because someone published a blog post about memory safety.

The Problem Nobody Can Fix

But here's where it gets interesting. The video doesn't just genuflect to C++'s legacy and move on. It digs into the actual problems, and they're real.

C++ has accumulated 40 years of features, each solving problems that seemed critical at the time. Templates. Exceptions. Multiple inheritance. Move semantics. Concepts. The result is a language so complex that even experts can't agree on which subset you should use. Go on any C++ forum and you'll find developers arguing about whether to use exceptions or error codes, when to reach for variant versus polymorphism, whether smart pointers are always the right choice.

It's exhausting, and I say that as someone who's been watching these arguments since the Clinton administration.

The memory safety issue is harder to dismiss. The video cites that 70% of security vulnerabilities at Microsoft and Google stem from memory safety bugs—use-after-free, buffer overflows, data races. The kind of bugs that C++ makes possible because it trusts you to manage memory correctly.

C++ has safety tools. Smart pointers, RAII, bounds-checked containers. But they're opt-in, and nothing in the compiler stops you from reaching for a raw pointer when you're in a hurry or feeling clever.

"It's gone serious enough that the White House, the NSA, and the CIA have all published guidance telling developers to move away from memory unsafe languages with C++ being specifically named," the video notes.

That's not developer discourse. That's governments saying "this is a national security problem."

The Replacement Problem

Now, if you've been around the block, you know that "we need to replace C++" is not a new sentiment. The video runs through the graveyard: D Language in the early 2000s, Google's Carbon in 2022, Herb Sutter's CPP2. All attempts to either replace C++ or fix it from within. All stalled or experimental.

Replacing an entrenched language turns out to be really hard. Who knew?

But the video makes a smart distinction. The alternatives that are gaining traction aren't trying to be "C++ but better." They're solving different problems for different contexts.

Go isn't trying to replace C++ in game engines. It's targeting backend services, cloud infrastructure, DevOps tools—places where C++ was overkill and Java was too heavy. The video characterizes it well: "If you're coming from C++, Go will honestly feel like a downgrade in control, but a massive upgrade in productivity."

That tracks with what I've seen. Docker, Kubernetes, HashiCorp's entire stack—these are Go shops. Not because Go is faster than C++, but because shipping working code matters more than squeezing out microseconds.

Zig is the purist's choice—a modern C replacement without the accumulated complexity. No hidden control flow, no hidden allocations, great C interop. But as the video admits, "the job market is basically non-existent right now." Zig is a bet on the future, and most of us have rent to pay in the present.

The Rust Variable

Then there's Rust, and this is where the video's bias shows (it's from a Rust channel, after all). But the argument is worth taking seriously.

Rust is the only language that's actually taken meaningful market share from C++. Not by being easier—Rust's learning curve is notoriously steep—but by making memory safety guarantees at compile time. The borrow checker catches use-after-free bugs, data races, null pointer dereferences before your code runs.

The video points to real adoption: AWS, Microsoft, Google, Cloudflare, parts of the Linux kernel. These aren't experiments. This is production infrastructure.

Here's what I find interesting: Rust succeeded not by trying to be C++ with better syntax, but by reconceiving the entire approach to ownership and memory. That's a genuinely new idea, not a repackaging of old ones.

Does that mean C++ is dying? No. COBOL is still running banks. C is still in the kernel. Legacy doesn't disappear; it just stops growing.

The Actual Question

The video's recommendation is pragmatic: If you're going into a role that requires C++—a specific company, codebase, or industry—then yes, learn C++. If you're already deep in C++ and want to go deeper, that expertise is valuable.

But if you're starting fresh? The video argues for Rust or Go, depending on what you want to build.

That seems about right to me, with one caveat: the job market for C++ is still enormous. Billions of lines of existing code means decades of maintenance work. Someone has to keep Unreal Engine running. Someone has to optimize those trading systems. Someone has to maintain Chrome.

The question isn't "is C++ dead?" It's "where is the growth?"

New projects increasingly pick Rust for systems programming, Go for services. C++ still dominates in industries with massive existing codebases and entrenched tooling. If you want to work in game development or high-frequency trading, C++ knowledge is basically required. If you want to build the next generation of cloud infrastructure, you're probably looking at Go or Rust.

The video ends with a pitch for a Rust roadmap, which is fine—people need to eat, and at least it's transparent. But the underlying analysis holds up better than most "should you learn X" content.

C++ isn't dying. It's just not the only game anymore, and for the first time in decades, that's actually true.