C++ Alliance Clang Initiative

The Problem

Compiler development is in crisis. The pool of contributors has been shrinking for years while the C++ standard accelerates. The gap between what is standardized and what is implemented continues to widen.

In January 2026, eighteen major compiler implementers published P3962, "Implementation reality of WG21 standardization." Their assessment is stark:

"Many implementers are volunteers or are only partially funded for standardisation work, and there is often no dedicated staffing to implement all standardized features."

"Full conformance to recent standards remains difficult in practice, with some implementations still working toward C++20 conformance with limited capacity to adopt newer standards."

"Adding new features to the standard necessarily displaces other work, including bug fixes, conformance improvements, performance tuning, and various high-value library enhancements."

The implementers themselves are calling for help. The gap does not close on its own—it closes when dedicated engineering time is spent on the compilers.

Our Goals

The initiative has two goals:

1. Continue the maintenance of Clang. We contribute to the day-to-day upkeep of Clang—bug fixes, conformance work, and code review—submitted to official upstream Clang through the standard LLVM review process.

2. Develop an implementation of C++ Profiles. We are building a working implementation of the C++ Profiles framework proposed in P3589R2, carried on this repository's profiles branch, with each proposed profile developed on a branch of its own.

Everything we produce aims for acceptance by the official Clang project; Clang's success is our success.

Clang Maintenance

Maintenance work happens directly in the upstream workflow: issues are triaged on the LLVM tracker, patches are submitted as pull requests to llvm/llvm-project, and every change goes through LLVM's standard review process. The focus is on the areas P3962 identifies as chronically understaffed—bug fixes, conformance improvements, and keeping review queues moving.

The C++ Profiles Implementation

C++ Profiles let a translation unit opt into additional language restrictions: a profile is a named set of rules enforced by the compiler, each formulated to keep the program free of a certain class of problems—for example, use of uninitialized memory. Profiles do not change the meaning of well-formed programs; they reject programs that cannot be shown to be free of the targeted problem.

The work is split across three branches; each profile branch is a series of commits on top of the framework branch.

• profiles — the P3589R2 framework, gated behind the C++-only -fprofiles flag: the [[profiles::enforce(...)]], [[profiles::suppress(...)]], and [[profiles::require(...)]] attributes, including their integration with C++ modules, header units, and AST serialization. Profile names are open-ended—standard, implementation-defined, and third-party profiles are all requested through the same syntax. It carries no profile of its own.
• profiles-init — an initial slice of the std::init profile, the initialization profile proposed by Bjarne Stroustrup in P4222. Its guarantee: no object is read or written before it is initialized, enforced entirely at compile time. Intentionally uninitialized objects are marked with the [[uninit]] attribute and verified by local flow analysis; pointers and references to uninitialized memory are marked with [[ref_to_uninit]]. The profile currently enforces ten individually suppressible rules covering uninitialized declarations, reads, writes, reference bindings, constructors, and static initialization.
• profiles-core-ub — an initial slice of the std::core_ub profile, the runtime-checkable undefined-behavior profile proposed by Vinnie Falco in P4317. Its guarantee: a checkable core-language operation whose precondition is violated traps rather than proceeding into undefined behavior. Nine individually suppressible rules are checked at run time, covering division by zero, signed overflow, invalid shifts, misaligned access, null dereference, out-of-bounds subscripting, floating-to-integer conversion overflow, out-of-range enumeration loads, and flowing off the end of a value-returning function. The cases of P4317 that need whole-program bookkeeping or a support runtime are out of scope for this slice.

Every branch carries a user-facing guide and a design document; on a profile branch, both also document the profile that branch adds.

Prebuilt toolchains (Linux and Windows x86_64) are published as rolling prereleases, rebuilt on every push to a profile branch, so a profile can be tried without building Clang from source: profiles-init-latest and profiles-core-ub-latest.

The feature is experimental: attribute spellings, rule names, and diagnostics may change as the proposals evolve. The long-term aim is the same as for all our work—an implementation of sufficient quality to be proposed upstream.

Team

• Krystian Stasiowski — Compiler initiative lead
• Matheus Izvekov — Reviewer
• Vlad Serebrennikov — Reviewer
• Coordination: #cppa-clang Slack channel

References

• Upstream LLVM Repository
• C++ Alliance Clang Workspace
• The profiles branch — the P3589R2 framework
• The profiles-init branch — the std::init profile
• The profiles-core-ub branch — the std::core_ub profile
• P3962: Implementation reality of WG21 standardization
• P3589R2: C++ Profiles
• P4222: An initialization profile
• P4317: A profile for runtime-checkable core-language undefined behavior
• C++ Alliance