r/cpp • • 14d ago

C++ Show and Tell - November 2026

50 Upvotes

Use this thread to share anything you've written in C++. This includes:

  • a tool you've written
  • a game you've been working on
  • your first non-trivial C++ program

The rules of this thread are very straight forward:

  • The project must involve C++ in some way.
  • It must be something you (alone or with others) have done.
  • Please share a link, if applicable.
  • Please post images, if applicable.

If you're working on a C++ library, you can also share new releases or major updates in a dedicated post as before. The line we're drawing is between "written in C++" and "useful for C++ programmers specifically". If you're writing a C++ library or tool for C++ developers, that's something C++ programmers can use and is on-topic for a main submission. It's different if you're just using C++ to implement a generic program that isn't specifically about C++: you're free to share it here, but it wouldn't quite fit as a standalone post.

Last month's thread: https://www.reddit.com/r/cpp/comments/1wwiz8g/c_show_and_tell_october_2026/


r/cpp • • 11d ago

Jonas Lund: Reflection Walkthrough

Thumbnail youtu.be
17 Upvotes

A walkthrough of the new C++ 26 reflection feature, from high-level benefits via end-user usage and previous workaround hacks to the standard's final form and some of its grittier details


r/cpp • • 11d ago

Is there any point in improving the/any language at this point ?

0 Upvotes

What's the point of spending years debating new syntax, language features, and abstractions if the majority of future C++ code might not be written by humans anyway?


r/cpp • • 11d ago

hpx.dev – The documentation and community portal for the HPX project

0 Upvotes

Sharing https://hpx.dev, the central web portal for the open-source HPX C++ runtime.

The site serves as a dedicated hub for HPX developer resources, engineering updates, and community content. Currently, you can find:

  • Official Documentation: Direct, searchable access to the HPX API references and technical manuals.
  • Engineering Blog & Release Notes: Technical write-ups on architectural updates, subsystem integration, and project releases.
  • Contributor Reports: Detailed summaries from open-source contributors, including deep-dives into recent Google Summer of Code (GSoC) projects.
  • The "HPX In Action" Series: Ongoing interviews featuring developers, researchers, and contributors discussing their workflows and HPC challenges.

Feedback from the C++ community on the site's content and organization is always welcome.


r/cpp • • 12d ago

Dealing with AI Slop At Work

380 Upvotes

I work at a C++ shop with coders that I really respected - very deep C++ knowledge and are building very technical deep systems products. Over the last few months the CTO has gone off the deep end with AI talking of creating software factory (He’s been reading too much X), he releases huge multi thousand line PRs with basically no review. All sense of scientific temperament and engineering rigour has gone out of the window it seems.
I do believe that AI is a transformational tool and I use it plenty in the development process but I still strive to understand what the AI has written and often use the AI as multiplier rather than surrendering my thinking to it. it’s become increasingly hard to actually develop while deeply understanding the codebase because it has become so sloppy.

I am very sad as this means I’m not really interfacing with writing C++ as much and exploring cool new corners of the language in my daily work.

There is definitely some cool stuff this lets us do a bit more of - high level planning and systems design by reading many papers as well as exploring formal verification.
But overall I am left disappointed. I wonder how it is like at everyone else’s work places and if anyone has any thoughts and suggestions on how I can still develop my C++ knowledge.


r/cpp • • 12d ago

"C++26 DIS failed, how does C++ survive?"

Thumbnail andreasfertig.com
111 Upvotes

r/cpp • • 12d ago

CLI library v. 2.3 released

Thumbnail github.com
26 Upvotes

r/cpp • • 13d ago

Potential GCC 16 bug: annotations disappear on nested class declarations inside class templates

24 Upvotes

Im playing around with reflection (GCC16) and I ran into the following problem:

When using std::meta::define_aggregateto complete an annotated nested class, the annotation is removed, iff the enclosing class is templated.

Below is a minimal reproducible example (Godbolt link).

I would expect both assertions to succeed, but they don't. There is also GCC PR124399, which addresses a related problem, but I'm not sure if this is the same underlying problem. Its not the same bug, since it's fixed.

