-
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
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
Am I the only one who feels like header files in C/C++ are duplication?
We declare things in headers, define them in source, keep them in sync manually, sprinkle include guards everywhere... all to prevent problems caused by the very system we are forced to use. It's like writing code to defend against the language's file model rather than solving actual problems.
And include guards especially - why is "dont include the same header twice" something every project has to re-implement manually? Why isn't that just the compiler's default behavior? Who is intentionally including the same header multiple times and thinking "yes, this is good design"?
It feels like a historical artifact that never got replaced. Other languages let the compiler understand structure directly, but here we maintain parallel representations of the same interface.
Why can't modern C++ just:
treat headers as implicitly guarded, and maybe
auto-generate interface declarations from source files?
https://redd.it/1rgyeqp
@r_cpp
Serialization by contract and IPC
https://github.com/amarmer/SerializationByContract
https://redd.it/1rb2yes
@r_cpp
Apache Fory C++: Fast Serialization with Shared/Circular Reference Tracking, Polymorphism, Schema Evolutionn and up to 12x Faster Than Protobuf
We just released Apache Fory Serialization support for c++:
https://fory.apache.org/blog/fory\_cpp\_blazing\_fast\_serialization\_framework
Highlights:
1. Automatic idiomatic cross-language serializaton: no adapter layer, serialize in C++, deserialize in Python.
2. Polymorphism via smart pointers: Fory detects std::is_polymorphic<T> automatically. Serialize through a shared_ptr<Animal>, get a Dog back.
3. Circular/shared reference tracking: Shared objects are serialized once and encoded as back-references. Cycles don't overflow the stack.
4. Schema evolution: Compatible mode matches fields by name/id, not position. Add fields on one side without coordinating deployments.
5. IDL compiler (optional): foryc ecommerce.fdl --cpp_out ./gen generates idiomatic code for every language from one schema. Generated code can be used as domain objects directly
6. 6. Row format: O(1) random field access by index, useful for analytics workloads where you only read a few fields per record.
Throughput vs. Protobuf: up to 12x depending on workload.
GitHub: https://github.com/apache/fory
C++ docs: https://fory.apache.org/docs/guide/cpp
I’d really like critical feedback on API ergonomics, and production fit.
https://redd.it/1r8a0zt
@r_cpp
Learn C++ by Example • Frances Buontempo & Matt Godbolt
https://youtu.be/PXKICIiXEUM?list=PLEx5khR4g7PJbSLmADahf0LOpTLifiCra
https://redd.it/1r8yslh
@r_cpp
Problems with a weak tryLock operation in C and C++ standards
https://forums.swift.org/t/se-0512-document-that-mutex-withlockifavailable-cannot-spuriously-fail/84789/3
https://redd.it/1r94jgk
@r_cpp
BitFields API: Type-Safe Bit Packing for Lock-Free Data Structures
https://rocksdb.org/blog/2025/12/31/bit-fields-api.html
https://redd.it/1ra6tux
@r_cpp
C++26: std::is_within_lifetime
https://www.sandordargo.com/blog/2026/02/18/cpp26-std_is_within_lifetime
https://redd.it/1ragm1s
@r_cpp
[https://www.youtube.com/watch?v=muJL-\_ymx-0](https://www.youtube.com/watch?v=muJL-_ymx-0)
* MARTIJN TERPSTRA - Low Overhead Multi-threaded Logging for Low-latency Applications - [https://www.youtube.com/watch?v=AjnQBHu0AhE](https://www.youtube.com/watch?v=AjnQBHu0AhE)
* FREDRICK OMONDI - Introduction to Writing and Profiling GPU Kernels - [https://www.youtube.com/watch?v=0PvjR\_\_R5kI](https://www.youtube.com/watch?v=0PvjR__R5kI)
* PHIL NASH - Mastering the Special Member Functions : The Rules of 0 to 5 and Beyond - [https://www.youtube.com/watch?v=PEr6XVALpVk&pp=0gcJCYcKAYcqIYzv](https://www.youtube.com/watch?v=PEr6XVALpVk&pp=0gcJCYcKAYcqIYzv)
**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/1r6ft3n
@r_cpp
Favorite optimizations ??
I'd love to hear stories about people's best feats of optimization, or something small you are able to use often!
https://redd.it/1r65r5r
@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
C++26 Reflection + PyBind11 for algo trading
https://github.com/profitviews/merton-market-maker
https://redd.it/1rbjsxk
@r_cpp
Implementing your own asynchronous runtime for C++ coroutines
Hi all! Last time I wrote a blog post about writing your own C++ coroutines. Now, I wanted to highlight how to write your own C++ asynchronous runtime for your coroutines.
https://rhidian-server.com/how-to-create-your-own-asynchronous-runtime-in-c/
Thanks for reading, and let me know if you have any comments!
https://redd.it/1ratu13
@r_cpp
Experimental adaptive sort - matches std::sort on random input, 2-8x faster on structured data
Hi all,
I’ve been developing an adaptive sorting algorithm, tentatively called **JesseSort**, which aims to exploit partial order in input data while still being competitive with standard library sorts on random input. I’m looking for feedback on design and potential adoption strategies.
# What it does
* Detects natural runs in the input (ascending, descending, or random) with a tiny lookahead.
* Maintains two sets of piles for ascending and descending runs, essentially a dual-patience sort.
* Falls back to tiny 8-value bitonic sort networks on detected random regions.
* When this random-input block is run too many times, it falls back to **std::sort**.
* Currently merges adjacent runs in a naive/bottom-up way.
# Current numbers
Median runtime ratios vs `std::sort` over 100 trials:
|Input Type|1k Values|10k|100k|1M|
|:-|:-|:-|:-|:-|
|Random|**0.984**|1.032|1.042|1.088|
|Sorted|1.022|**0.679**|**0.583**|1.448?|
|Reverse|1.636|1.076|**0.900**|2.101?|
|Sorted+Noise(5%)|1.048|1.041|1.079|1.201|
|Random+Repeats(50%)|1.037|1.032|1.031|1.089|
|Jitter|1.012|**0.674**|**0.586**|1.443?|
|Alternating|**0.829**|1.011|**0.974**|1.018|
|Sawtooth|1.121|**0.960**|**0.978**|1.072|
|BlockSorted|1.046|**0.950**|**0.928**|1.153|
|OrganPipe|**0.446**|**0.232**|**0.138**|**0.268**|
|Rotated|**0.596**|**0.522**|**0.396**|**0.716**|
|Signal|1.402|**0.828**|**0.659**|**0.582**|
**Notes:**
* Ratios are `JesseSort` / `std::sort`. **Values <1 indicate JesseSort is faster.** 0.5 means JesseSort takes half the time (2x faster). 2.0 means JesseSort takes twice as much time (2x slower).
* Large input blow-ups (`?`) appear to be outliers on my machine, but would be curious to see if others see the same pattern.
# Current issues / questions
1. **Handoff threshold:** Detecting random input too early loses semi-structured gains; too late slows random input. How should this balance be tuned?
2. **Fallback vs. std::sort:** Could JesseSort itself (dual patience games) serve as a better fallback than heap sort in standard introsort implementations?
3. **Merge optimizations:** Current merge is bottom-up adjacent. I’ve prototyped a TimSort-style merge that merges smaller runs first. Minor speedups in most cases but I haven't tested it enough.
4. **Memory layout & cache:** Some sensitivity to variable placement and data alignment is noticeable. Any advice for robust layout-sensitive optimizations?
5. **Real-world adoption:** Even if slightly slower on purely random input (\~5%), the structured input gains are often >50%. Would such an algorithm be worth promoting or considered niche? If the hit to random input is too significant, maybe this would find a better home as an alternative like `std::structured_sort`?
I’m looking for input on:
* Algorithmic improvements, especially for the random vs structured handoff
* Practical concerns for integration into standard libraries
* Benchmark methodology for mixed input distributions
* Real-world test datasets that might showcase advantages
Code and full details are available here: [https://github.com/lewj85/jessesort](https://github.com/lewj85/jessesort)
Thanks
https://redd.it/1r8n7vi
@r_cpp
MSVC Build Tools 14.51 Preview released
https://devblogs.microsoft.com/cppblog/microsoft-c-msvc-build-tools-v14-51-preview-released-how-to-opt-in/
https://redd.it/1r8ufqi
@r_cpp
Parallel C++ for Scientific Applications: Tasks & Concurrency (2nd Part)
https://www.youtube.com/watch?v=l-QUaAH_JJs
https://redd.it/1r9ulqk
@r_cpp
I made a minimal SDL3 starter template with CMake and vcpkg — cross-platform, no bundled libs
Been doing C++ game dev for a while and got tired of setting up the same boilerplate every time I started a new SDL project. Put together a clean starter template with SDL3, SDL3_image, and SDL3_ttf managed via vcpkg so dependencies just work on Linux, macOS, and Windows.
Includes a basic SDLWindow class, hardware-accelerated renderer, and a game loop ready to go. Nothing fancy, just a solid starting point.
https://github.com/Tanner-Davison/sdl3-starter-template
Happy to answer questions about the setup or take feedback on the structure.
https://redd.it/1rajyp5
@r_cpp
Sourcetrail (Fork) 2025.12.8 released
Hi everybody,
Sourcetrail 2025.12.8, a fork of the C++/Java source explorer, has been released with these changes:
C++: Add indexing of structured binding declarations
C++: Add indexing of auto prvalue casts
GUI: Fix error/status view not cleared between indexing
C/C++: Replace msvc mulitithreading library switches with corresponding clang switches
C/C++: Add Visual Studio 2026 support
Database: Enable simple database performance improvement
https://redd.it/1r668nj
@r_cpp
New C++ Conference Videos Released This Month - February 2026 (Updated To Include Videos Released 2026-02-09 - 2026-02-15)
**CppCon**
2026-02-09 - 2026-02-15
* A Case-study in Rewriting a Legacy Gui Library for Real-time Audio Software in Modern C++ (Reprise) - Roth Michaels - CppCon 2025 - [https://youtu.be/ag\_WNEDwFLQ](https://youtu.be/ag_WNEDwFLQ)
* Back to Basics: Master the static inline, const, and constexpr C++ Keywords - Andreas Fertig - CppCon 2025 - [https://youtu.be/hLakx0KYiR0](https://youtu.be/hLakx0KYiR0)
* std::execution in Asio Codebases: Adopting Senders Without a Rewrite - Robert Leahy - CppCon 2025 - [https://youtu.be/S1FEuyD33yA](https://youtu.be/S1FEuyD33yA)
* Back to Basics: Custom Allocators Explained - From Basics to Advanced - Kevin Carpenter - CppCon 2025 - [https://youtu.be/RpD-0oqGEzE](https://youtu.be/RpD-0oqGEzE)
* Your Optimized Code Can Be Debugged - Here's How With MSVC C++ Dynamic Debugging - Eric Brumer - CppCon 2025 - [https://youtu.be/YnbO140OXuI](https://youtu.be/YnbO140OXuI)
2026-02-02 - 2026-02-08
* Connecting C++ Tools to AI Agents Using the Model Context Protocol (MCP) - Ben McMorran - [https://youtu.be/NWnbgwFU1Xg](https://youtu.be/NWnbgwFU1Xg)
* The Truth About Being a Programmer CEO - Greg Law - [https://youtu.be/e8kNoLCW\_Rs](https://youtu.be/e8kNoLCW_Rs)
* An Introduction to the new C++ 26 "Reflection" Feature - Inbal Levi - [https://youtu.be/HBkG5DpLYo0](https://youtu.be/HBkG5DpLYo0)
* CMake Doesn't Have to Be Painful | Simple Strategies That Work - Bret Brown - [https://youtu.be/NDfTwOvWIao](https://youtu.be/NDfTwOvWIao)
* Parallel Range Algorithms: The Evolution of Parallelism in C++ - Ruslan Arutyunyan - [https://youtu.be/LVDr0132vUI](https://youtu.be/LVDr0132vUI)
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-02-09 - 2026-02-15
* How To Learn Audio Plugin Development With JUCE in 2026 (for free) - Jan Wilczek & Tom Poole - ADC 2025 - [https://youtu.be/MCL1BRsEEYc](https://youtu.be/MCL1BRsEEYc)
* Learnings from a Decade of Being a Mentor in Game Audio - Jorge Garcia - ADCx Gather 2025 - [https://youtu.be/Er\_C2652Bxw](https://youtu.be/Er_C2652Bxw)
* Channel Agnosticism in MetaSounds - Simplifying Audio Formats for Reusable Graph Topologies - Aaron McLeran - ADC 2025 - [https://youtu.be/vC-jnag-w9Q](https://youtu.be/vC-jnag-w9Q)
2026-02-02 - 2026-02-08
* Real-Time, Low Latency and High Temporal Resolution Spectrograms - Alexandre R.J. Francois - [https://youtu.be/QbNPA5QJ6OU](https://youtu.be/QbNPA5QJ6OU)
* Audio Codec Switching in the Linux Kernel for Automotive Edge Devices - Rutvij Trivedi - [https://youtu.be/eo2wWQQNYbI](https://youtu.be/eo2wWQQNYbI)
* Instrument Your Code So it Can Sing - Adam Shield - [https://youtu.be/Ll8h2ASyicA](https://youtu.be/Ll8h2ASyicA)
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)
**C++ Under The Sea**
2026-02-02 - 2026-02-09
* INBAL LEVI - Welcome to 0.1 of the meta::\[\[verse\]\]! - [https://www.youtube.com/watch?v=PEr6XVALpVk&pp=0gcJCYcKAYcqIYzv](https://www.youtube.com/watch?v=PEr6XVALpVk&pp=0gcJCYcKAYcqIYzv)
* LIEVEN DE COCK - Space Invaders: The Spaceship Operator is upon us -
Back to Basics: Iterators in C++ - Nicolai Josuttis - CppCon 2023
https://www.youtube.com/watch?v=26aW6aBVpk0
https://redd.it/1r5nrqw
@r_cpp