-
Stay up-to-date with everything C++! Content directly fetched from the subreddit just for you. Join our group for discussions : @programminginc Powered by : @r_channels
Can I rant for a minute.
Call me weird but I think the majority of C++'s issues stem from one very fundamental problem: the language cannot evolve because everyone is against breaking ABI. Yes, this is another one of these posts. Allow me to try something new.
I think everyone already knows how we got here and this is what's driving me nuts. I don't understand why there hasn't been a push to actually solve it. Like, actually push against the entities that are against breaking ABI and allow the language to actually move forward instead of tiny baby steps. As Bjarne has said, there's a better, less-complicated language inside C++. We'll never see it with our current self-imposed limitation. It is clearly a self-imposed limitation and quite frankly I find it ridiculous we're still here. It's not like C++ is the only language and other languages haven't found a way around this issue with one solution or another.
Against all reason, I love C++. Don't ask me why. I've been using this frankenstein language since I think the early 90s. I continue using it now and have written a (very playable) 2D game engine with it. And, as with any experienced C++ programmer, my issues with the language are numerous. To name a few:
1. I think vector, string, and a few other STL types should have been baked into the language.
2. We have way too many ways to initialize a variable.
3. Argument passing is unnecessarily complicated compared to other languages.
4. The h/cpp compilation model is a dinosaur.
5. Why did we get copyable_function instead of function2? Let's not even get into that discussion.
6. Modules seem almost terminal upon arrival. (Yes, I've heard both that they are basically usable now, and also that the spec is fundamentally flawed.)
7. People are already complaining about reflection including STL headers because it needs vector. Don't even get me started on the prospect of something like refl_string and refl_vector.
8. Destructive moves.
9. ~~Let me know in the comments if I didn't include your favorite issue.~~
C++ has had some very nice evolutions. C++11 was great. Reflection will hopefully be a great addition. (Modules was supposed to be a great addition but let's not go there right now.) But there are so many competitor languages at this point it's just bonkers there are few or any attempts to solve the fundamental issue: C++ cannot grow because it cannot get out of its own way. Would C++ have so many flawed (map/set) or downright unusable features (regex) if there was a feasible way to go back and fix them? As an aside, I tried using std::regex in a utility for my game engine. At this point it would likely take over 2 minutes to execute said utility. Using CTRE, it executes in just a few seconds.
I honestly think it's no secret why Circle, Rust, and Go exist. Would they exist if C++ had an effective -- or at least, agreed-upon -- way to break ABI? (Or, ISO forbid, breaking ABI wasn't necessary by some means.) I have doubts about the feasibility of something like std::network because if one security hole is found that affects ABI, the whole thing becomes basically permanently unusable. Something like std::gui would also be dead upon arrival.
C++ specs get one chance to get it right. If they don't -- and unfortunately the rate is not 100%, which is unattainable anyway -- it's extra complexity in the language that is, for all intents and purposes, a "noob trap". I think this is dumb. I can't be the only one. I have to imagine this "we must get it right on the first shot" is also what makes passing a new paper outrageously difficult.
I really don't want to hear "we can't because breaking ABI would break tons of applications". I still think it's a self-imposed limitation, and it is time to recognize the heavy damage it's done to the language. You're limiting the evolution of the language to the extreme detriment of its usability. I personally cannot overstate this. The solutions are many, and if it comes down to "every major C++ release is an ABI break" so be it. C++'s technical debt is
C++26 is done! ISO C++ standards meeting, Trip Report
https://herbsutter.com/2026/03/29/c26-is-done-trip-report-march-2026-iso-c-standards-meeting-london-croydon-uk/
https://redd.it/1s71t0x
@r_cpp
Modern Loki: C++20 header-only port of Alexandrescu's classic, with 150 compiled & tested documentation examples
I rewrote Alexandrescu's Loki library from *Modern C++ Design* (2001) in C++20. Header-only, zero dependencies, full test suite.
What's different from the original:
* `typelist<Ts...>` using variadic templates instead of recursive `Typelist<H, T>`
* `abstract_factory` built on `std::tuple` instead of virtual multiple inheritance
* Threading policies using `std::mutex`/`std::shared_mutex`/`std::atomic`
* Visitors via `std::variant` \+ `overloaded` pattern alongside classic acyclic
* Concepts for policy constraints instead of SFINAE
The documentation is the part I'm most proud of: every single component has 10 real-world examples that are extracted from the Markdown by a Python script and compiled against MSVC as part of CI. If the docs lie, CI fails.
This is a teaching/reference library, not a "replace std::" library. If you're studying *Modern C++ Design* or teaching generic programming, this might be useful.
GitHub: [https://github.com/skillman1337/modern-loki](https://github.com/skillman1337/modern-loki) CI: MSVC 2022, GCC 13, Clang 17
https://redd.it/1s5lno0
@r_cpp
C++ feature for DI/DIP/OCP with the widest cross-language analogue
the abstract base class interface(ABCI) via pure virtual functions is perhaps the 1st. (apart from the C style function pointer). it is analogues to type, abstract in fortran, and dyn Trait in rust and ABC / Protocol in python
sometimes due to performance considerations in compiled languages, one needs to switch to the compile time alternatives. in cpp the most common one is template(used with concept) which is close to T: Trait in rust and interface in fortran.
Do you think ABCI and template+concept are the 1st and 2nd best in cpp? what else?
https://redd.it/1s6ikn8
@r_cpp
Feeling Lost Between Low-Level Understanding and High-Level Coding (need advice)
Hi everyone,
I’m relatively new to high-level programming languages like C, C++, JavaScript, etc. Currently, I work as a programmer for PLCs and other controllers. In that space, coding is very low-level—we think in terms of bits, bytes, memory, and execution flow. Because of that, I have a solid understanding of what actually happens inside a controller when code runs (bit shifts, string operations, and so on).
Recently, with the rise of AI, I’ve started doing more high-level “vibe coding.” The challenge I’m facing is that I don’t fully understand what’s happening under the hood anymore.I can read and understand the code at a surface level, but when I try to break it down from an OS or system-level perspective, it feels abstract and heavily packaged.
Even when I try to write code at a surface level, I’m wired to dig into what’s happening underneath—otherwise, I start losing interest.
To address this, I’ve started learning C/C++ more rigorously from the ground up. However, it sometimes feels like the world is rapidly moving forward with new technologies while I’m going back to basics.
I wanted to check if I’m approaching this the right way and what I can do to improve my learning curve.
Would really appreciate any feedback ,advice or your experiences.
thanks
https://redd.it/1s6og1h
@r_cpp
C++20 Coroutines Optimization Opportunities from Compiler’s perspective
https://chuanqixu9.github.io/c++/2026/03/27/C++20-Coroutines-from-compiler-and-library-authors-perspective.en.html
https://redd.it/1s6miyt
@r_cpp
Standard LLMs hallucinate on large C++ codebases. I built an open-source MCP server using tree-sitter to fix that.
I’ve been experimenting heavily with AI agents for legacy modernization, but I kept hitting a massive wall when dealing with C++.
If you just dump a bunch of intertwined C++ files into Claude or an open-source model, it loses context. It tries to refactor a function without knowing what upstream dependencies rely on it, or it gets tangled in circular references and breaks the build. Regex-based parsers also constantly miss the nuances of C++ macros and templates.
So, I built **LegacyGraph-MCP**, an open-source Model Context Protocol (MCP) server that turns "spaghetti code" into a queryable Knowledge Graph for AI Agents.
**How it works under the hood:** Instead of forcing the LLM to read raw text and guess relationships, the agent queries the structure.
1. **AST Parsing:** It uses `tree-sitter-cpp` for 100% accurate parsing (no regex hacks).
2. **Graph RAG:** It loads the codebase into a NetworkX directed graph.
3. **Agent Interaction:** The LLM uses MCP tools to ask specific questions like:
* *“Which functions call* `process_client()`\*?”\*
* *“Are there any circular dependencies here?”*
* *“What are the orphan functions?”*
**Features:**
* **Omni-Ingestion:** It can clone a GitHub repo, apply a patch, scan a local directory, or accept raw file uploads.
* **Hybrid Deployment:** You can run it locally (`stdio`) directly tied to your IDE/Claude Desktop, or deploy it to the cloud (`HTTP`/`SSE`) with ephemeral `/tmp/` clones.
* **Token-Safe Visuals:** It dynamically generates bounded Mermaid.js graphs inline so the LLM can visually map out the dependencies it is working on.
**The Ask:** The core graph logic is working well (I’ve got an end-to-end verifier passing 100% on test data), but I’m looking for feedback from people who work with *really* messy, real-world legacy code.
Specifically:
1. Does the cycle detection logic hold up against your worst circular dependencies?
2. Are there specific query tools (besides `get_callers`, `get_callees`, `detect_cycles`, etc.) that would make your life easier when using an AI coding assistant?
**Repository:** [LegacyGraph-MCP](https://github.com/RohitYadav34980/LegacyGraph-MCP)
*(If you are using Smithery or Claude Desktop, I included the quick-start configs in the README).*
What else can we build with this?
I am open to all ideas! Could we use this for automated test scaffolding for isolated subgraphs? Dead-code pruning pipelines? Vulnerability blast-radius analysis? Drop your ideas in the comments.
Whether you are a backend engineer optimizing graph algorithms, or someone pushing the limits of AI agents, there is a place for you here. Let’s build the ultimate open-source legacy modernization engine together.
Would love to hear your thoughts or see if this breaks on your weirdest legacy code!
https://redd.it/1rzws51
@r_cpp
Xoshiro256++ RNG with AVX2/512
https://github.com/bobjansen/Zorro
https://redd.it/1rzoo5h
@r_cpp
Last C++26 meeting in Croydon is about to begin
Since not everyone is aware and confusion often arises regarding privated GitHub repos, let's inform people on Reddit this time: The last meeting for C++26 is about to begin. Some quick facts:
- The meeting lasts from 2026-03-23 (Mon morning) to 2026-03-28 (Sat afternoon). See also <https://isocpp.org/std/meetings-and-participation/upcoming-meetings>
- Until the meeting ends, <https://github.com/cplusplus/papers/> is private. The repos usually become visible again immediately after the meeting ends.
- The papers published during and after the meeting all go into the April mailing 2026-04-20. This includes the final working draft.
- All remaining NB (national body) comments should be resolved during this meeting. The working draft is then sent off to ISO for review and national bodies vote on the C++26 standard as a whole (yes/no/abstain).
- Any C++26 work takes priority, but once that is completed, time is spent on C++29 papers.
https://redd.it/1rzjovp
@r_cpp
Common Package Specification is Out the Gate
https://www.kitware.com/common-package-specification-is-out-the-gate/
https://redd.it/1rzdr6u
@r_cpp
Measuring stack headroom at runtime in C++
yair.lenga/how-much-stack-space-do-you-have-estimating-remaining-stack-in-c-on-linux-3c9513beabd8" rel="nofollow">https://medium.com/@yair.lenga/how-much-stack-space-do-you-have-estimating-remaining-stack-in-c-on-linux-3c9513beabd8
https://redd.it/1rz7kl7
@r_cpp
Looking at Unity finally made me understand the point of C++ coroutines · Mathieu Ropert
https://mropert.github.io/2026/03/20/unity_cpp_coroutines/
https://redd.it/1rz08da
@r_cpp
Parallel C++ for Scientific Applications: Distributed Parallelism with HPX (1st Part)
https://www.youtube.com/watch?v=DA_a0XDpp20
https://redd.it/1ryx2cp
@r_cpp
C++26: Span improvements and freestanding.
Given the freestanding remarks at https://www.sandordargo.com/blog/2026/03/18/cpp26-span-improvements blog post.
> As freestanding environments generally cannot support exceptions, parts of these facilities cannot be included. Specifically, span::at() (since it throws std::outofrange) and all overloads of std::expected::value() are excluded from the freestanding subset.
It appears that once again, even with C++26 hardening runtime, there were some security improvements that were left out of the table when targeting freestanding environments.
Like possibly having some try_at() that would return std::optional or std::expected result types.
At least looking at the proposed std::span I am not able to find such alternatives.
https://redd.it/1rwznpr
@r_cpp
splice: a C++26 reflection-based hook and signal library
I’ve been experimenting with static reflection in the gcc16 trunk. I’ve built a library that lets you annotate class/struct methods and inject behavior through attributes.
You mark methods as hookable with [[=splice::hook::hookable{}]], then you can inject before/after/return hooks at runtime through a registry. You can cancel calls, override return values, rewrite arguments and control execution order by changing the priority of your hooks, all without touching the original class.
It also has a wire system for signal/slot connections. Slots declare which signal they handle via reflection attributes, and you can connect specific, or all signals on a listener. Listeners can also be paused, resumed, and they automatically disconnect when destroyed via RAII. If you want to wire a listener to for example, an on_click method on a class, you just add an attribute: [[SPLICE_WIRE_SLOT(.signal = ^^MyClass::on_click)]]
This currently requires GCC 16 (built from a snapshot) and the -freflection compiler flag. Still early, but all the tests pass and the API feels simple to use. Eventually, I want to use the same reflection machinery to generate FFI bindings for Lua, and maybe other scripting languages too.
GitHub: https://github.com/FloofyPlasma/splice
Curious if anyone else is experimenting with the reflection coming in C++ 26.
https://redd.it/1rxj838
@r_cpp
Building a computer from scratch and running C++ on it
https://www.youtube.com/watch?v=lBooqws52YA
https://redd.it/1s74k5m
@r_cpp
Bare metal 32 Bit RISC CPU
https://github.com/NaQeEb313/BareMetalRisccpu
Hello Reddit,
I am a 2nd year ECE student, and I have made a 32-bit CPU based on an FSM that works using a multi-cycle approach. I upgraded it from a very basic 8-bit CPU which only had two operations and two registers, just to understand how a CPU works.
Then I improved it by adding a register file, increasing the memory, adding data memory, and also improving the ISA of the CPU.
My goal is to become a low-level (system software) engineer, so my next plan is to build an assembler using C+ + to give instructions to this CPU.
If you find my work interesting, please share your thoughts and suggest more projects that can help me improve my skills in system software.
Also, if you can share any book references, research papers, or articles for building an assembler, that would really help.
Thanks!
https://redd.it/1s6xbrq
@r_cpp
From Introductory to Advanced C++ - Learning Guidelines - Slobodan Dmitrovic - Meeting C++ 2025
https://www.youtube.com/watch?v=n8P11hDYWIs
https://redd.it/1s63dhz
@r_cpp
Report from the Croydon 2026 ISO C++ Committee meeting - mp-units
https://mpusz.github.io/mp-units/HEAD/blog/2026/03/28/report-from-the-croydon-2026-iso-c-committee-meeting/
https://redd.it/1s5y4tm
@r_cpp
Organizing C++ Module Sources
https://abuehl.github.io/2026/03/26/organizing-module-sources.html
https://redd.it/1s6nb7m
@r_cpp
[CppCon] How C++ Finally Beats Rust at JSON Serialization - Daniel Lemire & Francisco Geiman Thiesen
https://www.youtube.com/watch?v=Mcgk3CxHYMs
https://redd.it/1s6jzk2
@r_cpp
How to understand modern C++ features in practice? Let's create a compiler! - Boguslaw Cyganek - Meeting C++ 2025
https://www.youtube.com/watch?v=_uuUw8N0qQ0
https://redd.it/1rzwojc
@r_cpp
Kristian Ivarsson: Casual, an open-source SOA platform
https://youtu.be/2c-I7fzKPWY
https://redd.it/1rzn5p9
@r_cpp
Should assertions be used frequently in software development? And in what general scenarios are they typically applied?
https://redd.it/1rzfy9i
@r_cpp
A matter of style or is it?
Which one do you prefer (the constructor does some work and sets valid_):
class A {
public:
explicit operator bool() const { return valid; }
private:
bool valid_ = false;
}
class A {
public:
bool is_valid() const { return valid; }
private:
bool valid_ = false;
}
A a{};
if (a) {
// is valid
}
A a{}
if (a.is_valid()) {
// is valid
}
C++/sys - A Standard Library Projection to Facilitate the Verification of Run-time Memory Safety
Hi all,
A while ago I was looking for a relevant C++ conference to demonstrate the capabilities of C++/sys. A pure C++ mechanism which offers a new approach to memory safety via debug-time verification.
My talk was accepted into C++Online 2026 which concluded a couple of weeks ago. The discussions were great, I received some really useful feedback (and the little 2D gather town was pretty fun!).
The slides are available here and the release video should appear on YouTube in the following weeks.
Excited to share the tech with the wider community. Much of it is discussed in the slides; some highlights:
Offers improvements over AddressSanitizer in terms of C++ error detection rate
Tracks access lifespan rather than blocks of data
Has contextual knowledge of C++ objects and containers so generally quite performant
100% detection rate for executed paths
Memory pinning and locking mechanism tracks dangling 'this' and references
Zero overhead in release builds
Compatible with any standard C++ compiler (from hosted C++98 running on MS-DOS to freestanding C++${LATEST} on Zephyr)
Doesn't interfere with C code/libraries. Just like Java, Rust, Python thin-bindings, these are treated as unchecked.
Some of the above sounds like magic but the core mechanism allowing for this is quite simple. Temporaries created by operator->, operator* and operator[\] lock memory for the lifetime of access and pointers are entirely prevented from dangling in a coarse-grained manner. Obviously this has an impact on what designs are possible with some discussion in the slides.
Link to the open-source (BSD 3-clause) reference implementation is here.
https://codeberg.org/kpedersen/sys\_public
https://research.thamessoftware.co.uk/sys
Very happy to discuss further. It has some rough areas but I personally love the tech and find it makes writing and testing C++ considerably more satisfying knowing that there is virtually zero chance of a memory error lurking in the tested branches.
https://redd.it/1rz3df4
@r_cpp
Draft idea: constructor member designators
I’ve been experimenting with a small idea to make constructor initializer lists a bit clearer and less error‑prone. The idea actually came from a dilemma I had when trying to settle on naming conventions for member variables. Prefixes like m_ or _name help avoid shadowing, but they also feel like a workaround for something the language could express more directly.
I wrote a short draft exploring “constructor member designators” - a `.member` syntax for constructor initialization.
https://github.com/richardcervinka/cpp-constructor-member-designators
This is just an experiment, but maybe someone will find it interesting.
https://redd.it/1ryyizp
@r_cpp
What open source projects in C++ have the highest code quality?
My understanding of the characteristics of quality code are the conventional ones.
* operations on an object that are allowed in a particular object state do not put the object into an invalid state.
* it's prioritized to organize the implementation of each object into the smallest possible number of sub-objects.
* no cryptically abbreviated names are used, except possible in very small scopes.
With the program(s)/executable(s) themselves, as well as modules with corresponding namespaces, being considered singleton objects.
Fair dinkum if you want to name projects that score well under a different understanding of code quality.
https://redd.it/1rwokuj
@r_cpp
CppCon 2025 More Speed & Simplicity: Practical Data-Oriented Design in C++ -- Vittorio Romeo
https://isocpp.org/blog/2026/03/cppcon-2025-more-speed-simplicity-practical-data-oriented-design-in-cpp-vit
https://redd.it/1rxda1g
@r_cpp
How do you reduce branch mispredictions?
I was looking into it recently and realized how many algorithms work together in order to predict branches, so I was wondering how performance engineers even figure out what will make a certain branch more predictable
https://redd.it/1ryrjsq
@r_cpp