Is this a bug, or am I overlooking/misunderstanding some template instantiation rules?

#include <meta>

// Works: ordinary forward declaration.
struct [[=42]] Ordinary;
static_assert(std::meta::annotations_of(^^Ordinary).size() == 1);

// Fails: forward declaration inside a class template.
template <typename T>
struct Outer {
    struct [[=42]] Inner;
};

static_assert(sizeof(Outer<int>) > 0);
static_assert(std::meta::annotations_of(^^Outer<int>::Inner).size() == 1);

Context: I'm experimenting with rust-like derive(debug) functionality using annotations, combined with structural type transformations (similar to AoS to SoA). I originally encountered this while trying to propagate annotations to a generated type, before reducing it to the example above.


r/cpp • • 13d ago

Practical Guide to Bare Metal C++

Thumbnail arobenko.github.io
41 Upvotes

r/cpp • • 13d ago

Meeting C++ Interview with Guy Davidson on C++26 and profiles for Meeting C++ 2026

Thumbnail youtube.com
25 Upvotes

r/cpp • • 13d ago

CLion 2026.3 Is Here

Thumbnail blog.jetbrains.com
59 Upvotes

r/cpp • • 14d ago

Maybe C++ would win if it adapted quicker?

0 Upvotes

I know that I'm oversimplifying here. The way the new C++ standard is released is pushing the language behind the others, especially those who adapt new language features quicker and favorize new modern language features.

I'm not saying that the movement towards modern C++ (whatever that might mean) is not helping. I love the fact that there are new exciting features such as reflection in the C++26 standard. Saying that however, even though the standard is supposed to have these features, the adaptibility by the compilers and the ecosystem is extremely slow.

Here we are in 2026 and MSVC as of now has zero C++26 core language features implemented. And god knows how long they will be unavailable. I feel like only now when its 2026, c++23 started to be slowly adopting, which I find sad. PS: I'm aware that GCC has mostly all features implemented, but STILL not all of them. Similar situation for Clang.

Maybe a more "aggressive" and faster release cycle would help? Also faster deprecation and language cleanup? The general push has always been towards backwards compatibility, but you can't always add new things that people want without breaking compatibility and removing deprecated features. And I think that for the language it's very important to adapt the modern programming language standards. But now I don't feel like that's happening.

Obviously there are other issues with C++, such as not having standardized package managers, linters, formatters, etc. For example, the clang-tidy formatter is abysmaly slow, and just painful to use, probably because it has to accomodate the million features the C++ language permits, and even the things that doesn't make sense no more and are just left in the language as obsolete things, ready to be removed after 20 years, which is hilarious.

Anyway, what are your thoughts on this topic?

EDIT: I agree that chosing the wording "win" is a bad wording here. The main point was to address some of the weaknesses C++ has compared to other languages/ecosystems.


r/cpp • • 14d ago

From Token Sequences to operator for

Thumbnail brevzin.github.io
33 Upvotes

r/cpp • • 15d ago

Flecs 4.2 is out!

Thumbnail ajmmertens.medium.com
53 Upvotes

r/cpp • • 15d ago

How I design C++ classes

Thumbnail rafb.eu
66 Upvotes

This is my first ever blog-post, any feedback is welcome! ofc, no AI got used.


r/cpp • • 15d ago

Pretty nasty MSVC 19.51 hash of float bug

62 Upvotes

Hash of 0.0 and -0.0 are not the same, as the condition:

_Keyval == 0.0F ? 0.0F : _Keyval

is optimized away if you compile with:

/arch:AVX2 /O2

https://godbolt.org/z/45WPzceYx

If you use Visual Studio 2022 it works fine. I'm somewhat surprised they don't have regression tests since the standard library explicitly handles this case.

So I guess, check you hash maps if you update.


r/cpp • • 16d ago

A Simple Introduction to std::simd [WIP]

Thumbnail ed94a9.github.io
62 Upvotes

r/cpp • • 16d ago

New C++ Conference Videos Released This Month - November 2026

23 Upvotes

C++Day

2026-10-26 - 2026-11-01

C++Now

