Why did the Safe C++ proposal fail?
Hi everyone. Jon here. Today, I'm reporting the unfortunate failure of the "Safe C++" proposal, which aimed to improve memory safety in the programming language C++. C++ is a language widely used in game development and system software, but memory safety issues (e.g., memory leaks and buffer overflows) can be security vulnerabilities. The proposal aimed to incorporate Rust-like safety features into C++, but was officially abandoned around September 2025. First, let me explain the background to the proposal.
Recommended for those who want to start automating with no coding!
With Make.com (formerly Integromat)...
📌 Integrate major tools like email, Slack, Google Sheets, and Notion all at once
📌 Automate complex tasks with just drag and drop
📌 A free plan is also available, so you can try it out for yourself.
If you're interested, here's the details:
What is Make.com (formerly Integromat)? How to Use It, Pricing, Reviews, and Latest Information [2025 Edition]
Overview and Objectives of the Safe C++ Proposal
Safe C++ was proposed as an extension to C++, with a primary focus on improving memory safety. Memory safety is a mechanism for preventing bugs and security vulnerabilities caused by incorrect access by ensuring that a program correctly handles memory (computer storage). For example, the Rust language is designed to guarantee this safety by default, but C++'s high flexibility means that developer mistakes can easily cause serious problems.
Discussions on this proposal began in earnest around 2024, and according to a report by InfoQ, details of Safe C++ were made public around October 7, 2024. The point of the proposal was to create a "safe subset" of C++ (a portion of code restricted by specific rules) that would provide strong guarantees like those of Rust. In other words, the proposal aimed to be a "superset" (extended version) that would allow safe code to be written without breaking existing C++ code. The proposer was Sean Baxter, and it was submitted to the C++ standards committee, attracting a great deal of attention.
Why was this necessary? As can be seen from online news and posts on X (formerly Twitter), memory safety issues in C++ are a major security challenge. For example, a September 2025 article in FinancialContent pointed out that memory-related vulnerabilities caused by C++ account for the majority of overall security issues. With government agencies also calling for improvements to the safety of C++, this proposal could have an impact on enterprise-level cybersecurity.
Here's a little about related tools. I recommend Gamma as a useful AI tool for quickly creating technical documents and presentations. It uses AI to instantly create documents and slides, making it perfect for summarizing technical topics like C++. For more information,This articlePlease check with.
How and why the proposal failed
Unfortunately, the Safe C++ proposal was abandoned around September 2025. According to an InfoWorld article (published September 30, 2025), the proposal's authors stopped work on it due to resistance from the community and compatibility concerns. Let's organize the specific timeline.
- Early 2024: The idea of Safe C++ was proposed, and discussions about incorporating Rust's memory safety into C++ began to pick up steam. A November 4, 2024 article on LinuxSecurity.com introduced the Safe C++ initiative as an attempt to integrate Rust's features.
- 2025 9 Month 13 Day: Simone Bellavia's web page reports that although the proposal has been around for a year, it is proving difficult to achieve a subset that provides strong guarantees (memory safety, type safety, thread safety).
- 2025 9 Month 16 Day: In an article in The Register, the proposal's authors claimed it "no longer works" and effectively abandoned it.
- 2025 9 Month 30 Day: FinancialContent and InfoWorld reported that the C++ standards committee has decided to abandon Safe C++ in favor of the "Profiles" approach instead.
The main reason for its failure was resistance from the C++ community. According to a report by WebProNews in September 2025 (about a week ago), many people were concerned about the risk of losing compatibility with existing code and the increasing complexity of the language. Furthermore, a post by X (around September 2025) suggested that memory safety issues were not due to a "lack of skills" but were fundamental to the language design. Safe C++ was supposed to solve these problems, but it failed to gain consensus from the community.
One alternative that is gaining attention is "Profiles." Proposed by C++ creator Bjarne Stroustrup, this is a method of enhancing safety by using checking functions in the compiler (the tool that converts code into machine code). This approach prevents memory-related errors through static analysis (detecting bugs without executing the code), and avoids large-scale language changes like Safe C++. An article in The Register dated September 16, 2025, states that Profiles is being promoted as a replacement for Safe C++.
Future Implications and C++ Memory Safety
The failure of Safe C++ could affect the security of software using C++. A September 30, 2025 article in FinancialContent points out that this decision will be a "blow" that will leave vulnerabilities in critical infrastructure (OS and high-performance applications). On the other hand, the advancement of the Profiles approach will enhance existing tools (e.g., static analysis in MSVC and Clang) and increase guidelines for developers to write secure code.
Looking at X trends, a post from September 29, 2025, cited famous past vulnerabilities (e.g., Heartbleed's buffer over-read) as examples of C++ memory issues, and called for initiatives like Safe C++. A post from 2024 also pointed out that memory safety in C++ accounts for 70-80% of security vulnerabilities. These discussions show that language-level improvements are needed.
- Impact for developers: C++ developers are encouraged to use safety profiles (rule sets) with Profiles to prevent errors such as buffer overflows and use-after-free errors.
- Industry-wide: Government calls (e.g., the C++ committee's submission to the DOE) may encourage a shift to memory-safe languages (such as Rust).
If you're having trouble creating C++ documentation, check out the AI tool Gamma, which can help you quickly create documents and slides:What is Gamma? A new standard for instant document, slideshow, and website creation using AI.
Summary: Jon's comments
While the failure of Safe C++ is unfortunate, I believe it will serve as an opportunity for the C++ community to advance more practical safety measures. Beginners should start by learning a safe language like Rust, and then enjoy developing while taking advantage of C++'s strengths. Technology never stops evolving, so keep up with the latest developments.
Reference sources
- InfoWorld: Safe C++ proposal for memory safety flames out (December 2025, 9)
- FinancialContent: Safe C++ Proposal Flames Out (September 30, 2025)
- The Register: Safe C++ proposal all but abandoned (September 16, 2025)
- InfoQ: Safe C++ is a new Proposal to Make C++ Memory-Safe (October 7, 2024)
- WebProNews: Safe C++ Proposal Abandoned Amid Community Resistance (September 2025)
- Simone Bellavia's Web Page: Safe C++ proposal is not being continued (September 13, 2025)
- LinuxSecurity.com: Safe C++ Initiative (November 4, 2024)
- Related posts from X (formerly Twitter) (Overview of the Memory Safety Discussion from Trends for 2024-2025)