The editorial argues the timing is urgent because Stroustrup is 75, Koenig is 73, and the engineers who built Cfront, the STL, and fought the export-template war won't be available for conference talks in 2040. Recording their oral history now is the documentary's core justification.
Sutter announces the film as the first feature-length archival treatment of C++, framed around two years of interviews with Stroustrup, ISO committee members, and the practitioners who shipped C++ into production systems. His framing treats the documentary as legacy-preservation work for a community that has not previously had this kind of historical record.
The editorial argues the industry confuses 'new' with 'important' and points to V8, Linux userspace, AAA game engines, exchange matching engines, CUDA, and PyTorch's hot path as evidence that C++ runs the compute that actually matters. The languages developers talk about and the languages they deploy into serious production have diverged, and C++ sits squarely on the deployment side.
Commenters from the C++ practitioner camp thanked the producers for finally telling the story of a language they have shipped for decades. Their reaction reflects a sense that C++'s real-world importance has long been undersold relative to trendier languages.
Commenters posted tombstone emoji in response to the announcement, treating the documentary as a sign C++ is on its way out rather than a celebration of a living language. Their reaction frames the film as confirmation of the Rust-led memory-safety transition consigning C++ to legacy status.
A third group in the thread pushed back on the premise itself, asking why C++ — neither newly born nor newly dead — warrants a feature-length film right now. Their skepticism questions both the cultural moment and whether a language still in active use needs retrospective treatment.
Herb Sutter posted on June 4, 2026 that *C++: The Documentary* is now live. The film — independently produced over roughly two years with interviews of Bjarne Stroustrup, members of the ISO C++ committee, and a generation of practitioners who shipped C++ into browsers, operating systems, trading floors, and game engines — is the first feature-length archival treatment of the language.
The Hacker News thread surfaced fast (130 points in a few hours, a respectable number for a non-news post on a Wednesday) and the comments split predictably: long-time C++ engineers thanking the producers for finally telling the story, Rust adopters posting tombstone emoji, and a third group asking the obvious question — *why does a 45-year-old programming language need a documentary, and why now?*
The answer is that C++ is simultaneously the most-deployed and the most-quietly-receding language in the industry, and someone finally noticed that the people who built it are old enough that the oral history needs to be recorded before it isn't. Stroustrup is 75. Andrew Koenig is 73. The compiler engineers who shipped the original Cfront, the STL authors, the people who fought the export-template war — they will not be giving conference talks in 2040.
There is a tendency in our industry to confuse *new* with *important*. The languages that get documentaries are supposed to be the ones with momentum: Rust, Zig, Mojo, whatever Andreas is announcing next month. C++ doesn't trend. It runs.
Look at what shipped this morning while you were reading Twitter. Chrome's V8 engine: C++. The Linux kernel's userspace allies — systemd, most of the GPU stack, the BPF toolchain's heaviest pieces: C and C++. Every AAA game engine in production. The matching engines at every major exchange. CUDA. PyTorch's hot path. The languages developers *talk* about and the languages developers *deploy into production for compute that actually matters* have diverged further than at any point since Java vs. Perl in 2003. A documentary is a useful forcing function to notice that.
The film's most interesting argument — and the one Sutter has been making for a decade — is that C++'s problems are governance problems, not language problems. Modules took 16 years from proposal to usable implementation. Contracts slipped C++26. The ABI break debate has been litigated four times and lost four times, each time costing the standard library performance that a younger language gets to claim as a benchmark win. The committee designs by consensus across vendors who ship to customers who will sue if a 1998 binary stops linking. This is the price of being the language that runs the infrastructure.
Rust's growth isn't a language-design victory so much as a permission-to-break-things victory. Cargo can deprecate. Editions can shift defaults. The borrow checker can get stricter every six months because there is no Fortune 500 customer holding a 30-year support contract. The documentary, from the clips Sutter has shared, doesn't dodge this. It frames the trade-off honestly: C++ chose backward compatibility as a feature, and that feature is now actively repelling new projects.
The community reaction is worth reading carefully. The top HN comment as of this writing notes that the film interviews people who *use* C++ in domains where the alternatives genuinely don't exist yet — embedded systems with 16KB of RAM, real-time audio, large-scale physics simulation. That's not nostalgia. That's a map of where the next decade of systems programming actually happens, and which language gets used there is not obvious.
If you are a senior engineer making language choices in 2026, the documentary is useful in a way that conference talks aren't: it shows you the *shape* of a language's lifecycle. C++ took 20 years to go from 'novel' to 'unavoidable' and is now 25 years into the 'unavoidable but unloved' phase — which based on COBOL, Fortran, and C suggests another 30 years of deployment ahead of it, not 10. Plan accordingly.
Concretely: if your codebase is C++, the documentary is ammunition for the conversation about *staying* on C++ for the modules you can't realistically rewrite. The financial cost of a full Rust rewrite of a mature C++ codebase is, by every public account from Mozilla to Discord to Cloudflare, brutal. The fashionable answer is 'rewrite in Rust.' The pragmatic answer is 'isolate the unsafe boundary, modernize the C++ to C++23, and stop apologizing.' The film makes the case for the second path better than any blog post will.
If your codebase is Rust or Go and you are hiring, watch the documentary to understand what you're losing access to. The engineers who can debug a use-after-free in a 4-million-line C++ codebase under time pressure are some of the strongest systems thinkers in the industry, and they read the job market correctly. They are mostly not applying to your Rust-only shop. The cultural premium your team puts on 'memory safety by construction' is reading, to them, as a refusal to engage with the harder problems they spent careers learning to solve. That's a hiring signal worth examining.
The documentary will not change C++'s trajectory. The committee will keep moving at committee speed, the next ten years of new infrastructure will keep being written in Rust and Zig, and the ten years after that will be written in whatever replaces those. But the film will, with luck, become the canonical answer to 'why is this language like this' for every junior engineer who inherits a C++ codebase for the next 20 years — and that is a more useful artifact than any standards document. Watch it. Then go fix your build system.
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.