-
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
17:00 UTC* – [https://cpponline.uk/workshop/ai-101/](https://cpponline.uk/workshop/ai-101/)
**C++Online One Day Beginner Workshops** – **Reduced from £345 to £150/$200/€175** (£90/$120/€105 for students)
1. **From Hello World to Real World – A Hands-On C++ Journey from Beginner to Advanced** – Amir Kirsh – 1 day online workshop available on *Thursday 21st May 08:30 – 16:30 UTC –* [https://cpponline.uk/workshop/from-hello-world-to-real-world/](https://cpponline.uk/workshop/from-hello-world-to-real-world/)
**C++Online Half Day Workshops** – £172.50/$230/€200 (£45/$60/€55 for students)
1. **Splice & Dice – A Field Guide to C++26 Static Reflection** – Koen Samyn – Half Day online workshop available on *Monday 25th May 09:00 – 12:30 UTC* – [https://cpponline.uk/workshop/splice-and-dice/](https://cpponline.uk/workshop/splice-and-dice/)
**C++Online Two Day Workshops** – £690/$920/€800 (£180/$240/€210 for students)
1. **AI++ 201 – Build a Matching Engine with Claude Code** – Jody Hagins – 2 day online workshop available on *May 28th – May 29th 09:00 – 17:00 UTC* – [https://cpponline.uk/workshop/ai-201/](https://cpponline.uk/workshop/ai-201/)
Eleven of these workshops had previews at the main C++Online Conference which took place on the 11th – 13th March. You can watch these preview sessions here: [https://www.youtube.com/playlist?list=PLHG0uo5c6V3KIeoLqvBbIqy5AXt\_Me\_cm](https://www.youtube.com/playlist?list=PLHG0uo5c6V3KIeoLqvBbIqy5AXt_Me_cm)
**Anyone who purchased a C++Online Main Conference ticket can also get a discount of however much they paid to attend the main conference.**
Also if anyone is from a lower-income background or live in a country where purchasing power is limited, then it is recommended to reach out to C++Online on [info@cpponline.uk](mailto:info@cpponline.uk) as they will be able to give you a discount.
**ACCU on Sea Two Day Workshops**
1. **C++ Best Practices** – Jason Turner – 2 day in-person workshop available on 15th & 16th June 10:00 – 18:00 – [https://accuonsea.uk/2026/sessions/cpp-best-practices/](https://accuonsea.uk/2026/sessions/cpp-best-practices/)
2. **C++ Templates for Developers** – Walter E Brown – 2 day in-person workshop available on 15th & 16th June 10:00 – 18:00 – [https://accuonsea.uk/2026/sessions/cpp-templates-for-developers/](https://accuonsea.uk/2026/sessions/cpp-templates-for-developers/)
3. **Talking Tech (A Speaker Training Workshop)** – Sherry Sontag & Peter Muldoon – 2 day in-person workshop available on 15th & 16th June 10:00 – 18:00 – [https://accuonsea.uk/2026/sessions/talking-tech-a-speaker-training-workshop/](https://accuonsea.uk/2026/sessions/talking-tech-a-speaker-training-workshop/)
**ACCU on Sea One Day Workshops**
1. **C++ Software Design** – Klaus Iglberger – 1 day in-person workshop available on 15th June 10:00 – 18:00 – [https://accuonsea.uk/2026/sessions/cpp-software-design/](https://accuonsea.uk/2026/sessions/cpp-software-design/)
2. **C++23 in Practice: A Complete Introduction** – Nicolai M. Josuttis – 1 day in-person workshop available on 16th June 10:00 – 18:00 – [https://accuonsea.uk/2026/sessions/cpp23-in-practice-a-complete-introduction/](https://accuonsea.uk/2026/sessions/cpp23-in-practice-a-complete-introduction/)
3. **Secure Coding in C and C++** – Robert C. Seacord – 1 day in-person workshop available on 16th June 10:00 – 18:00 – [https://accuonsea.uk/2026/sessions/secure-coding-in-c-and-cpp/](https://accuonsea.uk/2026/sessions/secure-coding-in-c-and-cpp/)
All ACCU on Sea workshops take place in-person in Folkestone, England.
**OTHER NEWS**
* **C++ Under The Sea 2026 Announced** – C++ Under The Sea will once again take place on 15 & 16th October 2026 at Breepark in Breda, the Netherlands
* **C++ Under The Sea 2026 Workshops Announced** – C++ Under The Sea have announced 3 workshops that will take place on the 14th October 2026. Find out more at [https://cppunderthesea.nl/#workshops](https://cppunderthesea.nl/#workshops)
* **ADC Japan Schedule Announced** – ADC have announced their full schedule for their Japan event which will feature
CMake distributed + cached builds of LLVM Clang in 30 seconds
https://www.loom.com/share/4a72f93282024fac9934a6af455f8dde
https://redd.it/1t3z06c
@r_cpp
2026 Annual C++ Developer Survey "Lite" Results [PDF]
https://isocpp.org/files/papers/CppDevSurvey-2026-summary.pdf
https://redd.it/1t3vcll
@r_cpp
I built a real-time terminal audio visualizer in C++17
Built a real-time audio visualizer for your terminal in using WASAPI & FFTW3.
Just shipped v1.1.0 with static linking for users, and compiler agnosticism for potential contributors. (MinGW, MSVC, Clang).
The executable runs on any windows machine with no dependencies.
https://github.com/majockbim/spectrum (there is a GIF in the README)
https://redd.it/1t3n64t
@r_cpp
Compile Your First C++26 Program with GCC 16.1
https://techfortalk.co.uk/2026/05/04/compile-your-first-c26-program-with-gcc-16-1/
https://redd.it/1t3ihpm
@r_cpp
What are you missing most from the C++ standard library?
I like C++ but I realized that I keep implementing functionality that should be part of the standard library. Here are the features I'm missing most:
- an easy way to spawn a subprocess while controlling the standard input/output. something like popen but integrated with the standard I/O streams.
- UTF-8 and Unicode: convert between UTF-8, UTF-16, and UTF-32. convert a string to lower case and to upper case.
- networking: an easy way to implement a HTTP client or server
- cross-platform memory-mapped files
- thread-safe (and possibly lock-free) queues.
- persistent data structures
- JSON serialization/deserialization
What are you missing most from the C++ standard library?
https://redd.it/1t3ghr1
@r_cpp
The Most Confusing C++ Behavior
https://codestyleandtaste.com/most-confusing-C++-behavior.html
https://redd.it/1t2xmw4
@r_cpp
GoodLog: a small C++17 wrapper around Boost.Log for colored output, rotation and hex dumps
Hi r/cpp,
I built GoodLog, a small C++17 wrapper around Boost.Log.
The goal is not to replace general-purpose logging libraries like spdlog. I wanted a reusable layer for C++ projects that already depend on Boost, so the common Boost.Log setup does not have to be repeated across modules.
It currently supports:
\- colored console output
\- automatic file:line source location
\- rotating log files
\- separate severity filters for console and file sinks
\- optional channel filtering
\- hex dump helpers for binary buffers
\- CMake demo and GoogleTest entry points
GitHub:
https://github.com/SoleyRan/Log
The project is still early, and I would especially appreciate feedback on the macro API, CMake integration, and whether the channel logging interface should be simplified.
https://redd.it/1t2pmyu
@r_cpp
I built a C++ integer-to-string library based on a new AVX-512 paper
I built a small C++ integer-to-string conversion library based on a new paper by Jael Champagne Gareau and Daniel Lemire, "Converting an Integer to a Decimal String in Under Two Nanoseconds":
- Project: https://github.com/simditoa/simditoa
- Paper: https://arxiv.org/abs/2604.26019
The paper looks at decimal formatting for integers, which shows up in logging, JSON/CSV/XML serialization, database output, and other places where numbers eventually become text. The interesting part, and the part I wanted to experiment with, is that it uses AVX-512 IFMA instructions to extract multiple decimal digits in parallel, avoiding the usual repeated division/modulo loop and avoiding large lookup tables.
The library exposes a small to_chars-style API:
#include "simditoa.h"
char buf[simditoa::MAX_DIGITS + 1];
size_t len = simditoa::to_chars(12345, buf);
buf[len] = '\0';
int64_t and uint64_t supportstd::to_charssimditoa::to_chars at about 15.82 ns/int versus 36.35 ns/int for std::to_chars on the tested setup, roughly 2.3x faster in that run. The paper reports stronger results for its full algorithm and benchmark suite, including single-core performance ahead of other tested methods, but my repo should be treated as a compact implementation based on the paper rather than a full reproduction of every variant in it.floor(2^52 / 10^k) to compute digit positions in parallel, then gathers the digit bytes with AVX-512 byte permutation. Larger values are split into chunks.
When to actually use a set
https://dubeykartikay.com/posts/why-never-use-std-unordered-set/
https://redd.it/1t2im2j
@r_cpp
I made C++ coding problems where you build things like a mini Redis or a tiny interpreter — looking for feedback
I’ve been building a small platform with coding problems that are more “systems-style” rather than typical algorithm exercises.
The idea is to practice by building simplified versions of real components, but still in a problem format (input/output + tests).
Some examples:
* implement a Redis-like server (TCP + protocol parsing)
* build a tiny interpreter
* create a virtual filesystem
* write an expression evaluator
The problems are:
* runnable directly in the browser (no setup)
* open-ended (you decide design/architecture)
* supporting multi-file submissions
I’m trying to keep them doable in a few hours, not huge multi-day projects.
I’m curious what people here think:
* does this kind of problem feel useful for improving practical C++ skills?
* or would you prefer something more guided / closer to full projects?
Still early, so any feedback would be really helpful.
Link: [https://elitecode.pro/](https://elitecode.pro/)
https://redd.it/1t2941b
@r_cpp
Post examples of using reflections in your projects
What the title says. I just want to see what interesting things people are using reflection for now that its in gcc. Thanks.
https://redd.it/1t25byx
@r_cpp
CppCon 2025: Can Standard C++ Replace CUDA for GPU Acceleration? - Elmar Westphal
https://www.youtube.com/watch?v=EOvukoCyW7A
https://redd.it/1t1kopc
@r_cpp
Read-Copy Update (RCU) API in C++26
https://people.kernel.org/paulmck/stupid-rcu-tricks-rcu-api-in-cpp26
https://redd.it/1t1gqwp
@r_cpp
Variadic Visitation
https://breese.github.io/2026/05/01/variadic-visitation.html
https://redd.it/1t1gfcd
@r_cpp
Latest News From Upcoming C++ Conferences (2026-05-05)
This is the latest news from upcoming C++ Conferences. You can review all of the news at [https://programmingarchive.com/upcoming-conference-news/](https://programmingarchive.com/upcoming-conference-news/)
**TICKETS AVAILABLE TO PURCHASE**
The following conferences currently have tickets available to purchase
* **ADC Japan (1st – 3rd June)** – You can buy tickets at [https://peatix.com/event/4840445](https://peatix.com/event/4840445)
* **ACCU on Sea (15th – 20th June)** – You can buy standard tickets at [https://accuonsea.uk/tickets/](https://accuonsea.uk/tickets/) with discounts available for ACCU members.
* **CppCon (12th – 18th September)** – You can buy early bird tickets until June 26th at [https://cppcon.org/registration/](https://cppcon.org/registration/)
* **C++ Under The Sea** **(NEW – 14th – 16th October)** – You can buy early bird tickets at [https://sales.ticketing.cm.com/cppunderthesea2026/](https://sales.ticketing.cm.com/cppunderthesea2026/)
* **Meeting C++ (26th – 28th November)** – You can buy early bird tickets at [https://meetingcpp.com/2026/](https://meetingcpp.com/2026/)
**OPEN CALL FOR SPEAKERS**
* **CppCon (Last Chance)** – Interested speakers have until May 17th to submit their talks for CppCon which is scheduled to take place on 12th – 18th September in Denver Colorado. Find out more including how to submit your proposal at [https://cppcon.org/cfs2026/](https://cppcon.org/cfs2026/)
* **Meeting C++** **(NEW)** \- Interested speakers have until June 4th to submit their talks for Meeting C++ which is scheduled to take place on 26th - 28th November. Find out more including how to submit your proposal at [https://meetingcpp.com/meetingcpp/news/items/Submit-your-talks-to-Meeting-Cpp-2026-.html](https://meetingcpp.com/meetingcpp/news/items/Submit-your-talks-to-Meeting-Cpp-2026-.html)
**OTHER OPEN CALLS**
* **CppCon Call For Authors Now Open!** – CppCon are looking for book authors who want to engage with potential reviewers and readers. Read the full announcement at [https://cppcon.org/call-for-author-2026/](https://cppcon.org/call-for-author-2026/)
**TRAINING COURSES AVAILABLE FOR PURCHASE**
Conferences are offering the following training courses:
**Last Chance To Register:**
1. **Stop Thinking Like a Junior** **– The Soft Skills That Make You Senior** – Sandor Dargo – Half Day online workshop available on *Friday 8th May 20:00 – 23:30 UTC* – [https://cpponline.uk/workshop/stop-thinking-like-a-junior/](https://cpponline.uk/workshop/stop-thinking-like-a-junior/)
2. **Jumpstart to C++ in Audio – Learn Audio Programming & Create Your Own Music Plugin/App with the JUCE C++ Framework** – Jan Wilczek – 1 day online workshop available on both Monday 11th & Tuesday 12th May 13:00 – 16:30 UTC – [https://cpponline.uk/workshop/jumpstart-to-cpp-in-audio/](https://cpponline.uk/workshop/jumpstart-to-cpp-in-audio/) – £150/$200/€175 (£90/$120/€105 for students)
3. **Safe and Efficient C++ for Embedded Environments** – Andreas Fertig – 1 day online workshop available on *Tuesday 12th May 09:00 – 17:00 UTC* – [https://cpponline.uk/workshop/safe-and-efficient-cpp-for-embedded-environments/](https://cpponline.uk/workshop/safe-and-efficient-cpp-for-embedded-environments/)
4. **Mastering std::execution (Senders/Receivers)** – Mateusz Pusz – 1 day online workshop available on *Friday 15th May 09:00 – 17:00 UTC* – [https://cpponline.uk/workshop/mastering-stdexecution-senders-receivers/](https://cpponline.uk/workshop/mastering-stdexecution-senders-receivers/)
**C++Online One Day Workshops** – £345/$460/€400 (£90/$120/€105 for students)
1. **How C++ Actually Works – Hands-On With Compilation, Memory, and Runtime** – Assaf Tzur-El – One day online workshop that runs over two days on *May 18th – May 19th 16:00 – 20:00 UTC* – [https://cpponline.uk/workshop/how-cpp-actually-works/](https://cpponline.uk/workshop/how-cpp-actually-works/)
2. **AI++ 101 – Build an AI Coding Assistant in C++** – Jody Hagins – 1 day online workshop available on *Friday 22nd May 09:00 –
CMake cold build of LLVM Clang in 30 seconds
https://www.loom.com/share/4a72f93282024fac9934a6af455f8dde
https://redd.it/1t3xz9x
@r_cpp
Guys I developed a minimal parser combinator library and wrote a blog post
Links:
Github
Blog
https://redd.it/1t3rrgm
@r_cpp
New C++ Conference Videos Released This Month - May 2026
**CppCon**
2026-04-27 - 2026-05-03
* Lightning Talk: A Pragmatic Approach to C++: Designing, Organizing and Writing Maintainable Code - Oleg Rabaev - [https://youtu.be/re4Oy1IVj-s](https://youtu.be/re4Oy1IVj-s)
* Lightning Talk: Causal Inference for Code Writing AI - Matt K Robinson - [https://youtu.be/craQCfj73CI](https://youtu.be/craQCfj73CI)
* Lightning Talk: Cut the boilerplate with C++23 deducing\_this - Sarthak Sehgal - [https://youtu.be/o3vjUo2qXNg](https://youtu.be/o3vjUo2qXNg)
* Lightning Talk: The Lifecycle of This CMake Lightning Talk - Yannic Staudt - [https://youtu.be/3DqRIxXVfiI](https://youtu.be/3DqRIxXVfiI)
* Lightning Talk: Catching Performance Issues at Compile Time - Keith Stockdale - [https://youtu.be/YK8Kwj9okRk](https://youtu.be/YK8Kwj9okRk)
**C++Online**
2026-04-27 - 2026-05-03
* From 5000ns to 200ns - 5 Modern C++ Techniques Live Demo - Larry Ge - [https://youtu.be/9HqyiTWLENY](https://youtu.be/9HqyiTWLENY)
**Audio Developer Conference**
2026-04-27 - 2026-05-03
* From Paper to Plugin - A Guided Tour of Digital Filters - Ross Chisholm, Joel Ross & James Hallowell - ADC 2025 - [https://youtu.be/QlyWAfRUF30](https://youtu.be/QlyWAfRUF30)
* From Idea to Online Sale - The Full Journey of Building an Audio Plugin - Joaquin Saavedra - ADCx Gather 2025 - [https://youtu.be/mJoAArwAmkc](https://youtu.be/mJoAArwAmkc)
* Finding OSCar: Electronic and Software Secrets of a Classic Vintage Synth - Ben Supper - ADC 2025 - [https://youtu.be/NbIZEur3h7Q](https://youtu.be/NbIZEur3h7Q)
https://redd.it/1t3l7hu
@r_cpp
Quantity-safe analog literals
https://morwenn.github.io/c++/2026/05/02/TSB011-quantity-safe-analog-literals.html
https://redd.it/1t3gppy
@r_cpp
High-throughput log parsing (~500K lines/sec) in C++ without regex — looking for performance ideas
I’m building a log ingestion + parsing pipeline in C++ and trying to push throughput as far as possible.
Current setup:
\- \~500K lines/sec
\- custom tokenizer (no regex)
\- string_view everywhere to avoid copies
\- batch processing
\- append-only write path
Next step:
I want to optimize the query side using:
\- SIMD for substring search
\- possibly precomputed token patterns
Questions:
\- Best SIMD strategies for substring / token matching?
\- Any experience with AVX2/AVX512 for log-like workloads?
\- At what point does memory bandwidth become the bottleneck?
Also curious if anyone has benchmarked SIMD vs naive scan for log-style data.
Any pointers or war stories appreciated.
https://redd.it/1t37nr3
@r_cpp
The C++ Business Model, a new challenge for WG21
https://a4z.noexcept.dev/blog/2026/05/03/The-Cpp-Business-Model.html
https://redd.it/1t2tajl
@r_cpp
Auxid: An Orthodox C++20 Base Library for Data-Oriented Design
NOTE: All and any colorations/PRs are welcome, **EXCEPT FOR AI GENERATED GARBAGE**.
Hey folks,
Let me introduce Auxid: a C++20 platform/library aimed at high-performance applications (specifically game engines and systems software) built around **Orthodox C++** and **Data-Oriented Design (DOD)**.
I know the C++ ecosystem isn't short on utility libraries, but I built Auxid to bridge a specific gap: getting the predictable memory layouts and fast compile times of C-style systems programming, without losing the ergonomics of standard C++20 algorithms.
Mainstream C++ often relies on heavily templated, node-based STL containers that can thrash CPU caches or introduce hidden heap allocations. Auxid strips that back. Where the STL is already the right tool for the job (like `std::filesystem`), Auxid exposes it through thin, zero-overhead wrappers. For the rest, it provides DOD-friendly replacements.
Here’s a quick architectural overview of what’s inside:
* **Cache-Friendly Containers:** Includes a sparse-dense hash map, strictly aligned vector types, and small-string-optimized (SSO) strings.
* **Plays Nice with** `<algorithm>`: Auxid’s containers use iterators that satisfy C++20 iterator concepts (like contiguous iterators), meaning you can seamlessly pass them into `std::sort`, standard ranges, and other utilities.
* **Total Allocator Control:** No surprise allocations in the hot path. Auxid integrates [rpmalloc](https://github.com/mjansson/rpmalloc) out of the box for extremely fast, thread-caching heap allocation, alongside custom arena allocators.
* **Lightweight Error Handling:** Instead of exceptions, it relies on a union-based `Result<T, E>` and `Option<T>` that compile to tight representations, paired with Rust-style `AU_TRY` macros.
* **Explicit Control Flow:** Auxid provides an opt-in CMake target (`auxid_platform_standard`) that strictly disables C++ exceptions (`-fno-exceptions` / `/EHs-c-`) to enforce predictable performance characteristics.
It's designed to be dropped directly into existing CMake projects via `FetchContent`:
FetchContent_Declare(
auxid
GIT_REPOSITORY https://github.com/I-A-S/Auxid.git
GIT_TAG main
)
FetchContent_MakeAvailable(auxid)
If you are interested in DOD, alternative standard libraries, or just want to critique the architecture, I’d really value this community's feedback.
* **Core Library:** [I-A-S/Auxid](https://github.com/I-A-S/Auxid)
* **Project Scaffold:** [I-A-S/Auxid-Project-Template](https://github.com/I-A-S/Auxid-Project-Template)
Licensed under Apache 2.0.
Eager to hear what you think not just about the project, but the principles of Orthodox C++ as a whole!
https://redd.it/1t2nyai
@r_cpp
Migrating a small C++ code base to C++26 (modules, import std and contracts)
https://jonastoth.github.io/posts/migrate_cxx26/
https://redd.it/1t2kkoh
@r_cpp
Modern C++ Programming
https://federico-busato.github.io/Modern-CPP-Programming/
https://redd.it/1t2a4jz
@r_cpp
oo-alloc: i made a comprehensive learning resource for allocators in C++
hi!
i made a memory allocation library/learning resource. i wanted to learn more about them and i couldn't find one comprehensive source of knowledge, so i decided that i'll make one of my own:\].
it currently has these basic allocator types: arena (linear), stack, pool, free list, free tree, tracking, buddy, slab.
i gave my best to describe everything clearly in the readme, also added svg diagrams (written in Typst, btw). i plan to implement a bucket/size-segregated free list allocator as well.
hoping anyone will find this resource useful!
https://github.com/nihiL7331/oo-alloc
https://redd.it/1t287xq
@r_cpp
Does anyone maintain an impl of the Chandler Carruth map API?
Lightning Talk (C++Now 2019, 8min): https://youtube.com/watch?v=kye4aD-KvTU
In 2019, Chandler presented the above talk describing a C++ map API. It's not compatible with the standard map types, but for greenfield projects I think it's an excellent choice.
I've considered implementing it myself, but hash tables are very subtle and finicky. I'd rather rely on a robust implementation.
Abseil has some excellent hash tables, but to my knowledge they do not support the small size/small buffer optimization. Chandler's hypothetical API does. Would be great to have the SIMD probing algorithm from Abseil implemented for an SSO map type.
https://redd.it/1t21nhu
@r_cpp
Mathieu Ropert: The Performance Mindset
https://youtu.be/o-C6puc7nOk
https://redd.it/1t1k7k2
@r_cpp
Showcase/Request for Feedback Achieving 0.31ns Pathfinding on M1 for Search & Rescue Drones – Seeking advice on further optimization.]
Hi everyone,
I’m a student and student pilot from Vietnam, currently obsessed with combining Physics and C++ to solve real-world problems. My current project, H.A.L.O. Aegis, is a 600-700KB core designed for search-and-rescue drones operating in catastrophic environments (like collapsed buildings).
My goal was to create a "zero-latency" escape route identifier that can fit into the tiny L2 cache of embedded systems.
Current Specs:
Performance: \~0.326 ns per op on Apple M1 (measured via Google Benchmark).
Throughput: 3.0679G/s.
Memory Safety: Verified with AddressSanitizer (ASan).
The "Elephant in the room": Since I wanted to move fast on the rescue logic, I used AI to help generate some of the boilerplate and the bilingual interface (about 30-40% of the code). I manually hand-tuned the core physics-based logic to hit the sub-nanosecond mark.
Why I'm here: I’m planning to share this with NGOs like the Red Cross, but before I do, I want to make sure the code is truly "bulletproof."
Is my benchmarking methodology sound?
Are there any C++20 features I missed that could make this even more efficient for ARM64?
Please be kind—I'm still learning and I'm aware some of my internal comments might be messy (working on English-izing them!).
I'm ready for the "code review of a lifetime." If there’s anything not quite right, please let me know so I can fix it before it actually goes into a drone to save lives.
Project Link: https://github.com/Nguyenidkskibidi/halo-aegis-core
Thank you for your time and expertise!
https://redd.it/1t1h0do
@r_cpp
The STL for Geometry: Thirty-Year Evolution of C++ Libraries
https://polydera.com/algorithms/the-stl-for-geometry
https://redd.it/1t19d0y
@r_cpp