-
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
New C++ Conference Videos Released This Month - March 2026 (Updated To Include Videos Released 2026-03-02 - 2026-03-08)
**CppCon**
2026-03-02 - 2026-03-08
* Interesting Upcoming Low-Latency, Concurrency, and Parallelism Features from Wroclaw 2024, Hagenberg 2025, and Sofia 2025 - Paul E. McKenney, Maged Michael, Michael Wong - CppCon 2025 - [https://youtu.be/M1pqI1B9Zjs](https://youtu.be/M1pqI1B9Zjs)
* Threads vs Coroutines — Why C++ Has Two Concurrency Models - Conor Spilsbury - CppCon 2025 - [https://youtu.be/txffplpsSzg](https://youtu.be/txffplpsSzg)
* From Pure ISO C++20 To Compute Shaders - Koen Samyn - CppCon 2025 - [https://youtu.be/hdzhhqvYExE](https://youtu.be/hdzhhqvYExE)
* Wait is it POSIX? Investigating Different OS and Library Implementations for Networking - Katherine Rocha - CppCon 2025 - [https://youtu.be/wDyssd8V\_6w](https://youtu.be/wDyssd8V_6w)
* End-to-End Latency Metrics From Distributed Trace - Kusha Maharshi - CppCon 2025 - [https://youtu.be/0bPqGN5J7f0](https://youtu.be/0bPqGN5J7f0)
2026-02-23 - 2026-03-01
* Fix C++ Stack Corruptions with the Shadow Stack Library - Bartosz Moczulski - CppCon 2025 - [https://youtu.be/-Qg0GaONwPE](https://youtu.be/-Qg0GaONwPE)
* First Principles While Designing C++ Applications - Prabhu Missier - CppCon 2025 - [https://youtu.be/8mLo5gXwn4k](https://youtu.be/8mLo5gXwn4k)
* Matrix Multiplication Deep Dive || Cache Blocking, SIMD & Parallelization - Aliaksei Sala - CppCon 2025 - [https://youtu.be/GHctcSBd6Z4](https://youtu.be/GHctcSBd6Z4)
* Choose the Right C++ Parallelism Tool | Low-Level vs Async vs Coroutines vs Data Parallel - Eran Gilad - CppCon 2025 - [https://youtu.be/7a9AP4rD08M](https://youtu.be/7a9AP4rD08M)
* ISO C++ Standards Committee Panel Discussion 2025 - Hosted by Herb Sutter - CppCon 2025 - [https://youtu.be/R2ulYtpV\_rs](https://youtu.be/R2ulYtpV_rs)
**ADC**
2026-03-02 - 2026-03-08
* Efficient Task Scheduling in a Multithreaded Audio Engine - Algorithms and Analysis for Parallel Graph Execution - Rachel Susser - ADC 2025 - [https://youtu.be/bEtSeGr8UvY](https://youtu.be/bEtSeGr8UvY)
* The Immersive Score - Creative Advantages of Beds and Objects in Film and Game Music - Simon Ratcliffe - ADCx Gather 2025 - [https://youtu.be/aTmkr0yTF5g](https://youtu.be/aTmkr0yTF5g)
* Tabla to Drumset - Translating Rhythmic Language through Machine Learning - Shreya Gupta - ADC 2025 - [https://youtu.be/g14gESreUGY](https://youtu.be/g14gESreUGY)
2026-02-23 - 2026-03-01
* Channel Agnosticism in MetaSounds - Simplifying Audio Formats for Reusable Graph Topologies - Aaron McLeran - ADC 2025 - [https://youtu.be/CbjNjDAmKA0](https://youtu.be/CbjNjDAmKA0)
* Sound Over Boilerplate - Accessible Plug-Ins Development With Phausto and Cmajor - Domenico Cipriani - ADCx Gather 2025 - [https://youtu.be/DVMmKmj1ROI](https://youtu.be/DVMmKmj1ROI)
* Roland Future Design Lab x Neutone: diy:NEXT - Paul McCabe, Ichiro Yazawa & Alfie Bradic - ADC 2025 - [https://youtu.be/4JIiYqjq3cA](https://youtu.be/4JIiYqjq3cA)
**Meeting C++**
2026-03-02 - 2026-03-08
* Persistence squared: persisting persistent data structures - Juan Pedro Bolívar Puente - Meeting C++ - [https://www.youtube.com/watch?v=pQhHx0h-904](https://www.youtube.com/watch?v=pQhHx0h-904)
2026-02-23 - 2026-03-01
* Instruction Level Parallelism and Software Performance - Ivica Bogosavljevic - Meeting C++ 2025 - [https://www.youtube.com/watch?v=PMu7QNctEGk](https://www.youtube.com/watch?v=PMu7QNctEGk)
* Real-time Safety — Guaranteed by the Compiler! - Anders Schau Knatten Meeting C++ 2025 - [https://www.youtube.com/watch?v=4aALnxHt9bU](https://www.youtube.com/watch?v=4aALnxHt9bU)
https://redd.it/1rp5c8n
@r_cpp
Reducing FFmpeg build times in practice
We compile FFmpeg from source regularly for custom codec work and video pipelines, so build time directly affects iteration speed. Baseline was a 24 minute clean build on a 16 core Xeon. During active development we were running multiple builds per day, and CI was consistently blocked on compilation.
ccache helped incremental builds but not clean CI runs. Disabling unused codecs with --disable-everything and enabling only what we needed saved about three minutes. NVMe storage produced marginal gains. Scaling cores and RAM helped up to 16 cores, then flattened out.
Profiling with ninja -d stats showed compilation at \~80 percent of wall time, linking at \~15 percent and mostly serial, configure at \~5 percent and serial.
We then tested distributed builds. distcc delivered roughly a 60 percent improvement but required nontrivial setup. icecc performed slightly better in our environment at around 65 percent. Incredibuild produced the largest gain at about 88 percent over baseline.
Final numbers:
Clean build: 24 minutes to 2 minutes 50 seconds
Incremental: 8 minutes to 45 seconds
Full CI pipeline: 35 minutes to 6 minutes
How far are you pushing distcc or icecc in workloads? Anyone managed to squeeze more out of them?
How are you handling LTO in distributed setups? Is there an approach that preserves most of the distributed gains without turning the final link into a long serial step?
For anyone working on other large C or C++ codebases, did distributed compilation create a similar step change, or did you hit a different ceiling first?
https://redd.it/1rp23xe
@r_cpp
StockholmCpp 0x3C: Intro, event host presentation, C++ news and the quiz
https://youtu.be/_oluCPrUaQ4
https://redd.it/1rot31n
@r_cpp
Lessons learned from 2 years of operating a C++ MMO game server in production 1/N
I've been working as a server team lead and technical director on a large-scale MMO for the past 2+ years, from launch through live service.
our server uses an in-house actor model.
The core parts of our code are over 15 years old.
It started with C++98. Now we use C++20.
We use modern C++, but old style code is still in many places.
One example is that we allow certain race conditions.
This codebase is older than the C++ memory model.
It worked then, and it still works now.
// attacker context
int32_t hp = target->hp(); // violates actor context, but allowed
Another example is our enum convention.
For enums that can have an empty state, we use INVALID as the first value.
enum class Weapon {
INVALID = 0,
Dagger,
Sword,
Bow,
};
We replaced INVALID with std::optional to separate the logic of "no value" from the actual data set.
// before
Weapon weapon = target->weapon();
if (weapon != Weapon::INVALID) {
Process(weapon);
}
// after
if (target->weapon().has_value()){
Process(target->weapon().value());
}
One month after we deployed it, we got a crash.
We identified the root cause through crash dump analysis. It was a TOCTOU problem.
// reading from another actor context
if (target->weapon().has_value()){
// another thread had changed the weapon.
Process(target->weapon().value()); // bad_optional_access
}
With INVALID, this would not have crashed.
We had to review all the code we changed.
We reverted the code that reads optional values from other actors back to the INVALID convention.
Now INVALID and std::optional coexist in our codebase.
We know that switching to std::atomic is the right fix.
But a simple swap could introduce other problems, so we are thinking it through carefully.
we did not review the existing code well enough before applying modern C++.
Legacy code has implicit rules.
Making code more explicit is what modern C++ is really for.
https://redd.it/1rotys6
@r_cpp
Why std::pmr Might Be Worth It for Real‑Time Embedded C++
http://www.sapnag.me/blog/cppdev/2025-12-26-containers-std-vs-pmr/
https://redd.it/1rosl4c
@r_cpp
Azrar - a String interning library for C++ with faster comparisons and reduced memory footprint"
Comments and critics are welcome :-)
Github link: [https://github.com/kboutora/Azrar](https://github.com/kboutora/Azrar)
This is a lightweight C++ (14 and +) library for string interning and indexing that can significantly improve performance in applications dealing with repeated string comparisons or using strings as maps key.
The library is header only.
**How it works:**
Instead of working with strings, Azrar maintains a dictionary where each unique string gets assigned a unique index..
Working with these unique indexes makes copying, comparing, and hashing operations substantially faster.
Github link: [https://github.com/kboutora/Azrar](https://github.com/kboutora/Azrar)
**Usage minimalist example:**
include "Azrar.h"
include <map>
include <iostream>
using IdxString = Azrar::StringIndex<uint32_t>;
int main(int , char **)
{
// Expect to print 4 (sizeof (uint32_t))
std::cout << "sizeof(IdxString): " << sizeof(IdxString) << " bytes\n\n";
IdxString city1("seattle");
IdxString city2("seattle");
IdxString city3("portland");
// Fast O(1) comparison (compares integers, not string contents)
if (city1 == city2) {
std::cout << "Same city!\n";
}
// Use as map keys - much faster lookups than std::string
std::map<IdxString, int> population;
population[city1] = 750000;
population[city3] = 650000;
// Access the original string when needed
std::cout << "City: " << city1.c_str() << "\n";
return 0;
}
https://redd.it/1rophrb
@r_cpp
P4043R0: Are C++ Contracts Ready to Ship in C++26?
Are you watching the ISO C++ standardization pipeline? Looking for the latest status about C++ Contracts?
I'm curious to see the non-WG21 C++ community opinion.
The C++26 Contracts facility (P2900) is currently in the Working Draft, but the design is still the subject of substantial discussion inside the committee.
This paper raises the question of whether Contracts are ready to ship in C++26 or whether the feature should be deferred to a later standard.
Click -> P4043R0: Are C++ Contracts Ready to Ship in C++26?
I'm curious to hear the perspective of the broader C++ community outside WG21:
\- Do you expect to use Contracts?
\- Does the current design make sense to you?
\- Would you prefer a simpler model?
Feedback welcome.
https://redd.it/1rnh401
@r_cpp
I made a single-header, non-intrusive IoC Container in C++17
[https://github.com/SirusDoma/Genode.IoC](https://github.com/SirusDoma/Genode.IoC)
A non-intrusive, single-header IoC container for C++17.
I was inspired after stumbling across a compiler loophole I found [here](https://alexpolt.github.io/type-loophole.html). Just now, I rewrote the whole thing without relying on that loophole because I just found out that my game sometimes won't compile on clang macOS without some workarounds.
Anyway, this is a similar concept to Java Spring, or C# Generic Host / Autofac, but unlike [kangaru](https://github.com/gracicot/kangaru) or other IoC libraries, this one is single header-only and most importantly: **non-intrusive**. Meaning you don't have to add anything extra to your classes, and it just works.
I have used this previously to develop a [serious game](https://www.reddit.com/r/gamedev/comments/1rldvqa/i_remade_an_online_retro_game_by_reverse/) with complex dependency trees (although it uses a previous version of this library, please check that link, it's made with C++ too), and a game work-in-progress that I'm currently working on with the new version I just pushed.
Template programming is arcane magic to me, so if you found something flawed / can be improved, please let me know and go easy on me 😅
**EDIT**
As requested, let me briefly talk about what IoC is:
IoC container stands for [Inversion of Control](https://en.wikipedia.org/wiki/Inversion_of_control), as mentioned, a similar concept to [Spring in Java](https://docs.spring.io/spring-framework/reference/core/beans/introduction.html). By extension, it is a [dependency injection](https://en.wikipedia.org/wiki/Dependency_injection) pattern that manages and abstracts dependencies in your code.
Imagine you have the following classes in your app:
struct NetworkSystem
{
NetworkSystem(Config& c, Logger& l, Timer& t, Profiler* p)
: config(&c), logger(&l), timer(&t), profiler(&p) {}
Config* config; Logger* logger; Timer* timer; Profiler *profiler;
};
In a plain old-school way, you initialize the `NetworkSystem` by doing this:
auto config = Config(fileName);
auto logger = StdOutLogger();
auto timer = Timer();
auto profiler = RealProfiler(someInternalEngine, someDependency, etc);
auto networkSystem = NetworkSystem(config, logger, timer, profiler);
And you have to manage the lifetime of these components individually. With IoC, you could do something like this:
auto ioc = Gx::Context(); // using my lib as example
// Using custom init
// All classes that require config in their constructor will be using this config instance as long as they are created via this "ioc" object.
ioc.Provide<Config>([] (auto& ctx) {
return std::make_unique<Config>(fileName);
});
// Usually you have to tell container which concrete class to use if the constructor parameter relies on abstract class
// For example, Logger is an abstract class and you want to use StdOut
ioc.Provide<Logger, StdOutLogger>();
// Now simply call this to create network system
networkSystem = ioc.Require<NetworkSystem>(); // will create NetworkSystem, all dependencies created automatically inside the container, and it will use StdOutLogger
That's the gist of it. Most of the IoC container implementations are customizable, meaning you can control the construction of your class object if needed and automate the rest.
Also, the lifetime of the objects is tied to the IoC container; this means if the container is destroyed, all objects are destroyed (typically with some exceptions; in my lib, using `Instantiate<T>` returns a `std::unique_ptr<T>`). On top of that, depending on the implementation, some libraries provide sophisticated ways to manage the lifetime.
I would suggest familiarizing yourself with the IoC pattern before trying it out to avoid anti-patterns: For example, passing the container itself to the constructor is considered an anti-pattern. The following code
Exploring Mutable Consteval State in C++26
https://friedkeenan.github.io/posts/exploring-mutable-consteval-state/
https://redd.it/1ro1gfz
@r_cpp
Announcing TEC v1.0.0: Lightweight Header-Only Template-Based C++ Library
Hey r/cpp!
I'm excited to announce the first stable release of TEC, a lightweight, header-only, template-based C++ library for multithreaded execution in concurrent environments. This version marks the foundation of TEC, providing core functionalities for a wide range of applications, from embedded systems to distributed networking.
TEC is Apache 2.0-licensed, open-source, and ready for contributions. Check out the GitHub repo for the full README, examples, and API docs.
## Key Features
- Header-Only Design: Seamless integration with no compilation dependencies, enabling rapid prototyping and cross-platform deployment.
- No external dependencies: TEC can be dropped into any project without requiring third-party libraries or tools (the use of gRPC and Zlib is optional).
- Networking Capabilities: Efficient BSD socked based servers and clients with low memory footprint, ideal for communication in distributed systems.
- gRPC Ecosystem: (optional) The TEC library streamlines the development of gRPC servers and clients by leveraging the universal TEC's Daemon API (DAPI).
- Distributed Systems Modeling: Low-overhead tools for simulating large-scale architectures, handling high connection volumes in cloud or edge environments.
## Getting Started
To use TEC, simply include the header files in your C++ project. No additional builds required. Check the README for detailed usage examples and API documentation.
## Known Issues
- None reported at this time. Please open an issue if you encounter any problems.
## Feedback and Contributions
This is our first release, so we'd love your thoughts! Star the repo, open issues for bugs/features, or submit PRs via our CONTRIBUTING.
Thanks for checking it out.
Cheers,
The Emacs Cat
(Developer of TEC)
https://redd.it/1rhv2ld
@r_cpp
Should C++ Give More Priority to Syntax Quality?
I’ve been thinking about this for a while and I’m curious what others here think.
The C++ committee does an incredible job focusing on zero overhead abstractions and performance. But I sometimes feel that syntax quality and aesthetic consistency don’t get the same level of attention.
Recently I’ve noticed more features being proposed or added with syntax that feels… awkward or visually noisy. A few examples:
* `co_await`
* The reflection operator `^^`
* The proposed `e.try?` try operator
And many other similar things. Individually none of these are catastrophic. But collectively, I worry about the long-term impact. C++ is already a dense and complex language. If new features keep introducing unusual tokens or visually jarring constructs there is a risks of becoming harder to reason about at a glance.
Should syntax design be given equal weight alongside performance?
I’d love to hear perspectives from people who follow WG21 discussions more closely. Is this something that’s actively debated? Or is syntax mostly a secondary concern compared to semantics and performance?
Curious to hear what others think.
https://redd.it/1rhrg10
@r_cpp
Language specific package managers are a horrible idea
Package managers should only deal with package cache and have a scripting interface.
Package managers trying to act smart only makes our jobs harder as evidenced by looking at the issue pages of global package registries.
I recommend everyone here to switch to Conan and not use any abstractions for the build systems, disable remote and use a deployment script or using full deploy as an option. It is not ideal, but it doesn't stand in your way.
https://redd.it/1rh97ru
@r_cpp
Data structures and algorithms
I'm new to programming and I started learning cpp as a first language, and I'm currently struggling to understand Data structures (sorting algorithms and search algorithms are kidna understandable but I didn't fully consumed it , but stacks are just straight outta hell ) and I feel lost , I don't seem to have a big problem with object oriented programming and file management so I'm I just stupid or DS is just this hard? , and is there any good coursess or YouTube videos that explains it good? And also a good oop explanation videos would help, thanks 😊 🙏
https://redd.it/1rhe1t0
@r_cpp
Mocking the Standard Template Library
https://middleraster.github.io/TBCI/MockingTheSTL.html
https://redd.it/1rgskhw
@r_cpp
Upscaled files detector
I built a small C++20 tool that detects MP3-to-WAV/FLAC upscaling using spectral analysis, and wanted to share it here since the core is pretty DSP-heavy.
The detection works by running a Cooley-Tukey FFT over multiple frames of the file (with Hann windowing to reduce leakage), then comparing the energy ratio between the 10–16 kHz mid band and everything above 16 kHz. MP3 encoders tend to hard-cut the upper frequencies, so a consistently low high/mid ratio across >70% of valid frames flags the file as probably transcoded. Frames below an RMS threshold are skipped to avoid silent passages skewing the result.
The FFT itself has an AVX2-optimized butterfly stage — I wanted to experiment with SIMD intrinsics, so when four or more butterflies remain in a block it processes them in parallel using 256-bit registers (4 complex numbers at a time via moveldup/movehdup + addsub_ps). The IFFT reuses the forward pass via the conjugate symmetry trick rather than a separate implementation.
There's also a real-time spectrogram and stereo volume meter rendered in the terminal with FTXUI, and a microphone passthrough mode with basic frequency-domain feedback suppression.
The detection heuristic is pretty empirical and I know it has limitations — it doesn't account for formats like AAC which have different cutoff characteristics, and the fixed 16 kHz threshold doesn't adapt to the file's sample rate ceiling. I'd be curious whether anyone here has thoughts on more robust approaches (spectral flatness, entropy measures, etc.).
Repo: https://github.com/giorgiogamba/avil
https://redd.it/1rh42mr
@r_cpp
FastParseX, A high‑performance C++ parser for huge CSV/Log/Binary files (mmap, zstd, Arrow/Parquet)
I've been working on a C++ parsing engine focused on processing very large files (GB-TB scale) with predictable performance and minimal allocations.
FastParseX supports:
\- zero-allocation CSV parsing (quoted fields, multiline, trimming)
\- log parsing (Apache/Nginx/custom formats)
\- binary parsing (endianness, slicing, struct reading)
\- memory-mapped I/O with madvise/prefetch
\- async buffered I/O
\- gzip/xz/zstd streaming
\- parallel chunk processing
\- profiling (type inference, cardinality, min/max)
\- Arrow export
\- Parquet export
Repo: https://github.com/FastParseX-dev/FastParseX
Feedback from people who care about low-level performance, parsing internals, or C++ API
design is very welcome.
https://redd.it/1rp4a5r
@r_cpp
The compilation procedure for C++20 modules
https://holyblackcat.github.io/blog/2026/03/09/compiling-modules.html
https://redd.it/1royqvw
@r_cpp
Implementing a Compile-Time Sudoku Solver in Modern C++ (C++20/23
I’ve been experimenting with **constexpr** and template metaprogramming in C++20/23, and I thought it would be fun to implement a **Sudoku solver entirely at compile-time**.
* The idea is to encode the Sudoku grid as `constexpr` arrays.
* All solving logic happens using **compile-time recursion and constraints**, leveraging concepts and `consteval` functions.
* The compiler does all the heavy lifting, so when the program runs, the solution is already baked in.
I’d love feedback on:
1. How to make the solver more **efficient for larger grids** at compile-time.
2. Best practices for **readable compile-time recursion** without hitting template depth limits.
3. How to **debug constexpr code** effectively in real-world projects.
I can share a **minimal working example** if people are interested.
Has anyone else tried doing heavy algorithmic work entirely at compile-time?
https://redd.it/1rougbu
@r_cpp
Collider: A package and dependency manager for Meson (wrap-based)
http://collider.ee
https://redd.it/1rot7rc
@r_cpp
Accessing inactive union members through char: the aliasing rule you didn’t know about
https://www.sandordargo.com/blog/2026/03/04/char-representation-and-UB
https://redd.it/1rn09z0
@r_cpp
C++ Reflection: Another Monad
https://www.elbeno.com/blog/?p=1813
https://redd.it/1rn0512
@r_cpp
illustrates the anti-pattern:
struct NetworkSystem
{
NetworkSystem(Gx::Context& ioc) // DON'T DO THIS. Stick with the example I provided above
{
config = ioc.Require<Config>();
logger = ioc.Require<Logger>();
timer = ioc.Require<Timer>();
profiler = ioc.Require<Profiler>();
}
Config* config; Logger* logger; Timer* timer; Profiler *profiler;
};
auto ioc = Gx::Context();
auto networkSystem = NetworkSystem(ioc); // just don't
The above case is an anti-pattern because **it hides dependencies.** When a class receives the entire container, its constructor signature no longer tells you what it actually needs, which defeats the purpose of [DI](https://en.wikipedia.org/wiki/Dependency_injection). IoC container should be primarily used in the root composition of your classes' initialization (e.g, your `main()`).
In addition, many IoC containers perform compile-time checks to some extent regardless of the language. By passing the container directly, you are giving up compile-time checks that the library can otherwise perform (e.g., `ioc.Require<NetworkSystem>()` may fail at compile-time if one of the dependencies is not constructible either by the library (multiple ambiguous constructors) or by the nature of the class itself). I think we all could agree that we should enforce compile-time checks whenever possible.
Just like other programming patterns, some exceptions may apply, and it might be more practical to go with anti-pattern in some particular situations (that's why `Require<T>` in my lib is exposed anyway, it could be used for different purposes).
There might be other anti-patterns I couldn't remember off the top of my head, but the above is the most common mistake. There are a bunch of resources online that discuss this.
This is a pretty common concept for web dev folk (and maybe gamedev?), but I guess it is not for your typical C++ dev
https://redd.it/1ro288e
@r_cpp
peel - C++ bindings generator for GObject-based libraries
https://gitlab.gnome.org/bugaevc/peel
https://redd.it/1rod1sn
@r_cpp
C++ Show and Tell - March 2026
Use this thread to share anything you've written in C++. This includes:
* a tool you've written
* a game you've been working on
* your first non-trivial C++ program
The rules of this thread are very straight forward:
* The project must involve C++ in some way.
* It must be something you (alone or with others) have done.
* Please share a link, if applicable.
* Please post images, if applicable.
If you're working on a C++ library, you can also share new releases or major updates in a dedicated post as before. The line we're drawing is between "written in C++" and "useful for C++ programmers specifically". If you're writing a C++ library or tool for C++ developers, that's something C++ programmers can use and is on-topic for a main submission. It's different if you're just using C++ to implement a generic program that isn't specifically about C++: you're free to share it here, but it wouldn't quite fit as a standalone post.
Last month's thread: https://www.reddit.com/r/cpp/comments/1qvkkfn/c_show_and_tell_february_2026/
https://redd.it/1ri7ept
@r_cpp
Always actual list of the latest C++ related YT videos
https://www.swedencpp.se/videos
https://redd.it/1rhtj5w
@r_cpp
Good, basic* game networking library?
I want to get a simple server-client system up for a multiplayer game, and I've been poking around to find some simple networking implementations but haven't found many. I've used enet itself before but I would like something a little more friendly in terms of usability? I know it's good but something about it is not terribly enjoyable to use for games.
https://redd.it/1rggeut
@r_cpp
[OpenGL C++] 3D Voxel Engine Tutorial
https://youtube.com/playlist?list=PLQ7CpbxNS-_YP1WhUAVmxRQuF_a4PLju_&si=Hq5Jjp2OAv5heZbL
https://redd.it/1rgm7ae
@r_cpp
What makes a game tick? Part 9 - Data Driven Multi-Threading Scheduler · Mathieu Ropert
https://mropert.github.io/2026/02/27/making_games_tick_part9/
https://redd.it/1rgeve1
@r_cpp
Power of C++26 Reflection: Strong (opaque) type definitions
Inspired by a similar [previous thread](https://www.reddit.com/r/cpp/comments/1mwv927/the_power_of_c26_reflection_first_class/) showcasing cool uses for C++26 reflection.
With reflection, you can easily create "opaque" type definitions, i.e "strong types". It works by having an inner value stored, and wrapping over all public member functions.
Note: I am using `queue_injection { ... }` with the EDG experimental reflection, which afaik wasn't actually integrated into the C++26 standard, but without it you would simply need two build stages for codegen. This is also just a proof of concept, some features aren't fully developed (e.g aggregate initialization)
[godbolt](https://godbolt.org/z/8n4r5Ydvz)
struct Item { /* ... */ }; // name, price as methods
struct FoodItem;
struct BookItem;
struct MovieItem;
consteval {
make_strong_typedef(^^FoodItem, ^^Item);
make_strong_typedef(^^BookItem, ^^Item);
make_strong_typedef(^^MovieItem, ^^Item);
}
// Fully distinct types
void display(FoodItem &i) {
std::cout << "Food: " << i.name() << ", " << i.price() << std::endl;
}
void display(BookItem &i) {
std::cout << "Book: " << i.name() << ", " << i.price() << std::endl;
}
int main() {
FoodItem fi("apple", 10); // works if Item constructor isn't marked explicit
FoodItem fi_conversion(Item{"chocolate", 5}); // otherwise
BookItem bi("the art of war", 20);
MovieItem mi("interstellar", 25);
display(fi);
display(bi);
// display(Item{"hello", 1}); // incorrect, missing display(Item&) function
// display(mi); // incorrect, missing display(MovieItem&) function
}
https://redd.it/1rgo4s9
@r_cpp
Real-time Safety — Guaranteed by the Compiler! - Anders Schau Knatten Meeting C++ 2025
https://www.youtube.com/watch?v=4aALnxHt9bU
https://redd.it/1rh0v7u
@r_cpp