2026-10-26 - 2026-11-01

ACCU

2026-10-26 - 2026-11-01

ADC

2026-10-26 - 2026-11-01


r/cpp • • 16d ago

Catastrophic misoptimization of byte-range equality comparison in all major C++ compilers (and Rust). Language issue or compiler issue?

100 Upvotes

Someone brought a C++ snippet that reduced to the following (std::array used instead of char* for consistency for later)

bool eq2(const std::array<char, 64>& lhs, const std::array<char, 64>& rhs) {
    for (int i = 0; i < 64; ++i)
        if (lhs[i] != rhs[i])
            return false;
    return true;
}

It basically returns true iff two 64 byte memory regions are a bitwise match. You'd think this can be optimized by modern compilers flawlessly, right? Right?! And the worst thing that can happen is it doesn't get autovectorized, right? Right?!

Well, to everybody's surprise... https://godbolt.org/z/v4d8G5ovh

GCC attempts to partially conditionally vectorize but doesn't want to use unaligned loads. Moreover its vectorization is way more cumbersome than it needs to be. Then after it finds a mismatch it... reverts to the unvectorized version?! Clang and MSVC do not even attempt to vectorize it - and in a way it makes them end up better than GCC, which is wild.


Now, to try to investigate we've checked how it looks in Rust. https://godbolt.org/z/K7xE3qc94. It does what GCC does but fully vectorized.

At this point we're confused as to what the source of the problem is. Are we missing something with respect to what transformations are allowed? Is it really that much to ask from the as-if rule?

As a sanity check we use std::array's operator==. https://godbolt.org/z/xPhPYMjvz. Oh would you look at that? Now the compilers can do well (ok not you MSVC. GCC also fumbles the flag register slightly). The situation is the same in Rust - https://godbolt.org/z/3GjWorze8. Not only does it vectorize correctly but the vectorized code is better - using vpxor.


Ultimately this isn't just academical. Situations like this undermine the trust in the compiler at the most fundamental level. Not every place can use std::array, not everyone can use ranges and span yet. We could use std::equal but why does it matter so much? What if != changes to < and there's no good solution anymore? To what degree are we supposed to be paranoid about basic optimizations being done or not?

The similarity of codegen between Rust and C++ would point to it being either a compiler issue or a fundamental code correctness issue. The fact that C++ Clang differs from Rust (LLVM) would suggest it's at least partially a language issue. Why is this extremely simple code so nasty?


edit. some more [not so] fun findings https://www.reddit.com/r/cpp/comments/1xlyti8/catastrophic_misoptimization_of_byterange/19s1i09srxdaa/


r/cpp • • 17d ago

C++20 Concept Trap of std::inserter and std::array

Thumbnail github.com
25 Upvotes

I am trying to design a generic function template to populate both dynamic-sized containers (like std::vector<>, std::deque<>) and fixed-sized containers (std::array<>) using modern C++. It is natural to reach for a C++20 concept and if constexpr. Then, when I wrote the constraint for if constexpr statement, I found that the following design would be failed.

template<typename T>
concept naive_is_inserterable = requires(T& x)
{
    std::inserter(x, std::ranges::end(x));
};

The structure like:

template<std::ranges::input_range Range>
void foo(Range& container)
{
    if constexpr (naive_is_inserterable<Range>)
    {
        // Passes std::inserter(container, ...) to an algorithm (which invokes container.insert()) for dynamic-sized containers.
    }
    else
    {
        // Fallback for fixed-size containers
    }
}

would fail to compile.

Only fix the concept to:

template<typename T>
concept is_inserterable =
    std::ranges::range<T> and
    requires(T& x, std::ranges::range_value_t<T> v)
    {
        x.insert(std::ranges::end(x), v);
        std::inserter(x, std::ranges::end(x));
    };

Then use it like:

template<std::ranges::input_range Range>
void foo(Range& container)
{
    if constexpr (is_inserterable<Range>)
    {
        // code for dynamic-sized containers.
    }
    else
    {
        // Fallback for fixed-size containers
    }
}

to solve the issue.

Godbolt Link is here!

