cppstat - C and C++ Compiler Support Status

The evolution of C++ is a story of relentless innovation, where each new standard introduces powerful features that promise to reshape how we write code. Yet, for developers, this progress comes with a significant challenge: the uneven and often delayed implementation of these features across different compilers. A project called cppstat has emerged as an essential navigational chart in this complex terrain, offering a real-time, data-driven view of which C++26 (and earlier) features are supported by GCC, Clang, MSVC, and Xcode. This isn't merely a checklist; it's a dynamic map of the language's practical frontier, revealing where the theoretical promise of a standard meets the reality of compiler engineering.

At its core, cppstat is a meticulously curated database of language and library features, each mapped to its corresponding C++ standard paper and tagged with its implementation status in the four major compilers. The project's interface allows developers to sort and filter this data in multiple ways—by language versus library, by standard version, or by the degree of support—enabling a targeted exploration of the compiler landscape. For instance, a search for C++26 features immediately highlights the nascent state of the latest standard. Features like Reflection for C++26 (P2996), Annotations for Reflection (P3394), and Expansion Statements (P1306) show a stark reality: GCC 16 is the only compiler with any support (marked as "16"), while Clang, MSVC, and Xcode have yet to begin implementation. This visual disparity underscores the significant lag between standardization and practical availability, a critical consideration for teams planning to adopt cutting-edge features.

The data reveals nuanced patterns of compiler development. While C++26 features are largely unsupported, the status for C++23 and C++20 features presents a more mixed picture. For example, the #embed preprocessor directive (P1967), designed for a scannable, tooling-friendly way to include binary resources, shows partial support in GCC 15* and Clang 19*, with an asterisk indicating an incomplete or experimental implementation. Similarly, the "nice placeholder with no name" (_ as a variable name, P2169) is supported in GCC 14, Clang 18, and Xcode 16.3, but notably absent in MSVC. This granular detail is invaluable; it moves beyond a binary "supported/not supported" classification to acknowledge the spectrum of implementation maturity, from full support to partial or experimental status.

Beyond the raw data, cppstat serves a deeper purpose: it illuminates the strategic decisions and engineering priorities of compiler teams. The absence of support for major C++26 features in Clang and MSVC isn't an oversight but a reflection of the immense effort required to implement complex language changes. Features like Contracts for C++ (P2900) or Standard library hardening (P3471) involve deep compiler and library integration, demanding years of work. The project's data, therefore, acts as a proxy for understanding the compiler development cycle. It shows that GCC, often at the forefront, is already experimenting with C++26, while other compilers are solidifying their C++23 support. This pattern is consistent with historical trends, where GCC's open-source, community-driven model allows for faster iteration on new standards, while commercial compilers like MSVC may prioritize stability and enterprise needs.

The implications for developers are profound. For teams maintaining large, multi-platform codebases, cppstat is a risk-assessment tool. Adopting a feature like constexpr virtual inheritance (P3533) is feasible only if the target compilers support it, and the data shows this is currently a GCC 16-only prospect. For library authors, it informs decisions about which language features can be used in public APIs without excluding significant portions of the user base. The project also highlights the importance of the C++ standard's evolution itself. The push for Reflection and Contracts represents a fundamental shift towards more metaprogramming and design-by-contract capabilities, but their slow implementation suggests a long road ahead for widespread adoption.

Critically, cppstat also surfaces the subtle but important distinctions between compiler implementations. The status for Erroneous behavior for uninitialized reads (P2795) shows GCC 16 support, while others have none. This feature, which introduces the [[indeterminate]] attribute, is a significant step towards safer code, but its uneven support means developers must rely on compiler-specific warnings or static analysis tools in the interim. Similarly, the Remove deprecated arithmetic conversion on enumerations (P2864) is supported in GCC 14, Clang 18, and Xcode 16.3, but not yet in MSVC, indicating a potential portability issue for codebases that rely on the old behavior.

The project's value extends beyond its immediate utility. It embodies a broader trend in software development: the demand for transparency and data-driven decision-making. In an ecosystem where language standards evolve faster than tooling can keep up, tools like cppstat demystify the process. They replace anecdotal knowledge ("I think Clang supports that feature now") with empirical evidence. This is particularly crucial for C++, a language with a vast and complex standard library, where feature support can vary not just by compiler version but by standard library implementation (libstdc++ vs. libc++ vs. MSVC's STL).

For those looking to explore the data directly, the project is available at cppstat. The underlying data is likely sourced from compiler documentation, release notes, and community contributions, making it a living document that will evolve as new compiler versions are released. The inclusion of links to the original standard papers (e.g., P2996 for Reflection) provides a direct path for developers to understand the intent and design of each feature, bridging the gap between specification and implementation.

In conclusion, cppstat is more than a feature matrix; it is a testament to the collaborative, iterative nature of modern C++ development. It provides a sobering yet essential view of the language's present and future, reminding us that the journey from a standard paper to a production-ready compiler feature is long and arduous. For the pragmatic developer, it is an indispensable guide. For the language enthusiast, it is a chronicle of progress. And for the compiler implementer, it is a public ledger of their work, highlighting both achievements and the long road ahead. As C++ continues to evolve, tools that provide this level of clarity will only become more vital in helping the community navigate the path forward.