GCC 16 considering changing default to C++20

Original Article ↗ Hacker News Discussion ↗

C++20 as GCC’s Default

  • Some welcome GCC 16 moving to C++20 by default, wanting easier access to features like modules without extra flags.
  • Others insist serious projects should always pass an explicit -std= flag, so defaults shouldn’t matter for well-maintained code.
  • Concern is raised that unpinned legacy projects and deep dependency trees implicitly rely on a stable default and may break when it changes.

Modules Debate

  • A strong faction argues C++20 modules are a failed feature: underspecified, implemented ad‑hoc across major compilers, and not robust enough for serious, non‑hobby code.
  • It’s noted that the original high‑profile “modules are dead” critique predates standardization, but commenters claim the final standard still lacks a solid, independently implementable spec.
  • Counterexamples like Microsoft Office are clarified as using non-standard “header units,” not full C++20 modules, so not evidence of mainstream module adoption.

Standards Support and Backward Compatibility

  • People question why not default straight to C++23 or newer; the answer in the linked GCC docs and thread is that support is still incomplete.
  • Compatibility concerns center on new keywords and stricter rules making previously valid code fail. There’s disagreement over whether this constitutes “breaking changes”:
    • One view: C++ rarely makes truly breaking changes and is strongly backwards compatible.
    • Another: changing defaults so old code fails to compile is practically a breaking change, even if technically minor.

Bootstrapping and Self‑Hosting

  • Some confusion arises about whether changing the default impacts GCC’s own build; others clarify that GCC’s build uses explicit standard flags, so this is only about user defaults.
  • There’s a side debate on bootstrapping and whether using the latest standard complicates self-hosting with older compilers; participants dispute what “requires bootstrapping” actually means.

Rust and Release Cadence Comparison

  • A few praise C++’s slower, multi‑year default updates compared to Rust’s rapid evolution, arguing Rust’s culture of always targeting very new compilers complicates distro self‑hosting.
  • Others counter that Rust projects can and do pin minimum versions, and that rapid improvements are beneficial rather than inherently problematic.

Anubis / Anime Gateway Tangent

  • A large subthread focuses on the anime-style Anubis gateway in front of the GCC mailing list:
    • Some find it jarring, unprofessional, or creepy, especially in serious or corporate contexts.
    • Others like the playful aesthetic, argue open-source maintainers should prioritize fun over “corporate bland,” and note that the mascot doubles as a funding/branding mechanism (free version keeps the mascot; paid allows custom art).
    • Comparisons are made to Cloudflare-style blocks: Anubis is considered less harmful because it still shows page content, though some note performance issues on poor connections.
    • There’s a meta-argument about cultural bias toward anime art and whether negative reactions to “anime mascots” reflect broader prejudices.

Coroutines and ABI Concerns

  • One commenter wonders whether differing coroutine implementations could break interoperability between GCC and Clang binaries; the question is raised but not substantially resolved in the thread.

Practices and Personal Choices

  • Several commenters reiterate they always specify language standards and warning flags (both for C and C++) and consider relying on defaults a bad practice.
  • Some developers state they’ll continue using older standards (e.g., C99 or C++03/11) regardless of GCC defaults, prioritizing stability and long-term compatibility over new language features.