-
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
Reviewers wanted: Corosio & Capy (coroutine-native I/O + coroutine foundation for C++20) are entering Boost formal review
The Boost formal review of **Corosio** and **Capy** begins today (June 23) and runs through July 7. The esteemed Jeff Garland is the review manager (Jeff also managed the Boost.Asio review back in the day!).
**What these libraries are:**
* **Capy** is a coroutine foundation library providing task types, execution contexts, executors, async synchronization primitives, buffer abstractions, and coroutine composition facilities.
* **Corosio** is a coroutine-native async I/O library built on top of Capy. Networking and I/O operations are designed specifically for C++20 coroutines, including awaitable operations, executor affinity, cancellation support, and cross-platform backends (IOCP, epoll, kqueue).
Together they're a coroutine-native alternative to the callback first model. Async code reads like sync without giving up control over execution, cancellation, or performance.
**Why this review matters:** Boost currently doesn't have a coroutine-native I/O library. If these are accepted, they'd be the first.
If you have opinions about how async I/O should work in C++, now's your chance to put them on the record. Both experienced Boost contributors and first time reviewers are encouraged to participate.
**Links:**
* Corosio:[ GitHub](https://github.com/cppalliance/corosio) ·[ Docs](https://develop.corosio.cpp.al/corosio/index.html)
* Capy:[ GitHub](https://github.com/cppalliance/capy) ·[ Docs](https://develop.capy.cpp.al/capy/index.html)
* Submitting your review: [https://go.boost.org/4vrwPbP](https://go.boost.org/4vrwPbP)
https://redd.it/1udgx1y
@r_cpp
C++/WinRT being in maintenance mode means there is no way to develop a modern Windows app (WinUI) in C++?
https://redd.it/1udbgr9
@r_cpp
C++ Lifetime-End Pointer-Zap and OOTA Progress
https://people.kernel.org/paulmck/c-pointer-zap-and-oota-progress
https://redd.it/1ud7zg5
@r_cpp
I did a programme and uploaded in You Tube related to Cramer's rule for finding intersection points for 2D equations and plot it in C++ via GNU Plot.
https://youtu.be/F2BxeemH0IE?si=vAKX8i8uSR6L_xPz
https://redd.it/1uctm9c
@r_cpp
New C++ Conference Videos Released This Month - June 2026 (Updated to Include Videos Released 2026-06-15 - 2026-06-21)
**C++Online**
2026-06-15 - 2026-06-21
* The Art of API Design - Christoph Stiller - [https://youtu.be/d5djrT4qfHc](https://youtu.be/d5djrT4qfHc)
* Top-Performance Genetic Programming - Can Only C++ Get You There? - Eduardo Madrid - [https://youtu.be/oBQDe56Yi3Q](https://youtu.be/oBQDe56Yi3Q)
2026-06-08 - 2026-06-14
* Monads Meet Mutexes - Arne Berger - [https://youtu.be/AisGDOoF82U](https://youtu.be/AisGDOoF82U)
* Lock-free Queues in the Multiverse of Madness - Dave Rowland - [https://youtu.be/eHmjkFdQl00](https://youtu.be/eHmjkFdQl00)
2026-06-01 - 2026-06-07
* Writing C++ Code is Challenging, Writing Performant C++ Code is Daunting - Dmitrii Radivonchik - [https://youtu.be/R2sm9mailuU](https://youtu.be/R2sm9mailuU)
* Case Study - Purging Undefined Behavior and Intel Assumptions in a Legacy Codebase - Roth Michaels - [https://youtu.be/H-dHTeSR\_n8](https://youtu.be/H-dHTeSR_n8)
**ADC**
2026-06-15 - 2026-06-21
* Scripting Architecture for a DAW-like Plugin - How we Implemented Lua and JavaScript Scripting for Synthesizer V Studio - Kanru Hua - [https://youtu.be/CKOvmBRdHAA](https://youtu.be/CKOvmBRdHAA)
* Patterns of Practice: Live Coding and the Logic of South Asian Traditional Music - Abhinay Khoparzi - [https://youtu.be/n0-XpUhZ7Dc](https://youtu.be/n0-XpUhZ7Dc)
* ADC 2015 to 2035 - Looking Back at 10 Years of Audio Dev, and Peering Forward at the Next 10 - Julian Storer - [https://youtu.be/WvVur2\_aGHU](https://youtu.be/WvVur2_aGHU)
* From DAW to Game Engine - Unfiltered Creativity - Nikhil Dahake - [https://youtu.be/5PtMWJLFjyo](https://youtu.be/5PtMWJLFjyo)
2026-06-08 - 2026-06-14
* Low Latency Android Audio with improved CPU Performance - Phil Burk - [https://youtu.be/DtBrKEu0R0g](https://youtu.be/DtBrKEu0R0g)
* Linux as the Conductor - Driving Pre-Compiled Audio DSP Kernels on C7x for Real-Time Processing - Vishnu Pratap Singh - [https://youtu.be/Auq9WnHNtPo](https://youtu.be/Auq9WnHNtPo)
* Overview of Granular Synthesis - Avrosh Kumar - [https://youtu.be/QpBV24nWg2M](https://youtu.be/QpBV24nWg2M)
* The Agentic Symphony - Multi-Agent Collaboration for Emergent Musical Composition - Meera Sundar - [https://youtu.be/QMUXoImgTIA](https://youtu.be/QMUXoImgTIA)
2026-06-01 - 2026-06-07
* Beyond the DAW - Designing a Procedural Sequencer Powered by Music-Theory - Romy Dugue & Cecill Etheredge - [https://youtu.be/48sH4wQUDAs](https://youtu.be/48sH4wQUDAs)
* From DAW Users to Audio Developers - Teaching JUCE to Creative Minds - Milap Rane - [https://youtu.be/200UrugEanY](https://youtu.be/200UrugEanY)
* Music Design and Systems - Achieving Inaudibly Complex Systems in Video Games - Liam Peacock - [https://youtu.be/R6raBvCNsQo](https://youtu.be/R6raBvCNsQo)
* Developing for Avid’s Audio Ecosystem - Rob Majors - [https://youtu.be/91-7YWVKRE4](https://youtu.be/91-7YWVKRE4)
**CppCon**
2026-06-01 - 2026-06-07
* Lightning Talk: Navigating Code Reviews as a Code Author - Ben Deane - [https://youtu.be/zygtgvHp\_MM](https://youtu.be/zygtgvHp_MM)
* Lightning Talk: Eight Consteval Queens and Compile-Time Printing - Sagnik Bhattacharya - [https://youtu.be/gNPhJrXLiIs](https://youtu.be/gNPhJrXLiIs)
* Instrumenting the Stack: Strategies for End-to-end Sanitizer Adoption - Damien Buhl - [https://youtu.be/TSrymTXw5w8](https://youtu.be/TSrymTXw5w8)
https://redd.it/1ucmu7i
@r_cpp
Boost Review for Capy and Corosio Begins Today
The Boost Formal Review of the Corosio and Capy libraries will begin on June 23, 2026 and will conclude on July 7, 2026.
The review manager for these reviews will be Jeff Garland and the libraries are brought to you by Vinnie Falco. Since this is a two library review the period is somewhat extended from normal.
# Capy
Capy is a coroutine foundation library providing task types, execution contexts, executors, asynchronous synchronization primitives, buffer abstractions, and coroutine composition facilities. It serves as the execution and asynchronous programming substrate upon which Corosio is built.
Repository:
Capy[ GitHub Repository](https://github.com/cppalliance/capy)
docs
# Corosio
Corosio is a coroutine-native asynchronous I/O library for C++20. It provides networking and I/O facilities designed specifically for coroutines, with awaitable operations, executor affinity, cancellation support, and cross-platform implementations based on IOCP, epoll, and kqueue.
Repository:
[Corosio GitHub Repository](https://github.com/cppalliance/corosio)
docs
# Review Questions
Potential reviewers are encouraged to consider the following questions:
1. What is your evaluation of the usefulness of the libraries?
2. What is your evaluation of the design?
3. What is your evaluation of the implementation?
4. What is your evaluation of the documentation?
5. Have you used either or both libraries? What was your experience?
6. Are the libraries ready for inclusion in Boost?
7. If not, what changes would you recommend before acceptance?
8. Do the libraries fit well within the existing Boost ecosystem?
9. Are there API, naming, usability, extensibility, or implementation concerns that should be addressed?
# How to Participate
Please post your review to the Boost Developers mailing list. Reviews from both experienced Boost contributors and first-time reviewers are encouraged. Reports based on real-world usage, experimentation, code inspection, and documentation review are all valuable contributions.
At the conclusion of the review period, the review manager will consider all feedback and determine whether the libraries should be accepted into Boost.
We look forward to your participation in this review.
If you have any questions or need assistance please let me know.
Matt - Boost Review Wizard
https://redd.it/1uck5ne
@r_cpp
Libc
So just to confirm my understanding: when I write C code with printf, the linker links my program against printf inside libc, because that function contains the implementation. The compiler itself doesn’t know the implementation details of printf, so it relies on the linker to resolve it and connect it to the actual function in libc. Then, when we look at the implementation, we find that it does formatting, buffering, and then it calls write internally. And write itself contains some assembly that invokes a system call to reach the kernel right?
https://redd.it/1uc7grf
@r_cpp
Dispatch Table with C++26 Reflection - Zero Boilerplate & Zero Runtime Overhead
https://noqtabeda.github.io/2026/06/20/cpp26-dispatch-table\_en/
https://redd.it/1ubt3qm
@r_cpp
A tiny C++23 filesystem wrapper that returns std::expected instead of throwing
Hi everyone,
I’ve been working on a small C++23 header-only library called **expected_fs**:
https://github.com/MrZLeo/expected-fs
It’s a thin wrapper around `std::filesystem` where fallible operations return `std::expected<T, std::error_code>` instead of throwing `std::filesystem_error`.
The idea is not to replace `std::filesystem`, but to make filesystem code easier to compose in projects that prefer explicit error handling.
Example:
```cpp
#include <expected_fs/expected_fs.hpp>
#include <iostream>
int main() {
const auto size = expected_fs::file_size("data.txt");
if (!size) {
std::cerr << size.error().message() << '\n';
return 1;
}
std::cout << *size << '\n';
}
```
Most function names mirror `std::filesystem`, so usage should feel familiar:
```cpp
auto created = expected_fs::create_directories("out/cache");
auto copied = expected_fs::copy_file("input.txt", "out/input.txt");
auto removed = expected_fs::remove("out/input.txt");
```
It's simple and it just work. I’d love feedback on the API shape, naming, CMake packaging, and whether this feels useful to people who avoid exception-based filesystem handling.
Thanks for taking a look! :)
https://redd.it/1ubq20l
@r_cpp
Pymetabind: Writing pybind11 bindings with C++26 reflections
https://codeberg.org/bstaletic/pymetabind/
https://redd.it/1ubiwsu
@r_cpp
The problem with targeting Linux
Linux unlike MacOS and Windows doesn't have a standardised SDK. This forces devs to either natively compile there or create SDK/sysroot ourselves.
​
This creates some issues, firstly everyone targets different sets of packages for shared linking, this causes glibc version mismatches and similar issues.
​
In the end, why are we dealing with this, why can't Debian and Ubuntu Devs just collaborate to release a tarball for arm64 and x64 desktop. We could just download it and set the flags and everything works.
​
But currently we have to create a sysroot via docker, weird system packages with Debian etc. None of them are really ideal.
​
The rest of the Devs who target mini-pc's or try to run Linux on milkv-duos can build their own sysroot from scratch, while we can just move to actual work.
​
https://redd.it/1ub4s64
@r_cpp
I built a custom DX11 engine that lets you layer 70+ real-time shaders over your entire Windows desktop (Zero input lag, no game hooking)
Hey everyone,
I’ve been developing a real-time post-processing engine called Shade Elements, and it is finally live. It essentially transforms your entire Windows operating system, applications, and games into a living canvas.
The main goal was to build something insanely powerful but completely non-invasive. Instead of injecting into game files (which triggers aggressive anti-cheat software), Shade Elements uses a custom C++ DirectX 11 engine to operate entirely as a screen-space overlay. It hooks the display compositor directly, meaning you get zero input lag and zero ban risks.
Here is what the engine can do:
70+ Stackable Shaders: You aren't limited to one effect. You can stack a CRT curvature filter over a VHS tape glitch, add realistic Phosphor Burn-in, or drop an ASCII visualizer over your favorite game.
Window-Aware Technology: The engine actively reads your Z-order. You can use the Bokeh Depth of Field shader to automatically track your active foreground window, keeping it razor-sharp while blurring out your messy desktop behind it.
Temporal Memory: The pipeline utilizes history buffers, allowing for buttery-smooth Motion Blur or the ability to "Save State" a snapshot of your screen mid-render and composite it back into the pipeline later.
Live Customization: Every shader has real-time sliders (Intensity, Radius, Speed, etc.) that parse dynamically. Plus, global hotkeys let you kill the overlay instantly without tabbing out.
I would love for you to try it out and tear it apart. I’ve set it up so the first 100 downloads are completely free!
You can check it out and grab a copy here:https://compaces.itch.io/shade-elements
Let me know what you think of the tech, or if you have any requests for new shaders to add to the vault!
https://redd.it/1ua583u
@r_cpp
CMake and c++ libraries
Hi everyone,
At work, I stumbled upon something that seems completely absurd to me, but perhaps someone here will have a different perspective.
We have a software architect who defines the data model using .idl files (a kind of simplified struct, if you're not familiar with it). These .idl files generate C++ code.
Historically, it was C++ 98 code. And now it also includes "modern" C++ code, meaning that arrays are no longer T[\] but rather vector<T>, for example. Originally, these IDL files are used within our kind-of micro services. They update the data model within the distributed monolith, and we develop related features.
Under the pretext that these are the same source IDL files, our software architect imposes and provides us with the same CMake target name for both. This means we have to generate one install folder in 98 and another in "modern" C++.
And for the software where we'd like to start mixing the two within the same CMake project, we're stuck because we're limited to a single CMake target for two final .so files.
Do any of you see the point of his approach?
Would you recommend having a unique target name for each .so/.a ?
https://redd.it/1ua0xc4
@r_cpp
I want to make a mine sweeper in cpp but i dont know which gui to use
I thought about making a wpf gui and connect it to a cpp engine but i dont think that with wpf i can make a fun GUI, i really want it to look like a game and not a form
Do any of you have reccomendation for me?
https://redd.it/1u9zh1p
@r_cpp
Built over a decade a turing-complete Quantum Computing zachlike
Hi
Excited to be able to announce that QO is almost ready to leave Early Access! I published a large patch that covers more than a year of work (lots of analytics, I've been tracking where ppl were getting stuck).
If you are interested in a highly intuitive visual method that faithfully describes all universal quantum computing and physics behind, (including how time behaves) this is for you. I am the Dev behind Quantum Odyssey (AMA! I love taking qs) - worked on it for about 10 years (3.5 in phd), the goal was to make a super immersive space for anyone to learn quantum computing through zachlike (open-ended) logic puzzles and compete on leaderboards and lots of community made content on finding the most optimal quantum algorithms. The game has a unique set of visuals (that was actually my PhD research) capable to represent any sort of quantum dynamics for any number of qubits and this is pretty much what makes it now possible for anybody 15yo+ to actually learn quantum logic without having to worry at all about the mathematics behind.
This is a game super different than what you'd normally expect in a programming/ logic puzzle game, so try it with an open mind.
# Stuff covered
Boolean Logic – bits, operators (NAND, OR, XOR, AND…), and classical arithmetic (adders). Learn how these can combine to build anything classical. You will learn to port these to a quantum computer.
Quantum Logic – qubits, the math behind them (linear algebra, SU(2), complex numbers), all Turing-complete gates (beyond Clifford set), and make tensors to evolve systems. Freely combine or create your own gates to build anything you can imagine using polar or complex numbers.
Quantum Phenomena – storing and retrieving information in the X, Y, Z bases; superposition (pure and mixed states), interference, entanglement, the no-cloning rule, reversibility, and how the measurement basis changes what you see.
Core Quantum Tricks – phase kickback, amplitude amplification, storing information in phase and retrieving it through interference, build custom gates and tensors, and define any entanglement scenario. (Control logic is handled separately from other gates.)
Famous Quantum Algorithms – explore Deutsch–Jozsa, Grover’s search, quantum Fourier transforms, Bernstein–Vazirani, and more.
Build & See Quantum Algorithms in Action – instead of just writing/ reading equations, make & watch algorithms unfold step by step so they become clear, visual, and unforgettable. Quantum Odyssey is built to grow into a full universal quantum computing learning platform. If a universal quantum computer can do it, I aim to bring it into the game!
Streams to watch:
khan academy style tutorials on qm/qc: MackAttackx">MackAttackx" rel="nofollow">https://www.youtube.com/@MackAttackx
Physics teacher wholesome stream with over 500hs in https://www.twitch.tv/beardhero
https://redd.it/1u9xyrq
@r_cpp
Removed by Reddit
Removed by Reddit on account of violating the [content policy. ]
https://redd.it/1udd0ql
@r_cpp
A first release of the program for Meeting C++ 2026
https://meetingcpp.com/meetingcpp/news/items/A-first-release-of-the-program-for-Meeting-Cpp-2026.html
https://redd.it/1udblca
@r_cpp
CppCast: Teaching C++ to Game Development Students in the Age of LLMs with Tom Tesch
https://cppcast.com/teaching_cpp_to_game_development_students_in_the_age_of_llms_with_tom_tesch/
https://redd.it/1ucxbo8
@r_cpp
C++Online 2026 Keynote - I Fixed Move Semantics - Jason Turner
https://youtu.be/TJhMGS9sRlw
https://redd.it/1ucszuo
@r_cpp
What’s your preferred setup for large C++ projects?
trying to put together something that won’t turn into a maintenance nightmare as we scale. sitting at aroubd 200k lines right now with a team of roughly 8 engineers, and were starting to hit some friction. not a disaster, but enough that id rather sort it out now than retrofit later.
current setup is cmake + make, gcc, no real dependency manager (vendoring almost everything),
ccache loosely configured,github actions for CI. it works.full builds are running around 25-30 minutes on a cold runner, which matches roughly what CI sees since we’re mostly doing clean builds on PRs. that’s the sore spot.
a few things i’m weighing: ninja over make at this sclae feels obvious but i want to hear it confirmed, vcpkg vs conan since we have mix of windows and linux devs, wether ccache is doing us any favors on CI or just on local machines. also debating clang vs gcc but no strong reason either way yet.
not looking for the perfect stack, just what people are actually running om codebases that grew past the point of simplicity. what broke first and what actually fixed it?
https://redd.it/1uckkfy
@r_cpp
An independently reverse engineered C++20 AirPlay 2 sender
I ended up reverse engineering Apple's AirPlay 2 realtime audio sender path and writing it in C++20, and thought the C++ side might be interesting here. it's lifted out of a shipping product and runs daily against a real Apple TV 4K and a MacBook, but it's not yet a turnkey library. The sender still does its networking via Qt, and the roadmap is to move that behind a small transport interface so it builds without Qt. The crypto and wire format core already builds standalone. Corrections very welcome, especially on the security scoping (receiver identity auth is currently log and continue, which I document). https://github.com/akustikrausch/airplay2-sender-cpp
https://redd.it/1ucf7fr
@r_cpp
Just got my first LGTM (PR merged into a major C++ library)
(https://preview.redd.it/just-got-my-first-lgtm-pr-merged-into-major-c-library-v0-l3a9cdzguo8h1.png?width=1919&format=png&auto=webp&s=8c324544c9ca43757f982ddf084badcd5ad29c68)
Just wanted to share a not so big of a deal but major personal milestone, i just got my very first pull request merged into the STEllAR Group's HPX parallel runtime library.
I'm an 18 year old undergrad at NITK, and diving into a high performance C++ codebase was honestly pretty intimidating. The bug I was tracking down caused the compiler to completely crash when handling certain parallel operations.
I spent the last few weeks digging through the code, rewriting the validation logic so it safely falls back to a sequential path when it needs to, and writing an automated test suite. Seeing all CI tests finally pass after a thorough code review was the best feeling ever.
The lead maintainer Harmut Kaiser was incredibly supportive and patient with me while i figured out the repos workflow and coding standards. Its wild to think that my code is officially a permanent part of the library now.
If anyone else is hesitant about jumping into open source, definitely go for it. The learning curve is brutal at first, but sticking with it and seeing it get merged makes so worth it.
Github: https://github.com/adhithyaragavan if anyone cares to check it out
https://redd.it/1ubzdpf
@r_cpp
nanobind: the bridge between C++ and Python...
nanobind is a C++17-first binding library , inspired by pybind11 but redesigned with a sharper focus on performance, compile times, and modern C++ practices. It’s built for developers who care about control—over lifetimes, memory, ABI stability, and error handling—without drowning in boilerplate.
​
Interested?
​
Read on
​
https://som-itsolutions.hashnode.dev/nanobind-the-bridge-between-c-and-python
https://redd.it/1ubtu4j
@r_cpp
BeCPP Symposium 2026, Keith Stockdale The journey to "/W4 /WX": How hard could it be?
https://youtu.be/iU3D6-EtyK4
https://redd.it/1ubn36p
@r_cpp
otherpeoplecode: Dynamically load DLLs over the internet in your Win32 C/C++ code
https://github.com/michaelsballoni/otherpeoplecode
https://redd.it/1ubf3up
@r_cpp
P3984: A type-safety profile
https://wg21.link/p3984
https://redd.it/1ua6h07
@r_cpp
libc.so and libstdc++.so
Can someone tell me whether what I'm saying is correct or not? A Linux distribution running on x86 has to include the `libc.so` and `libstdc++.so` libraries. These libraries are needed to run C and C++ programs. They must be present so that programs can communicate with the operating system. For example, if a program uses printf, does it have to use `libc.so` in order to print text to the screen in C?
https://redd.it/1ua0uf9
@r_cpp
One of the best C++29 features is already available?
https://meetingcpp.com/blog/items/One-of-the-best-Cpp29-features-is-already-available-.html
https://redd.it/1ua0of7
@r_cpp
Efficient C++ Programming for Modern 64-bit CPUs, Chapter 4/part 2
Here comes the 2nd installment of (VERY DRAFT) Chapters from my (and Dmytro Ivanchykhin's) upcoming book, "Efficient C++ Programming for Modern 64-bit CPUs". Comments are extremely welcome (as before, we're committed to fixing all the issues highlighted in comments).
Second part of Chapter 4 (the one on CPU Physics and CPU Cycles): https://6it.dev/blog/infographics-operation-costs-in-cpu-clock-cycles-take-2-80736 . In addition to some interesting data (in particular, micro-research on the progress of MUL/DIV ops since 2017), it has that visualization of the different times quite a few ppl here have asked for.
DISCLAIMERS:
\- it is VERY DRAFT (editing is coming)
\- this is not a book on optimizations (though some techniques will be covered in Appendices A and B in Vol. 2) - this is a book on de-pessimizations; for optimizations - please refer to the excellent book by Denis Bakhvalov (though we're sure that de-pessimizations should be seen as a prerequisite for optimizations 😉).
https://redd.it/1u9yi15
@r_cpp
What is the point of Emscripten?
Lately I was writing a manual for building my development environment incase I need to build it again.
​
I look at the platforms I want to target, and see Emscripten, for wasm32 and wasm64. Lately, I saw an article, saying that all major browsers have supported wasm64 besides safari, and I don't care about Mac users so I thought why don't I just target wasm64, I don't really want to think about going over 4GB anyway.
​
The problem is, I really want to get to multi language language projects, and rust doesn't have an Emscripten backend for 64 bits. It has one for 32 bits only.
​
That got me thinking, why am I even doing this, why should anyone run compute intensive stuff from a browser rather than just downloading a binary. I really feel like it doesn't really solve real problems.
​
Most stuff that people ported to web via emscripten is disgustingly slow, and they have zero toolchain control unlike native development. I can't just build a standard library of my choice from source and use it. Neither can I just use another allocator. It is all a giant black box.
​
I mean, android development is also annoying, but libraries like SDL just give you the wrappers normally, and the way you build stuff makes sense, you build C/C++ parts normally and just run another build on top of that with gradle and friends.
​
​
https://redd.it/1u9hee6
@r_cpp
