-
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
Mathieu Ropert: Learning Graphics Programming with C++
https://youtu.be/vL87j4wup1U
https://redd.it/1qxeohs
@r_cpp
SimpleBLE v0.11.0 - Introducing Peripheral Mode for Linux
Hey everybody, SimpleBLE v0.11.0 is finally live! We focused on making the most versatile Bluetooth library even more useful.
For those who don’t know, SimpleBLE is a cross-platform Bluetooth library with a very simple API that just works, allowing developers to easily integrate it into their projects without much effort, instead of wasting hours and hours on development.
This release mainly focuses on a single big feature for Linux that has been a year in the making: BLE Peripheral support.
This means your Linux machine can now:
• Advertise as a BLE device
• Expose GATT services and characteristics
• Act as a complete peripheral
Why does this matter?
If you thought using Central roles with the native Bluetooth stacks was hard, Peripheral takes this to a whole new level. It took us a very long time to find the right data representations that could abstract this problem away cleanly, but we’ve finally reached a point we feel comfortable sharing with a wider audience.
This barrier is now gone, and with it a whole new world of possibilities opens up: Building custom peripheral applications, device emulators or hardware mocks, all without any extra hardware. I’m excited to see what new ideas come to life based on this new capability.
You can find our Peripheral-specific examples here and here. Things might still break or change as we improve it and work towards a generalized API for all other OSes, but should be good enough to start validating ideas. We’d love to hear about your experience!
Want to know more about SimpleBLE's capabilities or see what others are building with it? Ask away!
https://redd.it/1qxbvyi
@r_cpp
P1689's current status is blocking module adoption and implementation - how should this work?
There is a significant "clash of philosophies" regarding Header Units in the standard proposal for module dependency scanning P1689 (it's not standard yet because it doesn't belong to the language standard and the whole ecosystem is thrown to trash by now but it's de facto) that seems to be a major blocker for universal tooling support.
# The Problem
When scanning a file that uses header units, how should the dependency graph be constructed? Consider this scenario:
// a.hh
import "b.hh";
// b.hh
// (whatever)
// c.cc
import "a.hh";
When we scan c.cc, what should the scanner output?
Option 1: The "Module" Model (Opaque/Non-transitive) The scanner reports that c.cc requires a.hh. It stops there. The build system is then responsible for scanning a.hh separately to discover it needs b.hh.
Rationale: This treats a header unit exactly like a named module. It keeps the build DAG clean and follows the logic that `import` is an encapsulated dependency.
Option 2: The "Header" Model (Transitive/Include-like) The scanner resolves the whole tree and reports that `c.cc` requires both `a.hh` and `b.hh`.
Rationale: Header units are still headers. They can export macros and preprocessor state. Importing a.hh is semantically similar to including it, so the scanner should resolve everything as early as possible (most likely using traditional -I paths), or the impact on the importing translation unit is not clear.
# Current Implementation Chaos
Right now, the "Big Three" are all over the place, making it impossible to write a universal build rule:
1. Clang (clang-scan-deps): Currently lacks support for header unit scanning.
2. GCC (-M -Mmodules): It essentially deadlocks. It aborts if the Compiled Module Interface (CMI) of the imported header unit isn't already there. But we are scanning specifically to find out what we need to build!
3. MSVC: Follows Option 2. It resolves and reports every level of header units using traditional include-style lookup and aborts if the physical header files cannot be found.
# The Two Core Questions
1. What is the scanning strategy? Should import "a.hh" be an opaque entry as it is in the DAG, or should the scanner be forced to look through it to find b.hh?
2. Looking-up-wise, is import "header" a fancy #include or a module?
If it's a fancy include: Compilers should use `-I` (include paths) to resolve them during the scan. Then we think of other ways to consume their CMIs during the compilation.
If it's a module: They should be found via module-mapping mechanics (like MSVC's /reference or GCC's module mapper).
# Why this matters
We can't have a universal dependency scanning format (P1689) if every compiler requires a different set of filesystem preconditions to successfully scan a file, or if each of them has their own philosophy for scanning things.
If you are a build system maintainer or a compiler dev, how do you see this being resolved? Should header units be forced into the "Module" mold for the sake of implementation clarity, or must we accept that they are "Legacy+" and require full textual resolution?
I'd love to hear some thoughts before this (hopefully) gets addressed in a future revision of the proposal.
https://redd.it/1qx7zex
@r_cpp
C++ Podcasts & Conference Talks (week 6, 2025)
Hi r/cpp! Welcome to another post in this series. Below, you'll find all the C++ conference talks and podcasts published in the last 7 days.
Before we start, apologies for the last week where my compilation included talks irrelevant to C++. I'll make sure to do my due diligence before posting here.
# 📺 Conference talks
# CppCon 2025
1. **"Compiler Explorer: The Features You Never Knew Existed - Matt Godbolt - CppCon 2025"** ⸱ +11k views ⸱ 30 Jan 2026 ⸱ 01h 00m 08s
2. **"Networks in C++ - What's Actually Changing? - Ignas Bagdonas - CppCon 2025"** ⸱ +4k views ⸱ 29 Jan 2026 ⸱ 01h 12m 42s
3. **"Mastering the Code Review Process - Pete Muldoon - CppCon 2025"** ⸱ +3k views ⸱ 28 Jan 2026 ⸱ 01h 08m 34s
4. **"Connecting C++ Tools to AI Agents Using the Model Context Protocol (MCP) - Ben McMorran - CppCon"** ⸱ +1k views ⸱ 02 Feb 2026 ⸱ 00h 29m 32s
5. **"The Truth About Being a Programmer CEO - Greg Law - CppCon 2025"** ⸱ +600 views ⸱ 03 Feb 2026 ⸱ 01h 24m 02s
# Meeting C++ 2025
1. **"Speed for Free - current state of auto vectorizing compilers - Stefan Fuhrmann - Meeting C++ 2025"** ⸱ +700 views ⸱ 31 Jan 2026 ⸱ 00h 42m 02s
This post is an excerpt from the latest issue of ***Tech Talks Weekly*** which is a free weekly email with all the recently published Software Engineering and Development conference talks & podcasts. Currently subscribed by +8,200 Software Engineers who stopped scrolling through messy YouTube subscriptions and reduced FOMO. Consider subscribing if this sounds useful: *https://www.techtalksweekly.io/*
Let me know what you think. Thank you!
https://redd.it/1qwp1a8
@r_cpp
Feedback wanted: C++20 tensor library with NumPy-inspired API
I've been working on a tensor library and would appreciate feedback from people who actually know C++ well.
**What it is:** A tensor library targeting the NumPy/PyTorch mental model - shape broadcasting, views via strides, operator overloading, etc.
**Technical choices I made:**
* C++20 (concepts, ranges where appropriate)
* xsimd for portable SIMD across architectures
* Variant-based dtype system instead of templates everywhere
* Copy-on-write with shared\_ptr storage
**Things I'm uncertain about:**
* Is the Operation registry pattern overkill? It dispatches by OpType enum + Device
* Using std::variant for axis elements in einops parsing - should this be inheritance?
* The BLAS backend abstraction feels clunky
* Does Axiom actually seem useful?
* What features might make you use it over something like Eigen?
It started because I wanted NumPy's API but needed to deploy on edge devices without Python. Ended up going deeper than expected (28k LOC+) into BLAS backends, memory views, and GPU kernels.
Github: [https://github.com/frikallo/axiom](https://github.com/frikallo/axiom)
Would so appreciate feedback from anyone interested! Happy to answer questions about the implementation.
https://redd.it/1qu3acu
@r_cpp
Flavours of Reflection
https://semantics.bernardteo.me/2026/01/30/flavours-of-reflection.html
https://redd.it/1qtzsxa
@r_cpp
C++ & CUDA reimplementation of StreamDiffusion
https://github.com/jcelerier/librediffusion
https://redd.it/1qvbv1j
@r_cpp
capabilities. This is an area of active development, but I plan to release a working prototype soon.
https://redd.it/1quxak5
@r_cpp
([docs](https://www.fleetcode.com/oss/tmc/docs/v1.4/executors/ex_cpu.html#hybrid-work-steering))([example](https://github.com/tzcnt/tmc-examples/blob/44ce66de8e74107c803645c82ddd88a7be35fd29/examples/hwloc/hybrid_executor.cpp)) Implement work steering for P- and E- cores on hybrid chips (e.g. Intel Hybrid / ARM big.LITTLE). Apple M / MacOS is also supported by setting the QoS class.
* ([example](https://github.com/tzcnt/tmc-examples/blob/44ce66de8e74107c803645c82ddd88a7be35fd29/examples/hwloc/asio_thread_per_core.cpp)) Turn Asio into a thread-per-core, share-nothing executor
* ([example](https://github.com/tzcnt/tmc-examples/blob/44ce66de8e74107c803645c82ddd88a7be35fd29/examples/hwloc/asio_server_per_cache.cpp)) Create an Asio thread *and* a worker thread pool for each chiplet in the system, that communicate exclusively within the same cache. This lets you scale both I/O and compute without cross-cache latency.
# Killer Features, Round 2
TooManyCooks offers several other features that others do not:
* ([docs](https://fleetcode.com/oss/tmc/docs/v1.4/halo/index.html)) ([example](https://github.com/tzcnt/tmc-examples/blob/44ce66de8e74107c803645c82ddd88a7be35fd29/tests/test_halo.cpp)) support for the only working HALO implementation ([Clang attributes](https://clang.llvm.org/docs/AttributeReference.html#coro-await-elidable))
* ([docs](https://www.fleetcode.com/oss/tmc/docs/v1.4/type_traits.html)) type traits to let you write generic code that handles values, awaitables, tasks, and functors
* ([docs](https://www.fleetcode.com/oss/tmc/docs/v1.4/priority.html)) support for multiple priority levels, as well as executor and priority affinity, are integrated throughout the library
* ([example](https://github.com/tzcnt/tmc-examples/blob/44ce66de8e74107c803645c82ddd88a7be35fd29/examples/asio/http_server.cpp)) seamless Asio integration
# Mundane Feature Parity
TooManyCooks also aims to offer feature parity with the usual things that other libraries do:
* ([docs](https://www.fleetcode.com/oss/tmc/docs/v1.4/executors/index.html)) various executor types
* ([docs](https://www.fleetcode.com/oss/tmc/docs/v1.4/awaitables/index.html)) various ways to fork/join tasks
* ([docs](https://www.fleetcode.com/oss/tmc/docs/v1.4/data_structures/channel.html)) async data structures (tmc::channel)
* ([docs](https://www.fleetcode.com/oss/tmc/docs/v1.4/control_structures/index.html)) async control structures (tmc::mutex, tmc::semaphore, etc)
# Designed for Brownfield Development
TooManyCooks has a number of features that will allow you to slowly introduce coroutines/task-based concurrency into an existing codebase without needing a full rewrite:
* ([docs](https://fleetcode.com/oss/tmc/docs/v1.4/awaitables/fork_group.html)) flexible awaitables like `tmc::fork_group` allow you to limit the virality of coroutines - only the outermost (awaiting) and innermost (parallel/async) function actually need to be coroutines. Everything in the middle of the stack can stay as a regular function.
* global executor handles (`tmc::cpu_executor()`, `tmc::asio_executor()`) and the `tmc::set_default_executor()` function let you initiate work from anywhere in your codebase
* ([docs](https://fleetcode.com/oss/tmc/docs/v1.4/executors/ex_manual_st.html)) a manual executor lets you run work from inside of another event loop at a specific time
* ([docs](https://fleetcode.com/oss/tmc/docs/v1.4/integration/external_awaitables.html#default-behavior-it-just-works)) ([example](https://github.com/tzcnt/tmc-examples/blob/44ce66de8e74107c803645c82ddd88a7be35fd29/examples/external/external_awaitable.cpp)) foreign awaitables are automatically wrapped to maintain executor and priority affinity
* ([docs](https://fleetcode.com/oss/tmc/docs/v1.4/integration/external_awaitables.html#fully-integrating)) ([example](https://github.com/tzcnt/tmc-examples/blob/44ce66de8e74107c803645c82ddd88a7be35fd29/examples/external/callback_awaitable.hpp#L157)) or you can specialize `tmc::detail::awaitable_traits` to fully integrate an external awaitable
*
C++ Show and Tell - February 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/1q3m9n1/c_show_and_tell_january_2026/
https://redd.it/1qvkkfn
@r_cpp
Unable to run C++ in VS Code even after installing MinGW/MSYS — really stuck
Hi everyone,
For the past 2–3 days, I’ve been trying to run C++ programs in VS Code, but it’s just not working.
I installed MinGW, also set up MSYS, and checked the environment PATH variables carefully. Everything seems correct, but C++ still refuses to run. I even uninstalled and reinstalled MinGW, but the problem remains.
I’m honestly very frustrated at this point and not sure what I’m missing.
If anyone has faced a similar issue or knows how to fix this, please help me out. I would really appreciate it.
Thank you!
https://redd.it/1qstpqs
@r_cpp
Want to design a Washing Machine SImulator, and it's HLD, LLD, Design, code in C++ and stress tests.
I am trying to build a C++ consumer washing machine with realistic state transitions, safety interlocks, and usability modes. The simulator will be used to validate logic, concurrency handling, and event-driven control flow without physical hardware
as this asked in interview and nothing is available on internet.
https://redd.it/1qrvqfm
@r_cpp
Assign](https://tea-age.solutions/teascript/teascript-language-documentation/#copy_assign_vs_shared_assign_operators)
TeaScript also has a Host Application which can be used to execute standalone TeaScript files, run a REPL or helps with debugging script code. The host application is also Open Source but actually not part of the repository above. You find precompiled packages here (source code included): [https://tea-age.solutions/teascript/downloads/](https://tea-age.solutions/teascript/downloads/)
**Some final thoughts**
Personally, I am really impressed what is now already possible with just C++20 and the help of reflectcpp. I hope, this makes TeaScript more interesting and usable for embed it in C++ Applications.
Can't wait to have C++26 compilers available!
Happy coding! :-)
https://redd.it/1qr98nv
@r_cpp
Parallel C++ for Scientific Applications: Data Parallelism (2nd Part)
https://www.youtube.com/watch?v=5RaeKdiYxuA
https://redd.it/1qrb899
@r_cpp
Concept-based Generic Programming - Bjarne Stroustrup - CppCon 2025
https://www.youtube.com/watch?v=VMGB75hsDQo
https://redd.it/1qr7z1o
@r_cpp
cppfront
I don't think https://github.com/hsutter/cppfront gets much attention. What do people think of it?
It solves so much of the mess in C++. As far as I can see, only threading still needs to be solved to be comparable to Rust?
Maybe that could be solved by a method similar to Google's thread annotation, just built-in instead of macros?
https://redd.it/1qxc1ns
@r_cpp
Try this Quiz! https://cppquiz.org/quiz/question/1
CppQuiz.org - Question #1
Comment your score below
https://redd.it/1qx997s
@r_cpp
A little clarity on FP needed
My intention is not to start a OO vs FP argument. I honestly feel like my experience has a void in it and I need to improve my understanding of some things.
I am traditionally OO and any time FP comes up and people debate the two, I usually only hear about deep inheritance trees as the sole premise. That was never enough to convince me to throw out all the bath water with the baby. In my mind, I can be OO, do SOLID, use RAII, and never inherit more than 1 interface, if I want to.
Failing to get any reasonable explanation from my peers, I started doing some research and I finally came across something that started to make sense to me.
The response was: "FP is becoming more popular because of distributed systems and how CPUs can no longer get faster, but add more cores. Therefore, we are doing a lot more where concurrency matters. In FP there is an idealogy to deal with 'pure functions' that act on immutable data, and create new data or events instead of mutate state within classes."
Well, that sounds good to me. So, I wanted to explore some examples. Person/Order, User/Logins, etc. I noticed in the examples, collections like a vector would be passed as a parameter by value and then a new vector would be returned.
Now, I admittedly don't know FP from my foot, but I'd like to understand it.
Is immutability carried to that extreme? Copying a big collection of data is expensive, after all.
I then got debate on how move semantics help, but couldn't get any examples to look at that did not have a copy, since after all, we are trying to deal with immutable data.
Is this legit FP?
struct Item {
ProductId productId;
int quantity;
};
struct Order {
OrderId id;
std::vector<Item> items;
};
Order addItemToOrder(const Order& order, Item item) {
Order newOrder = order;
newOrder.items.pushback(item);
return newOrder;
}
or would you
Order addItemToOrder(const Order& order, Item item) {
Order newOrder;
newOrder.id = order.id;
newOrder.items = order.items;
newOrder.items.pushback(item);
return newOrder;
}
Both of these seem to have a copy of the vector, and I'd imagine that would be a lot of performance cost for an idealogy, no?
I then got a response where they said to use a shared_ptr for the items in the order and add to it as needed, but then we are mutating a struct, so what's did we gain from using a class with methods to add items to an order object?
Is the reality we just have to be smart and drop carrying a ideal of keeping things immutable when the performance cost would be large? Or do the examples stink? Could you help solidify the FP way of doing things with orders and items in a system, where the person is adding items to the order and the entire order needs to be submitted to a db when they checkout?
https://redd.it/1qx6m0o
@r_cpp
New C++ Conference Videos Released This Month - February 2026
**CppCon**
2026-01-26 - 2026-02-01
* Using Floating-point in C++: What Works, What Breaks, and Why - Egor Suvorov - [https://youtu.be/m83TjrB6wYw](https://youtu.be/m83TjrB6wYw)
* Cross-Platform Package Management for Modern C++ Development with Pixi - Ruben Arts - [https://youtu.be/SQk0lKv2swk](https://youtu.be/SQk0lKv2swk)
* Mastering the Code Review Process - Pete Muldoon - [https://youtu.be/6a3CNRMssQE](https://youtu.be/6a3CNRMssQE)
* Networks in C++ - What's Actually Changing? - Ignas Bagdonas - [https://youtu.be/dVSCMJlHXQM](https://youtu.be/dVSCMJlHXQM)
* Compiler Explorer: The Features You Never Knew Existed - Matt Godbolt - [https://youtu.be/3W0vE\_VKokY](https://youtu.be/3W0vE_VKokY)
**ADC**
2026-01-26 - 2026-02-01
* Minimalistic Music Composition with C++ - Xyzzy - ADCx Gather 2025 - [https://youtu.be/9x49IxlrkqI](https://youtu.be/9x49IxlrkqI)
* The Real Waveform Matters - The Samples Are Not Always What They Seem - Jamie Angus-Whiteoak - ADC 2025 - [https://youtu.be/8eEWK6Fez8c](https://youtu.be/8eEWK6Fez8c)
**Meeting C++**
2026-01-26 - 2026-02-01
* Purging undefined behavior and Intel assumptions in Legacy Codebases - Roth Michaels - [https://www.youtube.com/watch?v=b7SZdhrEsic](https://www.youtube.com/watch?v=b7SZdhrEsic)
* 25+ years of pathfinding problems with C++ - Raymi Klingers - [https://www.youtube.com/watch?v=lEBQveBCtKY](https://www.youtube.com/watch?v=lEBQveBCtKY)
* Speed for Free - current state of auto vectorizing compilers - Stefan Fuhrmann - [https://www.youtube.com/watch?v=m2vVWkFsrM0](https://www.youtube.com/watch?v=m2vVWkFsrM0)
**ACCU Conference**
2026-01-26 - 2026-02-01
* The Beman Project: Testing C++ Library Proposals Before Standardization - Dietmar Kühl - ACCU 2025 Short Talks - [https://youtu.be/wXQE\_Upqbms](https://youtu.be/wXQE_Upqbms)
* A Sixth Seam in TDD? - Python Testing, Test Doubles & Legacy Code at Kosli - Jon Jagger - ACCU 2025 Short Talks - [https://youtu.be/62EltmSbqro](https://youtu.be/62EltmSbqro)
* What, What? - When We Think We Understand - Nara Morrison - ACCU 2025 Short Talks - [https://youtu.be/W0vAsaL\_svY](https://youtu.be/W0vAsaL_svY)
https://redd.it/1qtznyb
@r_cpp
Silent foe or quiet ally: Brief guide to alignment in C++. Part 2
https://pvs-studio.com/en/blog/posts/cpp/1340/
https://redd.it/1qul1u6
@r_cpp
A Faster WBT/SBT Implementation Than Linux RBT
https://typecombinator.github.io/en/posts/top\_down\_weight\_balanced\_tree
https://redd.it/1qunnpw
@r_cpp
Claude Code MCP server mcp-cpp-server broken after Claude Code 2.1.28+ update
Hey everyone,
If you use **mcp-cpp-server** (the Rust-based MCP server for C++ code analysis via clangd) with **Claude Code**, it silently breaks after updating Claude Code to 2.1.28+.
`claude mcp list` shows the server as "Failed to connect" with no useful error. After digging through stderr logs, the actual error is:
```
Incompatible protocol version: client: 2025-11-25 server: 2025-06-18
```
**What happened:** Claude Code 2.1.28 switched to MCP protocol version `2025-11-25`, but `mcp-cpp-server` v0.2.2 uses `rust-mcp-sdk` 0.7.4 which only speaks protocol `2025-06-18`. The server starts fine but Claude rejects the handshake.
**The fix:** Upgrade `rust-mcp-sdk` from 0.7 to 0.8 in Cargo.toml, plus a few API changes the new SDK requires:
\- `Implementation` struct needs new fields (`description`, `icons`, `website_url`)
\- `create_server()` now takes a `McpServerOptions` struct instead of positional args
\- `handle_list_tools_request` / `handle_call_tool_request` signatures changed
\- Handler conversion uses `.to_mcp_server_handler()` now
I've submitted **PR #12** upstream: https://github.com/mpsm/mcp-cpp/pull/12
**To use it now** (before the PR merges):
```bash
git clone https://github.com/ninokth/mcp-cpp.git
cd mcp-cpp
git checkout fix/sdk-0.8-upgrade
cargo build --release
cp target/release/mcp-cpp-server \~/.cargo/bin/
```
After that, `claude mcp list` should show `cpp: Connected` and all three tools (`search_symbols`, `analyze_symbol_context`, `get_project_details`) work again.
Hope this helps anyone else who hit this wall.
https://redd.it/1qwg9zy
@r_cpp
([docs](https://fleetcode.com/oss/tmc/docs/v1.4/integration/external_executors.html#fully-integrating)) ([example](https://github.com/tzcnt/tmc-examples/blob/44ce66de8e74107c803645c82ddd88a7be35fd29/examples/external/external_executor.cpp#L68)) specialize `tmc::detail::executor_traits` to integrate an external executor
* ([example](https://github.com/tzcnt/tmc-examples/blob/44ce66de8e74107c803645c82ddd88a7be35fd29/examples/external/callback_awaitable.hpp)) you can even turn a C-style callback API into a TooManyCooks awaitable!
# Designed for Beginners and Experts Alike
TooManyCooks wants to be a library that you'll choose first because it's easy to use, but you won't regret choosing later (because it's also very powerful).
To start, it offers the simplest possible syntax for awaitable operations, and requires almost no boilerplate. To achieve this, sane defaults have been chosen for the most common behavior. However, you can also customize almost everything using fluent APIs, which let you orchestrate complex task graphs across multiple executors with ease.
TooManyCooks attempts to emulate linear types (it expects that most awaitables are awaited exactly once) via a combination of \[\[nodiscard\]\] attributes, rvalue-qualified operations, and debug asserts. This gives you as much feedback as possible at compile time to help you avoid lifetime issues and create correct programs.
There is carefully maintained [documentation](https://www.fleetcode.com/oss/tmc/docs/v1.4/quick_start.html) as well as an extensive suite of [examples and tests](https://github.com/tzcnt/tmc-examples) that offer code samples for you to draw from.
# Q&A
# Is this AI slop? Why haven't I heard of this before?
I've been building in public since 2023 and have invested thousands of man-hours into the project. AI was never used on the project prior to version 1.1. Since then I've used it mostly as a reviewer to help me identify issues. It's been a net positive to the quality of the implementation.
This announcement is well overdue. I could have just "shipped it" many months ago, but I'm a perfectionist and prefer to write code rather than advertise. This has definitely caused me to miss out on "first-mover advantage". However, at this point I'm convinced the project is world-class so I feel compelled to share.
# The name is stupid.
That's not a question, but I'll take it anyway. The name refers to the phrase "too many cooks in the kitchen", which I feel is a good metaphor for all the ways things can go wrong in a multithreaded, asynchronous system. Blocking, mutex contention, cache thrashing, and false sharing can all kill your performance, in the same way as two cooks trying to use the same knife. TooManyCooks's structured concurrency primitives and lock-free internals let you ensure that your cooks get the food out the door on time, even under dynamically changing, complex workloads.
# Will this support Sender/Receiver?
Yes, I plan to make it S/R compatible. It already supports core concepts such as [scheduler affinity](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3552r3.html#scheduler-affinity) so I expect this will not be a heavy lift.
# Are C++20 coroutines ready for prime time?
In my opinion, there were 4 major blockers to coroutine usability. TooManyCooks offers solutions for all of them:
* Compiler implementation correctness - This is largely solved.
* Library maturity - TooManyCooks aims to solve this.
* HALO - Clang's [attributes](https://clang.llvm.org/docs/AttributeReference.html#coro-await-elidable) are the only implementation that actually works. TooManyCooks fully supports this, and it applies consistently ([docs](https://fleetcode.com/oss/tmc/docs/v1.4/halo/index.html)) ([example](https://github.com/tzcnt/tmc-examples/blob/44ce66de8e74107c803645c82ddd88a7be35fd29/tests/test_halo.cpp)) when the prerequisites are met.
* Debugger integration - LLDB has recently merged support for SyntheticFrameProviders which allow reconstructing the async backtrace in the debugger. GDB also offers a Frame Filter API with similar
Announcing TooManyCooks: the C++20 coroutine framework with no compromises
[TooManyCooks](https://github.com/tzcnt/TooManyCooks) aims to be the fastest general-purpose C++20 coroutine framework, while offering unparalleled developer ergonomics and flexibility. It's suitable for a variety of applications, such as game engines, interactive desktop apps, backend services, data pipelines, and (consumer-grade) trading bots.
It competes directly with the following libraries:
* tasking libraries: libfork, oneTBB, Taskflow
* coroutine libraries: cppcoro, libcoro, concurrencpp
* asio wrappers: boost::cobalt (via [tmc-asio](https://github.com/tzcnt/tmc-asio))
# TooManyCooks is Fast (Really)
I maintain a comprehensive suite of benchmarks for competing libraries. You can view them here: ([benchmarks repo](https://github.com/tzcnt/runtime-benchmarks)) ([interactive results chart](https://fleetcode.com/runtime-benchmarks/))
TooManyCooks beats every other library (except libfork) across a wide variety of hardware. I achieved this with cache-aware work-stealing, lock-free concurrency, and many hours of obsessive optimization.
TooManyCooks also doesn't make use of any ugly performance hacks like busy spinning ([unless](https://www.fleetcode.com/oss/tmc/docs/v1.4/executors/ex_cpu.html#_CPPv4N3tmc6ex_cpu9set_spinsE6size_t) you [ask it to](https://www.fleetcode.com/oss/tmc/docs/v1.4/data_structures/channel.html#_CPPv4N3tmc8chan_tok18set_consumer_spinsE6size_t)), so it respects your laptop battery life.
# What about libfork?
I want to briefly address libfork, since it is typically the fastest library when it comes to fork/join performance. However, it is arguably not "general-purpose":
* ([link](https://github.com/ConorWilliams/libfork?tab=readme-ov-file#-welcome-to-libfork--)) it requires arcane syntax (as a necessity due to its implementation)
* it requires every coroutine to be a template, slowing compile time and creating bloat
* limited flexibility w.r.t. task lifetimes
* no I/O, and no other features
Most of its performance advantage comes from its custom allocator. The recursive nature of the benchmarks prevents HALO from happening, but in typical applications (if you use Clang) HALO will kick in and prevent these allocations entirely, negating this advantage.
TooManyCooks offers the best performance possible without making any usability sacrifices.
# Killer Feature #1 - CPU Topology Detection
As every major CPU manufacturer is now exploring disaggregated / hybrid architectures, legacy work-stealing designs are showing their age. TooManyCooks is designed for this new era of hardware.
It uses the CPU topology information exposed by the [libhwloc](https://www.open-mpi.org/projects/hwloc/) library to implement the following automatic behaviors:
* ([docs](https://www.fleetcode.com/oss/tmc/docs/v1.4/executors/ex_cpu.html#hardware-optimized-defaults)) locality-aware work stealing for disaggregated caches (e.g. Zen chiplet architecture).
* ([docs](https://www.fleetcode.com/oss/tmc/docs/v1.4/executors/topology.html#_CPPv4N3tmc8topology12cpu_topology19container_cpu_quotaE)) Linux cgroups detection sets the number of threads according to the CPU quota when running in a container
* If the CPU quota is set instead by selecting specific cores (`--cpuset-cpus`) or with [Kubernetes Guaranteed QoS](https://docs.starlingx.io/r/stx.6.0/usertasks/kubernetes/using-kubernetes-cpu-manager-static-policy.html), the hwloc integration will detect the allowed cores (and their cache hierarchy!) and create locality-aware work stealing groups as if running on bare metal.
Additionally, the topology can be queried by the user ([docs](https://www.fleetcode.com/oss/tmc/docs/v1.4/executors/topology.html)) ([example](https://github.com/tzcnt/tmc-examples/blob/44ce66de8e74107c803645c82ddd88a7be35fd29/examples/hwloc/topo.cpp)) and APIs are provided that let you do powerful things:
*
Harald Achitz: About Generator, Ranges, and Simplicity
https://youtu.be/Bdwh4u4xF_o
https://redd.it/1qsu5nd
@r_cpp
Why doesn't std::atomic support multiplication, division, and mod?
I looked online, and the only answer I could find was that no architectures support them. Ok, I guess that makes sense. However, I noticed that clang targeting x86_64 lowers std::atomic<float>::fetch_add as this as copied from Compiler Explorer,source:'%23include+%3Catomic%3E%0A%0Aauto+fetchaddtest(std::atomic%3Cfloat%3E%26+atomic,+float+rhs)+-%3E+void+%7B%0A++++atomic.fetchadd(rhs)%3B%0A%7D%0A'),l:'5',n:'0',o:'C%2B%2B+source+%231',t:'0')),k:37.75456919060052,l:'4',n:'0',o:'',s:0,t:'0'),(g:!((g:!((h:ir,i:('-fno-discard-value-names':'0',compilerName:'x86-64+clang+(trunk)',demangle-symbols:'0',editorid:1,filter-attributes:'0',filter-comments:'0',filter-debug-info:'0',filter-instruction-metadata:'0',fontScale:12,fontUsePx:'0',j:1,selection:(endColumn:1,endLineNumber:1,positionColumn:1,positionLineNumber:1,selectionStartColumn:1,selectionStartLineNumber:1,startColumn:1,startLineNumber:1),show-optimized:'0',treeid:0,wrap:'1'),l:'5',n:'0',o:'LLVM+IR+Viewer+x86-64+clang+(trunk)+(Editor+%231,+Compiler+%231)',t:'0')),header:(),k:58.110236220472444,l:'4',m:83.92484342379957,n:'0',o:'',s:0,t:'0'),(g:!((g:!((h:compiler,i:(compiler:clangtrunk,filters:(b:'0',binary:'1',binaryObject:'1',commentOnly:'0',debugCalls:'1',demangle:'0',directives:'0',execute:'1',intel:'0',libraryCode:'1',trim:'0',verboseDemangling:'0'),flagsViewOpen:'1',fontScale:12,fontUsePx:'0',j:1,lang:c%2B%2B,libs:!(),options:'-O3+-std%3Dc%2B%2B26',overrides:!(),selection:(endColumn:1,endLineNumber:1,positionColumn:1,positionLineNumber:1,selectionStartColumn:1,selectionStartLineNumber:1,startColumn:1,startLineNumber:1),source:1),l:'5',n:'0',o:'+x86-64+clang+(trunk)+(Editor+%231)',t:'0')),header:(),k:46.736824930657534,l:'4',m:74.47698744769873,n:'0',o:'',s:0,t:'0'),(g:!((h:output,i:(compilerName:'x64+msvc+v19.latest',editorid:1,fontScale:12,fontUsePx:'0',j:1,wrap:'1'),l:'5',n:'0',o:'Output+of+x86-64+clang+(trunk)+(Compiler+%231)',t:'0')),header:(),l:'4',m:25.52301255230126,n:'0',o:'',s:0,t:'0')),k:41.889763779527556,l:'3',n:'0',o:'',t:'0')),k:62.24543080939948,l:'2',m:100,n:'0',o:'',t:'0')),l:'2',n:'0',o:'',t:'0')),version:4):
fetchaddtest(std::atomic<float>&, float):
movd xmm1, dword ptr rdi
.LBB01:
movd eax, xmm1
addss xmm1, xmm0
movd ecx, xmm1
lock cmpxchg dword ptr [rdi], ecx
movd xmm1, eax
jne .LBB01
ret
It's my understanding that this is something like the following:
auto std::atomic<float>::fetchadd(float arg) -> float {
float oldvalue = this->load();
while(this->compareexchangeweak(oldvalue, expected + arg) == false){}
return oldvalue;
}
I checked GCC and MSVC too, and they all do the same. So my question is this: assuming there isn't something I'm misunderstanding, if the standard already has methods that do the operation not wait-free on x86, why not add the rest of the operations?
I also found that apparently Microsoft added them for their implementation of C11_Atomic according to this 2022 blog post.
https://redd.it/1qsf6pa
@r_cpp
Recognizing stop_token as a General-Purpose Signaling Mechanism
https://www.vinniefalco.com/p/recognizing-stop_token-as-a-general
https://redd.it/1qro8rg
@r_cpp
TeaScript meets reflectcpp: Reflect C++ structs into and back from TeaScript
TeaScript is a modern multi-paradigm scripting language, realized and available as a C++20 Library, which can be embedded in C++ Applications.
The main branch ([https://github.com/Florian-Thake/TeaScript-Cpp-Library](https://github.com/Florian-Thake/TeaScript-Cpp-Library)) contains now a reflection feature as a preview. *(note: The last release 0.16.0 does not contain it yet, use the main branch head.).* The feature is optional and has the [reflectcpp](https://github.com/getml/reflect-cpp) library ad dependency. Instructions are in the example code [reflectcpp\_demo.cpp](https://github.com/Florian-Thake/TeaScript-Cpp-Library/blob/main/demo/reflectcpp_demo.cpp).
With that, you can reflect C++ structs without macros, without registration and without any other prerequisites directly into TeaScript like this
**Example**
Imagine you have the following C++ struct and instance:
// some C++ struct (note the self reference in children)
struct Person
{
std::string first_name;
std::string last_name;
int age{0};
std::vector<Person> children;
};
// create an example instance of the C++ struct.
auto homer = Person{.first_name = "Homer",
.last_name = "Simpson",
.age = 45};
homer.children.emplace_back( Person{"Maggie", "Simpson", 1} );
homer.children.emplace_back( Person{"Bart", "Simpson", 10} );
If you want to use a copy of homer in TeaScript you can reflect it in without macros, registration or other prerequisites like this:
// create the default teascript engine.
teascript::Engine engine;
// import the C++ struct instance into TeaScript.
teascript::reflect::into_teascript( engine, "homer", homer );
// nothing more to do, thats all!
Now, within TeaScript we can use 'homer' *(note: This is TeaScript code, not C++)*:
tuple_print( homer, "homer", 10 ) // prints all (nested) elements with name and value
// access some fields
homer.first_name // "Homer"
homer.age // 45
homer["last_name"] // "Simpson" (alternative way of accessing elements by key; by index and ."key name" is also possible)
homer.children[0].first_name // "Maggie"
homer.children[1].first_name // "Bart"
// NOW modifying it by adding Lisa as a child
_tuple_append( homer.children, _tuple_named_create( ("first_name", "Lisa"), ("last_name", "Simpson"), ("age", 8), ("children", json_make_array() ) ) )
// create a shared reference to Lisa
def lisa @= homer.children[2]
Now we can reflect Lisa back into a new C++ Person struct instance via this code:
// exporting from TeaScript into a new C++ struct instance!
// !!!
Person lisa = teascript::reflect::from_teascript<Person>( engine, "lisa" );
// !!! - Thats all !
Use lisa in C++ freely now. This is possible in **C++20** with the current supported minimum compiler versions VS 2022, g++11 and clang-14.
The C++ structs and its members are imported as TeaScript's Tuples.
You can learn more about them in 2 release blog posts as they got published / extended: Tuple / Named Tuple: [Part I](https://tea-age.solutions/2023/03/10/release-of-teascript-0-10-0/), [Part II](https://tea-age.solutions/2023/12/11/release-of-teascript-0-11-0/)
**Some key features of TeaScript**
* [Json Support](https://tea-age.solutions/2024/09/01/release-of-teascript-0-15-0/#json_support)
* [Coroutine like usage](https://tea-age.solutions/2024/05/15/release-of-teascript-0-14-0/#coroutine_like_execution)
* [Bidirectional interoperability](https://tea-age.solutions/teascript/overview-and-highlights/#bidirectional_interoperability)
* [Web Server / Client](https://tea-age.solutions/2024/09/01/release-of-teascript-0-15-0/#web_client_server_preview)
* [Uniform Definition Syntax](https://tea-age.solutions/teascript/teascript-language-documentation/#uniform_definition_syntax_and_lambdas)
* [Copy Assign VS Shared
State of C++ 2026
https://devnewsletter.com/p/state-of-cpp-2026/
https://redd.it/1qr84ba
@r_cpp
Audio Developer Conference will take place from the 9th – 11th November both in Bristol, UK & Online! Find out more at [https://audio.dev/adc-bristol-26-3/](https://audio.dev/adc-bristol-26-3/)
* **(NEW) ADC 2025 YouTube Videos Start Releasing This Week** – Subscribe to the ADC YouTube Channel to ensure you are notified when new videos are released! [audiodevcon" rel="nofollow">https://www.youtube.com/@audiodevcon](audiodevcon" rel="nofollow">https://www.youtube.com/@audiodevcon)
https://redd.it/1qqekxc
@r_cpp