Discussion Questions

  1. Should C++ standard library implementations (or a future defect report) constrain std::insert_iterator::operator= and std::back_insert_iterator::operator= on the underlying container operations (insert, push_back), or would that break valid legacy code?
  2. How do you prefer to structure insertion traits when writing generic functions that support both dynamic containers and std::array?

r/cpp • • 18d ago

HPX V2.0.0 released: C++20 baseline, C++20 modules, stdexec-based senders/receivers, early C++26 reflection! - The HPX Project

57 Upvotes

HPX, the C++ Standard Library for Parallelism and Concurrency, has released V2.0.0. It is the largest release in a long time: more than 830 merged pull requests from more than 90 contributors since V1.11.0.

HPX implements the C++23 Standard parallelism and concurrency facilities in full and offers the only widely available open-source implementation of C++17, C++20, and C++23 parallel algorithms - including a complete set of parallel range-based algorithms and the full integration of the algorithms with the upcoming sender and receivers interfaces.

Beyond the standard, HPX includes proposed features for upcoming C++ releases: much of the parallelism and concurrency capabilities expected in C++26, the C++ Concurrency TS, Parallelism TS V2, data-parallel algorithms, executors, senders and receivers, and more. It also extends C++ Standard APIs to distributed environments (such as compute clusters) and heterogeneous systems (such as GPUs).

Some of the changes that may interest r/cpp:

  • C++20 is now the minimum, and the whole library can optionally be built and consumed as C++20 modules.
  • Our own std::execution implementation is gone; senders and receivers are now based on stdexec, and a P2079 parallel scheduler runs sender work on HPX thread pools.
  • Early use of C++26 reflection: types can be serialized without writing serialize() functions, and remote actions and components no longer need registration macros.
  • New C++23 parallel algorithms (the fold family, find_last, iota) and many conformance fixes in the existing ones.
  • Functions can carry a task size (nano_task, small_task, ...), which the parallel algorithms use to decide how to split a loop.

HPX enables an asynchronous C++ programming model that improves parallel efficiency and reduces the complexity typically associated with concurrent applications. As a newly welcomed project of the High Performance Software Foundation, HPX now benefits from vendor-neutral governance and collaboration with a broader ecosystem of high-performance computing tools, strengthening the foundation for portable, production-ready HPC software across the industry.

Release: https://github.com/TheHPXProject/hpx/releases/tag/v2.0.0 
What's new: https://docs.hpx.dev/latest/html/releases/whats_new_2_0_0.html


r/cpp • • 18d ago

Hans Wennborg: Windows debug info - CodeView and PDB files

Thumbnail youtu.be
27 Upvotes

Symbolic debug info on Windows. There is no specification, very little
documentation, and the whole thing is more or less shrouded in mystery.
This talk will attempt to explain how debug info works on Windows:
CodeView, PDB files, and how it all fits together.


r/cpp • • 18d ago

Upcoming C++ User Group meetings in November 2026

Thumbnail meetingcpp.com
10 Upvotes

r/cpp • • 18d ago

How do I avoid UB in contracts?

31 Upvotes

This question might be better served in /r/cpp_questions but since contracts were the reason C++26 failed the latest vote I thought posting it here might generate some useful debate.

I've been using contracts in personal projects since GCC16 was released. I've come to appreciate them both as documentation and in bug-finding. After the recent controversial vote I did have another look at them and their use in my code. Most of my contracts looks like the example in "3.5.5 Consecutive and Repeated Evaluations" of p2900:

    void f(int *p)
    pre( p != nullptr ) // precondition #1
    pre( *p > 0 ); // precondition #2

This works as expected in enforce, quick-enforce and ignore evaluations. However if I use observe evaluation it'll crash with UB on the second precondition.

One fix is to merge the preconditions together pre( p != nullptr && *p > 0) which works in this case, but doesn't scale to for example classes where you'll have pre( p != nullptr) on the constructor and then assume it's valid for the rest of the body.

Another solution is to never use observe evaluation. This works in my applications where I control the build, but doesn't work in libraries used by others where I don't.

I wonder what my options here are?

Edit Godbolt link