-
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
MS Visual Studio 18.5 has now been Released, with one caveat...
...It still doesn't have MSVC Build Tools v14.51, only an old preview.
https://learn.microsoft.com/en-us/visualstudio/releases/2026/release-notes
At the same time, Microsoft releases Visual Studio Insiders (basically VS preview), with the MSVC Build Tools v14.51 release, not a preview.
https://learn.microsoft.com/en-us/visualstudio/releases/2026/release-notes-insiders
So, now we have - official VS Release with the MSVC Build Tools v14.51 preview.
And VS preview with the MSVC Build Tools v14.51 release.
Person (or persons?...) in Microsoft responsible for this weirdness should get annual bonus reward.
https://redd.it/1slomwh
@r_cpp
A year of read-only cppreference
Over a year ago (on 30 March 2025), cppreference became read-only for maintenance reasons. Since then, the only progress update was in August. There have been several discussions here in the last few months about what is happening with cppreference and when it might become editable again, but from what I understand, we simply do not know.
At this point, I fear that the lack of updates for what is basically the authoritative source on the language (other than the standard of course), linked to by IDEs and even this subreddit's sidebar, might be detrimental to the adoption of C++26 and further standards, should the situation persist. I would therefore like to ask the community whether there are other, more up-to-date resources, and whether there is any effort to, for example, fork cppreference.
I understand that software updates are complicated and I have no intention to criticise the maintainers of cppreference (who are doing it voluntarily and I am not entitled in any way to their continued work on the website), but I do not think the C++ community can afford to be bottlenecked in such a way for much longer.
https://redd.it/1slfh4p
@r_cpp
The programming iceberg...
I always look for new resources to learn programming. However, every programming language created there will be a huge documentation that is born with it.
And they are very deep shit.
When you get an error from a compiler, there are these many cryptic messages pooping your entire screen and sometimes it just makes me wonder what they are..
Does anyone even read these for fun?
g++ compiler documentation
c++ documentation
Python "print()" documentation
https://redd.it/1sl5dil
@r_cpp
ACCU Overload Journal 192 - April 2026
https://accu.org/journals/overload/overload192
https://redd.it/1skwvnh
@r_cpp
Can we finally use C++ Modules in 2026? · Mathieu Ropert
https://mropert.github.io/2026/04/13/modules_in_2026/
https://redd.it/1skhgdo
@r_cpp
Differentiation of Digital Filters In PyTorch - How to evaluate differentiable filters 1000 times faster in PyTorch. - Chin-Yun Yu - [https://youtu.be/Br5QhU\_08Po](https://youtu.be/Br5QhU_08Po)
2026-03-30 - 2026-04-05
* Creating from Legacy Code - A Case Study of Porting Legacy Code from Exponential Audio - Harriet Drury - [https://youtu.be/rjafXQwCz4w](https://youtu.be/rjafXQwCz4w)
* Designing an Audio Live Coding Environment - Corné Driesprong - [https://youtu.be/Jw8x2uMgFnc](https://youtu.be/Jw8x2uMgFnc)
* How To Successfully Develop Software Products - Olivier Petit & Alistair Barker - [https://youtu.be/vymlQFopbp0](https://youtu.be/vymlQFopbp0)
**Meeting C++**
2026-04-06 - 2026-04-12
* The Misra C++:2023 Guidelines - Richard Kaiser - [https://www.youtube.com/watch?v=TRz-WXgADuI](https://www.youtube.com/watch?v=TRz-WXgADuI)
* Applied modern C++: efficient expression evaluator with type erasure - Olivia Quinet - [https://www.youtube.com/watch?v=66WtE\_7wE1c](https://www.youtube.com/watch?v=66WtE_7wE1c)
2026-03-30 - 2026-04-05
* Building C++: It Doesn't Have to be Painful! - Nicole Mazzuca - Meeting C++ 2025 - [https://www.youtube.com/watch?v=ExSlx0vBMXo](https://www.youtube.com/watch?v=ExSlx0vBMXo)
* int != safe && int != ℤ - Peter Sommerlad - Meeting C++ 2025 - [https://www.youtube.com/watch?v=YyNE6Y2mv1o&pp=0gcJCdkKAYcqIYzv](https://www.youtube.com/watch?v=YyNE6Y2mv1o&pp=0gcJCdkKAYcqIYzv)
**using std::cpp**
2026-03-30 - 2026-04-05
* Learning C++ as a newcomer - Berill Farkas - [https://www.youtube.com/watch?v=nsMl54Dvm24](https://www.youtube.com/watch?v=nsMl54Dvm24)
* C++29 Library Preview : A Practitioners Guide - Jeff Garland - [https://www.youtube.com/watch?v=NqpLxkatkt4](https://www.youtube.com/watch?v=NqpLxkatkt4)
* High frequency trading optimizations at Pinely - Mikhail Matrosov - [https://www.youtube.com/watch?v=qDhVrxqb40c](https://www.youtube.com/watch?v=qDhVrxqb40c)
* Don’t be negative! - Fran Buontempo - [https://www.youtube.com/watch?v=jqLEFPDXZ-o](https://www.youtube.com/watch?v=jqLEFPDXZ-o)
* Cross-Platform C++ AI Development with Conan, CMake, and CUDA - Luis Caro - [https://www.youtube.com/watch?v=jnKeUE2C8\_I](https://www.youtube.com/watch?v=jnKeUE2C8_I)
* Building a C++23 tool-chain for embedded systems - José Gómez López - [https://www.youtube.com/watch?v=AlNnd0QARS8](https://www.youtube.com/watch?v=AlNnd0QARS8)
* Space Invaders: The Spaceship Operator is upon us - Lieven de Cock - [https://www.youtube.com/watch?v=9niOq1kr61Y](https://www.youtube.com/watch?v=9niOq1kr61Y)
* Same C++, but quicker to the finish line - Daniela Engert - [https://www.youtube.com/watch?v=9ijIocn\_xzo](https://www.youtube.com/watch?v=9ijIocn_xzo)
* Having Fun With C++ Coroutines - Michael Hava - [https://www.youtube.com/watch?v=F9ffx7HvyrM](https://www.youtube.com/watch?v=F9ffx7HvyrM)
* The road to 'import boost': a library developer's journey into C++20 modules - Rubén Pérez Hidalgo - [https://www.youtube.com/watch?v=hD9JHkt7e2Y](https://www.youtube.com/watch?v=hD9JHkt7e2Y)
* C++20 and beyond: improving embedded systems performance - Alfredo Muela - [https://www.youtube.com/watch?v=SxrC-9g6G\_o](https://www.youtube.com/watch?v=SxrC-9g6G_o)
* Supercharge Your C++ Project: 10 Tips to Elevate from Repo to Professional Product - Mateusz Pusz - [https://www.youtube.com/watch?v=DWXlyOd\_z88](https://www.youtube.com/watch?v=DWXlyOd_z88)
* Compiler as a Service: C++ Goes Live - Aaron Jomy, Vipul Cariappa - [https://www.youtube.com/watch?v=jMO5Usa26cg](https://www.youtube.com/watch?v=jMO5Usa26cg)
* The CUDA C++ Developer's Toolbox - Bernhard Manfred Gruber - [https://www.youtube.com/watch?v=MNwGvqX4KH0](https://www.youtube.com/watch?v=MNwGvqX4KH0)
* C++ Committee Q&A at using std::cpp 2026 - [https://www.youtube.com/watch?v=iD5Bj7UyAQI](https://www.youtube.com/watch?v=iD5Bj7UyAQI)
* The Mathematical Mind of a C++ Programmer - Joaquín M López - [https://www.youtube.com/watch?v=9g4K-oNw1SE](https://www.youtube.com/watch?v=9g4K-oNw1SE)
* C++ Profiles: What, Why, and How - Gabriel Dos Reis -
Differentiation of Digital Filters In PyTorch - How to evaluate differentiable filters 1000 times faster in PyTorch. - Chin-Yun Yu - https://youtu.be/Br5QhU\_08Po
2026-03-30 - 2026-04-05
Creating from Legacy Code - A Case Study of Porting Legacy Code from Exponential Audio - Harriet Drury - [https://youtu.be/rjafXQwCz4w](https://youtu.be/rjafXQwCz4w)
Designing an Audio Live Coding Environment - Corné Driesprong - https://youtu.be/Jw8x2uMgFnc
How To Successfully Develop Software Products - Olivier Petit & Alistair Barker - [https://youtu.be/vymlQFopbp0](https://youtu.be/vymlQFopbp0)
Meeting C++
2026-04-06 - 2026-04-12
The Misra C++:2023 Guidelines - Richard Kaiser - https://www.youtube.com/watch?v=TRz-WXgADuI
Applied modern C++: efficient expression evaluator with type erasure - Olivia Quinet - [https://www.youtube.com/watch?v=66WtE\_7wE1c](https://www.youtube.com/watch?v=66WtE_7wE1c)
2026-03-30 - 2026-04-05
Building C++: It Doesn't Have to be Painful! - Nicole Mazzuca - Meeting C++ 2025 - https://www.youtube.com/watch?v=ExSlx0vBMXo
int != safe && int != ℤ - Peter Sommerlad - Meeting C++ 2025 - [https://www.youtube.com/watch?v=YyNE6Y2mv1o&pp=0gcJCdkKAYcqIYzv](https://www.youtube.com/watch?v=YyNE6Y2mv1o&pp=0gcJCdkKAYcqIYzv)
using std::cpp
2026-03-30 - 2026-04-05
Learning C++ as a newcomer - Berill Farkas - https://www.youtube.com/watch?v=nsMl54Dvm24
C++29 Library Preview : A Practitioners Guide - Jeff Garland - [https://www.youtube.com/watch?v=NqpLxkatkt4](https://www.youtube.com/watch?v=NqpLxkatkt4)
High frequency trading optimizations at Pinely - Mikhail Matrosov - https://www.youtube.com/watch?v=qDhVrxqb40c
Don’t be negative! - Fran Buontempo - [https://www.youtube.com/watch?v=jqLEFPDXZ-o](https://www.youtube.com/watch?v=jqLEFPDXZ-o)
Cross-Platform C++ AI Development with Conan, CMake, and CUDA - Luis Caro - https://www.youtube.com/watch?v=jnKeUE2C8\_I
Building a C++23 tool-chain for embedded systems - José Gómez López - [https://www.youtube.com/watch?v=AlNnd0QARS8](https://www.youtube.com/watch?v=AlNnd0QARS8)
Space Invaders: The Spaceship Operator is upon us - Lieven de Cock - https://www.youtube.com/watch?v=9niOq1kr61Y
Same C++, but quicker to the finish line - Daniela Engert - [https://www.youtube.com/watch?v=9ijIocn\_xzo](https://www.youtube.com/watch?v=9ijIocn_xzo)
Having Fun With C++ Coroutines - Michael Hava - https://www.youtube.com/watch?v=F9ffx7HvyrM
The road to 'import boost': a library developer's journey into C++20 modules - Rubén Pérez Hidalgo - [https://www.youtube.com/watch?v=hD9JHkt7e2Y](https://www.youtube.com/watch?v=hD9JHkt7e2Y)
C++20 and beyond: improving embedded systems performance - Alfredo Muela - https://www.youtube.com/watch?v=SxrC-9g6G\_o
Supercharge Your C++ Project: 10 Tips to Elevate from Repo to Professional Product - Mateusz Pusz - [https://www.youtube.com/watch?v=DWXlyOd\_z88](https://www.youtube.com/watch?v=DWXlyOd_z88)
Compiler as a Service: C++ Goes Live - Aaron Jomy, Vipul Cariappa - https://www.youtube.com/watch?v=jMO5Usa26cg
The CUDA C++ Developer's Toolbox - Bernhard Manfred Gruber - [https://www.youtube.com/watch?v=MNwGvqX4KH0](https://www.youtube.com/watch?v=MNwGvqX4KH0)
C++ Committee Q&A at using std::cpp 2026 - https://www.youtube.com/watch?v=iD5Bj7UyAQI
The Mathematical Mind of a C++ Programmer - Joaquín M López - [https://www.youtube.com/watch?v=9g4K-oNw1SE](https://www.youtube.com/watch?v=9g4K-oNw1SE)
C++ Profiles: What, Why, and How - Gabriel Dos Reis -
Amidst the LLM craze, does anyone still care about old machine learning algorithms?
I've built my own framework that allows embedding, quantization, and self-retraining on microcontrollers using C++ from scratch, currently mainly for tree-based model families (like Random Forest, xgboost...). It can compress and train the entire MNIST dataset of 70,000 images on ESP32 with only 3MB of RAM while still achieving an accuracy of up to \~94% across 10 classes (models size about 600 KB of RAM). This is intended to help the model adapt without having to reload the code into the microcontroller.
Everything is here, including source code, demo, and documentation: https://github.com/viettran-edgeAI/MCU
Although it's designed to handle tabular data, I chose to demo it with a simple computer vision application for visualization.
I spent a lot of time on this project, it didn't rely heavily on AI, and I can explain every line of code. I'm open to discussing anything. I hope everyone can provide some feedback or suggestions. In my country, it seems like now they only care about LLMs; every paper tries to cram LLMs in and they don’t care about these older algorithms anymore—they just brush them aside.
https://redd.it/1skdyr7
@r_cpp
Let's bite the Bullet: Module Units shouldn't implicitly import anything
https://github.com/abuehl/docs/blob/main/no-implicit-import.md
https://redd.it/1sk1x75
@r_cpp
References vs Pointers
https://slicker.me/cpp/references_pointers.htm
https://redd.it/1sjyh5l
@r_cpp
CMake Past, Present, and Future - Bill Hoffman, Kitware [29m25s]
https://www.youtube.com/watch?v=cD-JgncskTQ
https://redd.it/1sjoid3
@r_cpp
Building a Deep learning framework in C++ (from scratch) - training MNIST as a milestone
i am building a deep learning framework called "Forge" completely from scratch in C++, its nowhere near complete yet, training MNIST Classifier shows a functional core on CPU (i'll add a CUDA backend too). My end goal is to train a modern transformer on Forge.
YT video of MNIST training :- www.youtube.com/watch?v=CalrXYYmpfc
this video shows:
\-> training an MLP on MNIST
\-> loss decreasing over epochs
\-> predictions vs ground truth
this stable training proves that the following components are working correctly:-
\--> Tensor system (it uses Eigen as math backend, but i'll handcraft the math backend/kernels for CUDA later) and CPU memory allocator.
\--> autodiff engine (computation graph is being built and traversed correctly)
\-->primitives -- linear layer, relu activation (Forge has sigmoid, softmax, gelu, tanh and leakyrelu too), CrossEntropy loss function (it fuses log softmax and CE. Forge has MSE and BinaryCrossEntropy too, the BCE fuses sigmoid and BCE) and SGD optimizer (i am planning to add momentum in SGD, Adam and AdamW)
[the Forge repo on GitHub is currently private as its WAP\]
My GitHub: github.com/muchlakshay
https://redd.it/1silamh
@r_cpp
Is Modern C++ Actually Making Us More Productive... or Just More Complicated?
Quick one that's been on my mind: with C++20/23 throwing ranges, coroutines, concepts, and modules at us, are we actually making the language better for real-world work… or just stacking more complexity on top of an already complicated beast?
Some of these features are genuinely cool and I use them, but I keep wondering if we're scaring off new devs while old codebases stay frozen in C++98 forever. Is modern C++ a net win for productivity, or are we over-engineering?
What do you think? Love it, hate it, or somewhere in between?
https://redd.it/1sihs1w
@r_cpp
HPX Tutorials: Performance analysis with VTune
https://www.youtube.com/watch?v=ddLCrNEZhts
https://redd.it/1shqr6c
@r_cpp
We benchmarked sender-based I/O against coroutine-based I/O. Here's what we found.
When I/O operations return senders, they incur an unnecessary per-operation allocation. This explains why.
|Stream Type|capy::task|bex::task|sender pipeline|
|:-|:-|:-|:-|
|Native|0|0|0|
|Abstract|0|1|1|
|Type-erased|0|1|1|
When an I/O stream is type-erased, sender/receiver's connect() produces an operation state whose type depends on both the sender and the receiver. The size is unknown at construction time. It must be heap-allocated per operation. Under awaitables, await_suspend takes a coroutine_handle<> — the consumer type is already erased — so the awaitable can be preallocated once and reused. The allocation cannot be eliminated. It follows from connect producing a type that depends on both the sender and the receiver.
We measured this. The benchmark executes 20,000,000 read_some calls per configuration on a single thread using a stream that isolates the execution model overhead from I/O latency. Five independent runs plus warmup; values are mean ± standard deviation. The benchmark source is public:
https://github.com/cppalliance/capy/tree/develop/bench/beman
Anyone is invited to inspect the code, suggest improvements, and help make it better. The architects of P2300 are especially welcome — their expertise would strengthen the comparison.
Two papers address the cost asymmetry. P4003R0 "Coroutines for I/O" defines the IoAwaitable protocol for standard I/O operations. P4126R0 "A Universal Continuation Model" is purely additive — it gives sender/receiver pipelines zero-allocation access to every awaitable ever written. Together they make coroutines and senders both first-class citizens of the I/O stack.
# Benchmark Results
All values are mean ± stddev over 5 runs (warmup pass discarded). Each table measures one execution model consuming two I/O return types (awaitable and sender). The native column is the model's own I/O type; the other column goes through a bridge.
# Table 1: sender/receiver pipeline
|Stream Type|sender (native)|awaitable (bridge)|
|:-|:-|:-|
|Native|34.3 ± 0.1 ns/op, 0 al/op|46.3 ± 0.0 ns/op, 1 al/op|
|Abstract|47.1 ± 0.2 ns/op, 1 al/op|46.4 ± 0.0 ns/op, 1 al/op|
|Type-erased|57.5 ± 0.0 ns/op, 1 al/op|54.1 ± 0.1 ns/op, 1 al/op|
|Synchronous|2.6 ± 0.3 ns/op, 0 al/op|5.1 ± 0.1 ns/op, 0 al/op|
# Table 2: capy::task
|Stream Type|awaitable (native)|sender (bridge)|
|:-|:-|:-|
|Native|31.4 ± 0.2 ns/op, 0 al/op|48.1 ± 0.3 ns/op, 0 al/op|
|Abstract|32.3 ± 0.2 ns/op, 0 al/op|72.2 ± 0.2 ns/op, 1 al/op|
|Type-erased|36.4 ± 0.1 ns/op, 0 al/op|72.1 ± 0.0 ns/op, 1 al/op|
|Synchronous|1.0 ± 0.2 ns/op, 0 al/op|19.0 ± 0.0 ns/op, 0 al/op|
# Table 3: beman::execution::task
Note: bex::task's await_transform calls the sender's as_awaitable member directly when available, bypassing connect and start. Table 3's native sender column measures the as_awaitable path, not the full sender protocol.
|Stream Type|sender (native)|awaitable (bridge)|
|:-|:-|:-|
|Native|31.9 ± 0.0 ns/op, 0 al/op|43.5 ± 0.1 ns/op, 1 al/op|
|Abstract|55.2 ± 0.0 ns/op, 1 al/op|43.4 ± 0.0 ns/op, 1 al/op|
|Type-erased|55.2 ± 0.0 ns/op, 1 al/op|48.7 ± 0.1 ns/op, 1 al/op|
|Synchronous|1.0 ± 0.2 ns/op, 0 al/op|2.9 ± 0.2 ns/op, 0 al/op|
The full formatted report with detailed analysis is here: https://gist.github.com/sgerbino/2a64990fb221f6706197325c03e29a5e
# Analysis
Native performance is equivalent. Both models achieve \~31–34 ns/op with zero allocations when consuming their native I/O type on a concrete stream. There is no inherent speed advantage to either model at the baseline.
Type erasure costs diverge. capy::any_read_stream adds \~5 ns/op and zero allocations. The awaitable is preallocated at stream construction and reused across every read_some call. This is possible because
NDC Techtown conference in Norway (Kongsberg)
The deadline for submitting talks to NDC Techtown 2026 is still open. This great SW development conference takes place in Kongsberg, Norway on 21st to 24th September and focuses on SW development for embedded and systems programming. The conference covers travel and accommodation.
More info here: https://ndctechtown.com/call-for-papers
https://redd.it/1slfkh6
@r_cpp
How Much Linear Memory Access Is Enough? (A Benchmark)
https://solidean.com/blog/2026/how-much-linear-memory-access-is-enough/
https://redd.it/1slaltv
@r_cpp
Valgrind-3.27.0.RC1 is available for testing
An RC1 tarball for 3.27.0 is now available at
https://sourceware.org/pub/valgrind/valgrind-3.27.0.RC1.tar.bz2
(md5sum = bd95111c1a9f81f136c5e4e2c62b493e)
(sha1sum = 0eefb3a7d86a3bd0154480db3d2173bb8bd6d7c1)
https://sourceware.org/pub/valgrind/valgrind-3.27.0.RC1.tar.bz2.asc
Public keys can be found at https://www.klomp.org/mark/gnupg-pub.txt
Please give it a try in configurations that are important for you and report any problems you have, either on the developer/user mailing list, or (preferably) via our bug tracker at https://bugs.kde.org/enter\_bug.cgi?product=valgrind
An RC2 should be available Fri Apr 17
The final 3.27.0 release is scheduled for Mon Apr 20.
https://redd.it/1sl2yqb
@r_cpp
Recent lld/ELF performance improvements
https://maskray.me/blog/2026-04-12-recent-lld-elf-performance-improvements
https://redd.it/1skocrw
@r_cpp
[https://www.youtube.com/watch?v=Z6Nkb1sCogI](https://www.youtube.com/watch?v=Z6Nkb1sCogI)
* Nanoseconds, Nine Nines and Structured Concurrency - Juan Alday - [https://www.youtube.com/watch?v=zyhWzoE3Y2c](https://www.youtube.com/watch?v=zyhWzoE3Y2c)
* Fantastic continuations and how to find them - Gonzalo Juarez - [https://www.youtube.com/watch?v=\_0xRMXA83z0](https://www.youtube.com/watch?v=_0xRMXA83z0)
* You 'throw'; I'll 'try' to 'catch' it - Javier López Gómez - [https://www.youtube.com/watch?v=VwloPRtTGkU](https://www.youtube.com/watch?v=VwloPRtTGkU)
* Squaring the Circle: value-oriented design in an object-oriented system -Juanpe Bolívar - [https://www.youtube.com/watch?v=DWthcNoRVew](https://www.youtube.com/watch?v=DWthcNoRVew)
* Concept-based Generic Programming - Bjarne Stroustrup - [https://www.youtube.com/watch?v=V0\_Q0H-PQYs](https://www.youtube.com/watch?v=V0_Q0H-PQYs)
https://redd.it/1ske930
@r_cpp
New C++ Conference Videos Released This Month - April 2026 (Updated To Include Videos Released 2026-04-06 - 2026-04-12)
**CppCon**
2026-04-06 - 2026-04-12
* Rust/C++ Interop Challenges - Victor Ciura - [https://youtu.be/8xqhSy539Pc](https://youtu.be/8xqhSy539Pc)
* groov: Asynchronous Handling of Special Function Registers - Michael Caisse - [https://youtu.be/TjSL-XCyUJY](https://youtu.be/TjSL-XCyUJY)
* Clean code! Horrible Performance? - Sandor Dargo - [https://youtu.be/nLts4S8xSd4](https://youtu.be/nLts4S8xSd4)
* Beyond the Big Green Button: Demystifying the Embedded Build Process - Morten Winkler Jørgensen - [https://youtu.be/UekVdzMCAa0](https://youtu.be/UekVdzMCAa0)
* C++: Some Assembly Required - Matt Godbolt - [https://youtu.be/zoYT7R94S3c](https://youtu.be/zoYT7R94S3c)
2026-03-30 - 2026-04-05
* How to Build Type Traits in C++ Without Compiler Intrinsics Using Static Reflection - Andrei Zissu - [https://youtu.be/EcqiwhxKZ4g](https://youtu.be/EcqiwhxKZ4g)
* Beyond Sequential Consistency: Unlocking Hidden Performance Gains - Christopher Fretz - CppCon 2025 - [https://youtu.be/6AnHbZbLr2o](https://youtu.be/6AnHbZbLr2o)
* Dynamic Asynchronous Tasking with Dependencies - Tsung-Wei (TW) Huang - CppCon 2025 - [https://youtu.be/6Jd9Zyl9SDc](https://youtu.be/6Jd9Zyl9SDc)
* Work Contracts in Action: Advancing High-performance, Low-latency Concurrency in C++ - Michael Maniscalco - CppCon 2025 - [https://youtu.be/5ghAa7B5bF0](https://youtu.be/5ghAa7B5bF0)
* Constexpr STL Containers: Why C++20 Still Falls Short - Sergey Dobychin - CppCon 2025 - [https://youtu.be/Py4GJaCHwkA](https://youtu.be/Py4GJaCHwkA)
**C++Online**
2026-04-06 - 2026-04-12
Mastering C++ Clocks: A Deep Dive into std::chrono - Sandor DARGO - [https://youtu.be/ytI6pzT1Opk](https://youtu.be/ytI6pzT1Opk)
2026-03-30 - 2026-04-05
* Is AI Destroying Software Development? - David Sankel - C++Online 2026 - [https://youtu.be/Ek32ZH3AI3k](https://youtu.be/Ek32ZH3AI3k)
* From Hello World to Real World - A Hands-On C++ Journey from Beginner to Advanced - Workshop Preview - Amir Kirsh - [https://youtu.be/2zhW-tL2UXs](https://youtu.be/2zhW-tL2UXs)
* Workshop Preview: C++ Software Design - Klaus Iglberger - [https://youtu.be/VVQN-fkwqlA](https://youtu.be/VVQN-fkwqlA)
* Workshop Preview: Essential GDB and Linux System Tools - Mike Shah - [https://youtu.be/ocaceZWKm\_k](https://youtu.be/ocaceZWKm_k)
* Workshop Preview: Concurrency Tools in the C++ Standard Library - A Hands-On Workshop - Mateusz Pusz - [https://youtube.com/live/Kx9Ir1HBbwY](https://youtube.com/live/Kx9Ir1HBbwY)
* Workshop Preview: Mastering std::execution (Senders/Receivers) - A Hands-On Workshop - Mateusz Pusz - [https://youtube.com/live/bsyqh\_bjyE4](https://youtube.com/live/bsyqh_bjyE4)
* Workshop Preview: How C++ Actually Works - Hands-On With Compilation, Memory, and Runtime - Assaf Tzur-El - [https://youtube.com/live/L0SSRRnbJnU](https://youtube.com/live/L0SSRRnbJnU)
* Workshop Preview: Jumpstart to C++ in Audio - Learn Audio Programming & Create Your Own Music Plugin/App with the JUCE C++ Framework - Jan Wilczek - [https://youtube.com/live/M3wJN0x8cJw](https://youtube.com/live/M3wJN0x8cJw)
* Workshop Preview: AI++ 101 - Build an AI Coding Assistant in C++ & AI++ 201 - Build a Matching Engine with Claude Code - Jody Hagins - [https://youtube.com/live/Vx7UA9wT7Qc](https://youtube.com/live/Vx7UA9wT7Qc)
* Workshop Preview: Stop Thinking Like a Junior - The Soft Skills That Make You Senior - Sandor DARGO - [https://youtube.com/live/nvlU5ETuVSY](https://youtube.com/live/nvlU5ETuVSY)
* Workshop Preview: Splice & Dice - A Field Guide to C++26 Static Reflection - Koen Samyn - [https://youtube.com/live/9bSsekhoYho](https://youtube.com/live/9bSsekhoYho)
**ADC**
2026-04-06 - 2026-04-12
* Hacking Handhelds for Creative Audio - Building Music Applications for the New Nintendo 3DS - Leonardo Foletto - [https://youtu.be/x-9lDvfAKd0](https://youtu.be/x-9lDvfAKd0)
* Helicopter View of Audio ML - Martin Swanholm - [https://youtu.be/TxQ4htrS2Po](https://youtu.be/TxQ4htrS2Po)
* PhilTorch: Accelerating Automatic
New C++ Conference Videos Released This Month - April 2026 (Updated To Include Videos Released 2026-04-06 - 2026-04-12)
CppCon
2026-04-06 - 2026-04-12
Rust/C++ Interop Challenges - Victor Ciura - [https://youtu.be/8xqhSy539Pc](https://youtu.be/8xqhSy539Pc)
groov: Asynchronous Handling of Special Function Registers - Michael Caisse - https://youtu.be/TjSL-XCyUJY
Clean code! Horrible Performance? - Sandor Dargo - [https://youtu.be/nLts4S8xSd4](https://youtu.be/nLts4S8xSd4)
Beyond the Big Green Button: Demystifying the Embedded Build Process - Morten Winkler Jørgensen - https://youtu.be/UekVdzMCAa0
C++: Some Assembly Required - Matt Godbolt - [https://youtu.be/zoYT7R94S3c](https://youtu.be/zoYT7R94S3c)
2026-03-30 - 2026-04-05
How to Build Type Traits in C++ Without Compiler Intrinsics Using Static Reflection - Andrei Zissu - https://youtu.be/EcqiwhxKZ4g
Beyond Sequential Consistency: Unlocking Hidden Performance Gains - Christopher Fretz - CppCon 2025 - [https://youtu.be/6AnHbZbLr2o](https://youtu.be/6AnHbZbLr2o)
Dynamic Asynchronous Tasking with Dependencies - Tsung-Wei (TW) Huang - CppCon 2025 - https://youtu.be/6Jd9Zyl9SDc
Work Contracts in Action: Advancing High-performance, Low-latency Concurrency in C++ - Michael Maniscalco - CppCon 2025 - [https://youtu.be/5ghAa7B5bF0](https://youtu.be/5ghAa7B5bF0)
Constexpr STL Containers: Why C++20 Still Falls Short - Sergey Dobychin - CppCon 2025 - https://youtu.be/Py4GJaCHwkA
C++Online
2026-04-06 - 2026-04-12
Mastering C++ Clocks: A Deep Dive into std::chrono - Sandor DARGO - https://youtu.be/ytI6pzT1Opk
2026-03-30 - 2026-04-05
Is AI Destroying Software Development? - David Sankel - C++Online 2026 - [https://youtu.be/Ek32ZH3AI3k](https://youtu.be/Ek32ZH3AI3k)
From Hello World to Real World - A Hands-On C++ Journey from Beginner to Advanced - Workshop Preview - Amir Kirsh - https://youtu.be/2zhW-tL2UXs
Workshop Preview: C++ Software Design - Klaus Iglberger - [https://youtu.be/VVQN-fkwqlA](https://youtu.be/VVQN-fkwqlA)
Workshop Preview: Essential GDB and Linux System Tools - Mike Shah - https://youtu.be/ocaceZWKm\_k
Workshop Preview: Concurrency Tools in the C++ Standard Library - A Hands-On Workshop - Mateusz Pusz - [https://youtube.com/live/Kx9Ir1HBbwY](https://youtube.com/live/Kx9Ir1HBbwY)
Workshop Preview: Mastering std::execution (Senders/Receivers) - A Hands-On Workshop - Mateusz Pusz - https://youtube.com/live/bsyqh\_bjyE4
Workshop Preview: How C++ Actually Works - Hands-On With Compilation, Memory, and Runtime - Assaf Tzur-El - [https://youtube.com/live/L0SSRRnbJnU](https://youtube.com/live/L0SSRRnbJnU)
Workshop Preview: Jumpstart to C++ in Audio - Learn Audio Programming & Create Your Own Music Plugin/App with the JUCE C++ Framework - Jan Wilczek - https://youtube.com/live/M3wJN0x8cJw
Workshop Preview: AI++ 101 - Build an AI Coding Assistant in C++ & AI++ 201 - Build a Matching Engine with Claude Code - Jody Hagins - [https://youtube.com/live/Vx7UA9wT7Qc](https://youtube.com/live/Vx7UA9wT7Qc)
Workshop Preview: Stop Thinking Like a Junior - The Soft Skills That Make You Senior - Sandor DARGO - https://youtube.com/live/nvlU5ETuVSY
Workshop Preview: Splice & Dice - A Field Guide to C++26 Static Reflection - Koen Samyn - [https://youtube.com/live/9bSsekhoYho](https://youtube.com/live/9bSsekhoYho)
ADC
2026-04-06 - 2026-04-12
Hacking Handhelds for Creative Audio - Building Music Applications for the New Nintendo 3DS - Leonardo Foletto - https://youtu.be/x-9lDvfAKd0
Helicopter View of Audio ML - Martin Swanholm - [https://youtu.be/TxQ4htrS2Po](https://youtu.be/TxQ4htrS2Po)
PhilTorch: Accelerating Automatic
std::pmr::generator, a generator without heap allocation
https://a4z.noexcept.dev/blog/2026/04/13/pmr-generator.html
https://redd.it/1skas3i
@r_cpp
The Global API Injection Pattern
https://www.elbeno.com/blog/?p=1831
https://redd.it/1sjzwaf
@r_cpp
Deciding 3rd party library
Hi all,
How do you people decide which opensource 3rd party library to include in a production environment, e.g for logging I can use either spdlog, Quill, Log4cplus, etc
Not every system is a HFT, in a general production system, how would you usually decide a library, practically speaking, I can get the logs through all of them but which one you would choose, I just took example of logger libs, it can be anything, I would like to understand how you all come to conclusion! do you usually study the whole library before using it?
https://redd.it/1sjrx2w
@r_cpp
400 page C++ full notes for beginners Available on Stuvia
A friend uploaded 400 page C++ notes for beginners who are just starting out with C++ programming and want clear and easy to understand explanations. Send me DM if you're interested.
https://redd.it/1siokcv
@r_cpp
I implemented UFCS in clang. Why it is cool, and why it will never come to C++.
https://github.com/ZXShady/zxshady.github.io/blob/main/ufcs.md
https://redd.it/1sik2vn
@r_cpp
I built a real-time N-body gravity simulator in C++/OpenGL — physically accurate with 4th-order Yoshida integration
Yo Reddit!
Finally shipping something I've been building for a while — a gravitational N-body simulator where I was pretty obsessed with making the physics realistic.
The integrator is Yoshida 4th-order symplectic — a step above Velocity Verlet. It runs 3 force evaluations per time step with coefficients derived to cancel lower-order error terms, giving much better long-term energy conservation for orbital sims.
Everything else in real units:
\- G = 6.674×10⁻¹¹ in full SI throughout
\- Planetary masses from real solar mass ratios
\- Orbital distances in real AU, time steps of 1 real day
\- Initial velocities from v = √(GM/r) so orbits are correct from frame 1
\- Momentum-conserving mergers when bodies collide
\- Live readout of speed in km/s and distance in AU — verifiable against NASA
Built with C++17, OpenGL 4.6, GLFW, GLM, ImGui, and stb_easy_font. Runs on Windows and Linux.
Would love any feedback — code structure, physics mistakes, whatever. I also have a bunch of open tickets if anyone wants to jump in (CMake, planet textures, Lagrange points...). And if you dig it, a star on the repo would make my day!
GitHub: https://github.com/kikikian/orrery
https://redd.it/1siaqgc
@r_cpp
await_suspend takes a type-erased coroutine_handle<> — the consumer type is already erased, so the awaitable's size is known at construction time. The sender equivalents add \~21–23 ns/op and one allocation per operation. The sender's connect(receiver) produces an op_state whose type depends on both the sender and the receiver. Since either may be erased, the operation state must be heap-allocated.
Bridges are competitive. Both bridges add 11–17 ns for native streams with zero bridge allocations. The allocations visible in the bridged columns come from the target model's own machinery (type-erased connect, executor adapter posting), not from the bridges themselves.std::execution provides compile-time sender composition, structured concurrency guarantees, and a customization point model that enables heterogeneous dispatch. These are real achievements for real domains — GPU dispatch, work-graph pipelines, heterogeneous execution. Coroutines serve a different domain. They cannot express compile-time work graphs or target heterogeneous dispatch. What they do is serial byte-oriented I/O — reads, writes, timers, DNS lookups, TLS handshakes — the work that networked applications spend most of their time on.
# Trade-off Summary
|Feature|IoAwaitable|sender/receiver|
|:-|:-|:-|
|Native concrete performance|\~31 ns/op, 0 al/op|\~32–34 ns/op, 0 al/op|
|Type erasure cost|\+5 ns/op, 0 al/op|\+21–23 ns/op, 1 al/op|
|Type erasure mechanism|preallocated awaitable|heap-allocated op_state|
|Why erasure allocates|it does not|op_state depends on sender AND receiver types|
|Synchronous completion|\~1 ns/op via symmetric transfer|\~2.6 ns/op via trampoline|
|Looping|native for loop|requires repeat_until \+ trampoline|
|Bridge to other model (native)|\~17 ns/op, 0 al/op|\~12 ns/op, 1 al/op|
|Bridge to other model (erased)|\~36 ns/op, 1 al/op|\~12 ns/op, 1 al/op|
https://redd.it/1shmwzz
@r_cpp
Freestanding standard library
https://www.sandordargo.com/blog/2026/04/08/cpp-freestanding
https://redd.it/1she4xf
@r_cpp