CppCoreGuidelines

The C++ Core Guidelines are a set of tried-and-true guidelines, rules, and best practices about coding in C++ (by isocpp)

CppCoreGuidelines Alternatives

Similar projects and alternatives to CppCoreGuidelines

  1. rust

    Empowering everyone to build reliable and efficient software.

  2. InfluxDB

    InfluxDB – Built for High-Performance Time Series Workloads. InfluxDB 3 OSS is now GA. Transform, enrich, and act on time series data directly in the database. Automate critical tasks and eliminate the need to move data externally. Download now.

    InfluxDB logo
  3. adventofcode

    Advent of Code solutions of 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 and 2024 in Scala (by sim642)

  4. rfcs

    RFCs for changes to Rust

  5. book

    The Rust Programming Language

  6. LearnOpenGL

    Code repository of all OpenGL chapters from the book and its accompanying website https://learnopengl.com

  7. build-your-own-x

    Master programming by recreating your favorite technologies from scratch.

  8. learnxinyminutes-docs

    Code documentation written as code! How novel and totally my idea!

  9. SaaSHub

    SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

    SaaSHub logo
  10. too-many-lists

    Learn Rust by writing Entirely Too Many linked lists

  11. carbon-lang

    Carbon Language's main repository: documents, design, implementation, and related tools. (NOTE: Carbon Language is experimental; see README)

  12. {fmt}

    A modern formatting library

  13. dmd

    dmd D Programming Language compiler

  14. Vcpkg

    C++ Library Manager for Windows, Linux, and MacOS

  15. SFML

    Simple and Fast Multimedia Library

  16. cppfront

    A personal experimental C++ Syntax 2 -> Syntax 1 compiler

  17. circle

    The compiler is available for download. Get it!

  18. cppreference-doc

    C++ standard library reference (by p12tic)

  19. Monocypher

    An easy to use, easy to deploy crypto library

  20. ring

    28 CppCoreGuidelines VS ring

    An experiment. (by briansmith)

  21. GSL

    Guidelines Support Library

  22. rules_rust

    Rust rules for Bazel

  23. SaaSHub

    SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

    SaaSHub logo
NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a better CppCoreGuidelines alternative or higher similarity.

CppCoreGuidelines discussion

Log in or Post with

CppCoreGuidelines reviews and mentions

Posts with mentions or reviews of CppCoreGuidelines. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2025-03-30.
  • Essential White Papers for Senior Software Engineers: Advanced Reading for Technical Leadership
    2 projects | dev.to | 30 Mar 2025
    "C++ Core Guidelines" by Bjarne Stroustrup and Herb Sutter Read the guidelines
  • Distributed Systems Programming Has Stalled
    3 projects | news.ycombinator.com | 27 Feb 2025
    I've found both explicit future/promise management and coroutines difficult (even irritating) to reason about. Co-routines look simpler at the surface (than explicit future chaining), and so their the syntax is less atrocious, but there are nasty traps. For example:

    https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines...

  • A Tail Calling Interpreter for Python
    1 project | news.ycombinator.com | 20 Feb 2025
    I liked "Effective Modern C++" although that is a little bit out of date by now. Stroustrup's recent article "21st century C++" https://cacm.acm.org/blogcacm/21st-century-c/ . There are also the C++ core guidelines though maybe those are also out of date? https://github.com/isocpp/CppCoreGuidelines

    I've been looking at Rust and it's an improvement over C, but it still strikes me as a work in progress, and its attitude is less paranoid than that of Ada. I'd at least like to see options to crank up the paranoia level. Maybe Ada itself will keep adapting too. Ada is clunky, but it is way more mature than Rust.

  • 21st Century C++
    3 projects | news.ycombinator.com | 5 Feb 2025
    I haven't read much from Bjarne but this is refreshingly self-aware and paints a hopeful path to standardize around "the good parts" of C++.

    As a C++ newbie I just don't understand the recommended path I'm supposed to follow, though. It seems to be a mix of "a book of guidelines" and "a package that shows you how you should be using those guidelines via implementation of their principles".

    After some digging it looks like the guidebook is the "C++ Core Guidelines":

    https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines

    And that I should read it and then:

    > use parts of the standard library and add a tiny library to make use of the guidelines convenient and efficient (the Guidelines Support Library, GSL).

    Which seems to be this (at least Microsoft's implementation):

    https://github.com/microsoft/GSL

    And I'm left wondering, is this just how C++ is? Can't the language provide tooling for me to better adhere to its guidelines, bake in "blessed" features and deprecate what Bjarne calls, "the use of low-level, inefficient, and error-prone features"?

  • Ray Tracing in One Weekend
    6 projects | news.ycombinator.com | 2 Jan 2025
    See this: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines...

    Technically, headers are just copy-paste, obviously. However, there's value to keeping them as standalone as possible.

  • Rust in QEMU Roadmap
    5 projects | news.ycombinator.com | 3 Dec 2024
  • Don't defer Close() on writable files
    7 projects | news.ycombinator.com | 8 Sep 2024
    > close a file (which ironically is the poster child for RAII)

    Yes, I call this "RAII is a lie" (T-shirt pending).

    Closing file descriptors is univerally used to showcase RAII, but it should never be used for that.

    C++ has the same problem:

    https://github.com/isocpp/CppCoreGuidelines/issues/2203

    In there, it is acknowledged that a manual Close() should always be provided, and used if you want guarantees.

    > is a bad pattern

    Good that Rust at least figured it out early that it's a bad pattern!

    Never use RAII in situations where the cleanup can fail!

  • CppCoreGuidelines: Essential Rules and Best Practices for C++ Developers
    1 project | news.ycombinator.com | 15 Aug 2024
  • What to do if you don't want a default constructor?
    1 project | news.ycombinator.com | 20 Jul 2024
    The standard library types are guaranteed to be in a useful state after being moved from (the term "valid state" is used for this). Of course, that doesn't mean that your own types have to, but the C++ Core Guidelines suggest doing so [1].

    1: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines...

  • I Have No Constructor, and I Must Initialize
    4 projects | news.ycombinator.com | 5 Jul 2024
    It’s in the cpp core guidelines: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines...

    std::reference_wrapper still can’t save you from yourself, but its slightly better.

  • A note from our sponsor - SaaSHub
    www.saashub.com | 18 Jun 2025
    SaaSHub helps you find the best software and product alternatives Learn more →

Stats

Basic CppCoreGuidelines repo stats
321
43,820
7.1
about 1 month ago

Sponsored
InfluxDB – Built for High-Performance Time Series Workloads
InfluxDB 3 OSS is now GA. Transform, enrich, and act on time series data directly in the database. Automate critical tasks and eliminate the need to move data externally. Download now.
www.influxdata.com

Did you know that CSS is
the 17th most popular programming language
based on number of references?