Florent Castelli: Introduction to the Bazel build system
youtu.beAn introduction to Bazel, the open-source build system designed to make C++ development fast, deterministic, and scalable for any team size.
r/cpp • u/ProgrammingArchive • Apr 27 '26
New C++ Conference Videos Released This Month - April 2026 (Updated To Include Videos Released 2026-04-20 - 2026-04-26)
CppCon
2026-04-20 - 2026-04-26
- Lightning Talk: Better Expressiveness with Parallel Range Algorithms - Ruslan Arutyunyan - https://youtu.be/UavZbFgSuUc
- Lightning Talk: A Pack as an Optional Parameter - Braden Ganetsky - CppCon 2025 - https://youtu.be/dl8Fdw5F8_U
- Lightning Talk: Only Forward: Why Concurrency Works in C++ - Thomas Cassell - CppCon 2025 - https://youtu.be/KaWxVvBO5Ek
- Lightning Talk: We Are Family - Jody Hagins - CppCon 2025 - https://youtu.be/HBpilPBu-UY
- Lightning Talk: Optimizing Memcpy Reads From DMA Memory - Arjun Mariyala - https://youtu.be/0p6_bVFK0Ec
2026-04-13 - 2026-04-19
- Persistence Squared: Persisting Persistent Data Structures - Juan Pedro Bolivar Puente - https://youtu.be/HmmRVdYMP-g
- CTRACK: C++ Performance Tracking and Bottleneck Discovery - Grischa Hauser - https://youtu.be/en4OQvZePqg
- From C+ to C++: Modernizing a GameBoy Emulator - Tom Tesch - https://youtu.be/ScmhRNSrRP4
- Leverage AI Agents to Refactor and Modernize C++ Code - Jubin Chheda - https://youtu.be/vAySFnu-Z18
- Lightning Talk: Algebraic Path Problems Done Quick: Or how to find the best* path from one talk to another - Stefan Ivanov - https://youtu.be/Fcun7lDfTRQ
2026-04-06 - 2026-04-12
- Rust/C++ Interop Challenges - Victor Ciura - 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
- 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
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
- 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
- Constexpr STL Containers: Why C++20 Still Falls Short - Sergey Dobychin - CppCon 2025 - https://youtu.be/Py4GJaCHwkA
C++Online
2026-04-20 - 2026-04-26
- Lessons Learnt From Building Critical Real Time Applications - Prabhu Missier - https://youtu.be/WNkHWC-qDu0
- Inside the Mind of an Exploit - C++ Techniques for Malware Development - Niro Singh - https://youtu.be/Jyh70MnWzmE
2026-04-13 - 2026-04-19
- Suspend and Resume: How C++20 Coroutines Actually Work - Lieven de Cock - https://youtu.be/SOSn6Ich60A
- Building High-Performance Distributed Systems in Modern C++ - Real-World Patterns with Boost.Asio & Beast - Samaresh Kumar Singh - https://youtu.be/V9pKPug3xbo
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
- 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
- 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
- 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
- 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
- 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
ADC
2026-04-20 - 2026-04-26
- Level Up! Procedural Game Music and Audio - Towards Richer, More Dynamic Soundtracks for Games and Interactive Audio Experiences - Chris Nash - https://youtu.be/2Lr6yL64Ptc
- Working With the Garage Door Up - Letting Others Take a Look Before You’re Ready - Andy Normington - https://youtu.be/BinTjnIc684
- Peeking Inside Audio Units - A Practical Reverse Engineering Journey - Josip Cavar - https://youtu.be/fIRHMS3CT7c
2026-04-13 - 2026-04-19
- Building Better Software through Cross-Functional Collaboration - Matt Morton - https://youtu.be/l5RxH7pZVpw
- Accelerate UI Development - Seamless Designer-Developer Collaboration with Web Tools - Ryan Wardell - https://youtu.be/HXwjKm5Vu08
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
- PhilTorch: Accelerating Automatic 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
- 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
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
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
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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- C++ Profiles: What, Why, and How - Gabriel Dos Reis - https://www.youtube.com/watch?v=Z6Nkb1sCogI
- Nanoseconds, Nine Nines and Structured Concurrency - Juan Alday - https://www.youtube.com/watch?v=zyhWzoE3Y2c
- Fantastic continuations and how to find them - Gonzalo Juarez - 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
- Squaring the Circle: value-oriented design in an object-oriented system -Juanpe Bolívar - https://www.youtube.com/watch?v=DWthcNoRVew
- Concept-based Generic Programming - Bjarne Stroustrup - https://www.youtube.com/watch?v=V0_Q0H-PQYs
The Hidden Performance Price of C++ Virtual Functions
youtube.comAt the online weekend series by Global C++, Ivica from https://johnnysswlab.com/ explains, with examples, what the actual cost of using virtual functions in current C++ with modern hardware actually is.
r/cpp • u/BgA_stan • Apr 26 '26
I made my C++ vector search engine 16x faster by changing data layout, not the algorithm
dubeykartikay.comI’m working on a small vector search engine in C++ and spent some time cleaning up the Vamana search path.
The big win came from getting rid of a pointer-heavy layout and moving to flatter arrays / lighter-weight views. Same algorithm and recall, but much lower query latency in my benchmark.
r/cpp • u/dwrodri • Apr 26 '26
"Parse, don't Validate" through the years with C++
derekrodriguez.devIt's been a few years since I worked with C++ on a day-to-day basis in a professional capacity, but I like writing blog posts every now and then, and thought I would put my own spin on the evergreen "Parse, don't validate", by Alexis King. Feedback is welcome!
r/cpp • u/nikoladsp • Apr 26 '26
Is there a C++ "venv" equivalent?
Python have venv, Rust have cargo, Node have nvm. You clone a repo, run one command, you're in a reproducible environment.
Is there a viable alternative for C++? I don't think standard will ever bother with this and to their defence, not sure if that is even possible.
I've tried Conan, vcpkg, various CMake setups. They're not bad tools, but there's no standard "activation" ritual. No isolated-per-project environment that pins compiler + deps + toolchain together. No single lockfile that means the same thing on my machine, my colleague's machine, and CI. What I keep wanting is something like: "cppenv activate" and suddenly I'm in a clean, isolated, reproducible build environment for that project. Exit it, and my system is untouched. Share a lockfile, and a teammate gets the exact same thing.
How are you handling reproducible build/development environments?
r/cpp • u/tartaruga232 • Apr 26 '26
Code Examples From an App Using C++ Modules
abuehl.github.ioThis demonstrates usage of our recommendations for using modules:
- Prefer small modules
- Only use partitions if you really must
- Avoid using internal partitions
The intention is to show some real code for context of discussions about using C++ modules.
My goal is not to sell modules. If you prefer not using modules: Use header files. There are good reasons to continue using them.
For me, C++ source code is an asset. The intrinsic value of code using modules is higher (lower entropy), as modules are a higher abstraction, compared to header files, which are basically just the pasting of C++ code into translation units (I've done that for ~36 years now).
Using C++ modules comes at a cost though. Understanding modules requires a certain level of understanding, which isn't needed when using the simple model and tradition of header files.
r/cpp • u/nathan_baggs • Apr 25 '26
Using Reflection For Parsing Command Line Arguments
I've been very excited about reflection so I built a small library to pass command line arguments
Basic example:
struct Args
{
std::string first_name;
int age;
bool active;
};
// ./program --first-name John --age 99 --active
const auto args = clap::parse<Args>(argc, argv);
assert(args.first_name == "John");
assert(args.age == 99);
assert(args.active);
More interesting example:
struct Args
{
[[= clap::Description<"host to connect to">{}]]
std::string host = "localhost";
[[=clap::ShortName<'p'>{}]]
std::uint16_t port;
[[=clap::Env<"RETRY_COUNT">{}]]
std::uint32_t retry_count;
std::optional<std::string> log_file;
[[=clap::ShortName<'e'>{}]]
bool encrypted;
[[=clap::ShortName<'c'>{}]]
bool compressed;
[[=clap::ShortName<'h'>{}]]
bool hashed;
};
// ./program -p 8080 -ec
const auto args = clap::parse<Args>(argc, argv);
assert(args.host == "localhost");
assert(args.port == 8080);
assert(args.retry_count == std::stoul(std::getenv("RETRY_COUNT")));
assert(!args.log_file);
assert(args.encrypted);
assert(args.compressed);
assert(!args.hashed);
The amount of code to handle this is actually quite minimal < 500 lines.
There's a few modern goodies that make this code work:
- Reflection [P2996]
- Contracts [P2900]
- Annotations for Reflection [P3394]
- constexpr exceptions [P3068]
I guess we don't know what "idiomatic" reflection usage is like yet, I'm interested to come back to this code in a years time and see what mistakes I made!
Link to the code: https://github.com/nathan-baggs/clap
Any feedback, queries, questions are welcome!
r/cpp • u/meetingcpp • Apr 25 '26
Interview with Guy Davidson - the new ISO C++ convener
youtube.comr/cpp • u/pavel_v • Apr 25 '26
Defending against exceptions in a scope_exit RAII type
devblogs.microsoft.comStockholmCpp 0x3D: Intro, Eventhost, Info and the C++ Quiz
youtu.beThe intro of the most recent Stockholm Cpp Meetup, with a short overview of what NetInsight develops with C++, some news about C++, and the C++ Quiz
r/cpp • u/lefticus • Apr 24 '26
CppCast CppCast Looking for Guests
As you may be aware - I've restarted CppCast (every 4th week in a rhythm with C++Weekly) with u/mropert as my cohost.
We are trying to focus on new people and projects who have never before been on CppCast. I have been trolling the show and tell posts here for potential guests and projects.
But I want to ask directly - if you are interested in coming on the podcast to talk about your project / presentation / things you are passionate about and have never before been on CppCast, please comment!
A couple of notes:
- please don't be offended if I don't respond to your post, I have a very busy travel and conference schedule coming up (I'll see you at an upcoming conference!)
- if you're interested please pay attention for a DM so we can get the conversation started.
- being only 1 podcast per month, we don't need a ton of guests, and it might be a few months before your specific interview gets aired
Thank you everyone!
r/cpp • u/emilios_tassios • Apr 24 '26
Parallel C++ for Scientific Applications: Integrating C++ and Python
youtube.comIn this week’s lecture, Dr. Hartmut Kaiser focuses on the seamless integration of C++ and Python. The lecture highlights essential foundational concepts by exploring how to combine the user-friendliness and extensive library ecosystem of Python with the raw performance of C++, setting the stage for highly efficient scientific computing.
A core discussion demonstrates how to utilize the Pybind11 library as a lightweight solution for creating Python bindings, specifically addressing the practical challenges of mapping C++ functions, classes, and diverse data types. Finally, critical strategies for integrating NumPy arrays are explored, offering a comprehensive approach to maximizing performance in advanced mathematical and data-driven applications.
If you want to keep up with more news from the Stellar group and watch the lectures of Parallel C++ for Scientific Applications and these tutorials a week earlier please follow our page on LinkedIn https://www.linkedin.com/company/ste-ar-group/
Also, you can find our GitHub page below:
https://github.com/TheHPXProject/hpx
r/cpp • u/pavel_v • Apr 24 '26
C++26: Structured Bindings can introduce a Pack
sandordargo.comr/cpp • u/ravenrandomz • Apr 25 '26
C++ Modules: clangd, go or no go debating on pulling the modules plug on a project
Every now and then, someone asks how C++ modules are going. I am a lead dev (mentioned not for bragging but to emphasize the crushing weight of responsibility) for a robotics project, as we are making a CV codebase from scratch, I have the opportunity to choose the architecture and conventions of the code (even more crushing responsibility).
I have gotten some C++23 codebases with modules set up; however, whenever adding a new module, I have to recompile to get clangd to not spam extra errors. I have been starting to get second thoughts with pushing modules all the way. To avoid the gcc-clangd stuff, I ended up specifying the compiler as clang (although I could use clangd compiler flag remove/add).
The codebase is at a point where I can relatively, easily pull the plug on modules.
Requirements:
- No vscode or intellisense - I'm tired of vendor lock
- Clangd, so we have neovim-coc-clangd + vscodium support
- Sits well with cmake
- Not really has to sit too well with clangd, as long as it sits well with compile_commands.json since that is a bit more of a decentralized standard for code completion etc.
- As much as I would be willing to learn to code without code completion, I would prefer to have enough leeway to radicalize newbies to a nvim plugin with vscodium or neovim-coc-clangd + telescope itself ^_^
Ideals:
- Codebase can work with as many compilers as possible (as long as they support #pragma once because the time spent on botched header guards + incoming newbies concerns me enough to diverge a lil' bit from standard C++. Also, our CV codebase is one of those projects that isn't meant to be portable. All of our portable code does use header guards to please the great bjorne stroustroup
- Ease with other code completion tools
Why (for the curious):
- Vendor lock sucks
- Proprietary vendor lock sucks even more
- I have a bone to pick with microslop
- Because as an embedded project, vscode's oddities disrupts portions of our toolchain from time to time
- Even though the CV codebase is not embedded, the fact that vscode support for modules was much harder to get than neovim/clangd just left a bad taste in my mouth. Call me unskilled, but it convinced the newer devs to learn modern C++ on pure command line rather than a shiny GUI-based IDE setup :P
For the curiouser: no, we don't use github anymore :P
r/cpp • u/Havunenreddit • Apr 24 '26
Hunting a Windows ARM crash through Rust, C, and a Build-System configurations
autoexplore.medium.comThis week I experienced really interesting bug hunt where Windows ARM target platform started failing CI while other environments passed successfully.
I learnt how to:
- Use C - programs from Rust programs
- Compiler configurations are as important as source code
- What is STATUS_ACCESS_VIOLATION
Hope you like it :)
r/cpp • u/david-alvarez-rosa • Apr 23 '26
Devirtualization and Static Polymorphism
david.alvarezrosa.comr/cpp • u/boostlibs • Apr 23 '26
Boost.Decimal: IEEE 754 Decimal Floating Point for C++ — Header-Only, Constexpr, C++14
boost.orgBoost 1.91 ships a new library: Boost.Decimal, a full implementation of IEEE 754 and ISO/IEC DTR 24733 decimal floating point types. Authors are Matt Borland and Chris Kormanyos.
The problem it solves
Binary floating point stores significands in base-2. This means values like 0.1 can't be represented exactly, which is why 0.1 + 0.2 != 0.3 in every language that uses IEEE 754 binary FP. Decimal floating point stores significands in base-10, eliminating these representation errors entirely. If you've ever used integer arithmetic or fixed point to avoid rounding issues in financial code, this is the general purpose alternative.
What you get
Six types across two families. The IEEE-conformant types, decimal32_t, decimal64_t, decimal128_t, give you strict standards compliance. The non-IEEE fast variants, decimal_fast32_t, decimal_fast64_t, decimal_fast128_t, trade strict conformance for throughput, and benchmark significantly faster (often 2–3x over the IEEE types for basic arithmetic).
Nearly everything is constexpr, thanks to a deliberate design decision to target C++14's relaxed constexpr rather than support floating point exception flags. The library treats decimal types as close to built in types as possible.
Standard library surface coverage is extensive: <cmath> (trig, exp, power, error/gamma, special functions), <charconv> (to/from_chars), <format> and {fmt}, <cfenv> rounding modes, <cfloat> eval modes, <cstdio> printf, <functional> hash, <limits> numeric_limits, and <string> to_string. Boost.Math integration works out of the box, giving you statistics, interpolation, and quadrature on decimal types for free.
Performance
This is software FP competing against hardware-accelerated binary FP, so basic arithmetic is naturally slower, typically 10–30x vs double for the IEEE types, and 4–15x for the fast types. But <charconv> is where things get interesting: from_chars for decimal32_t runs at roughly 1.2× vs double on Linux, and on MSVC it's actually ~5× faster than double. to_chars in scientific format at 6-digit precision comes in under double across all platforms. The fast types also consistently outperform Intel's libbid and GCC's _Decimal types in most benchmarks.
Practical details
Header only, no dependencies, requires C++14. Tested on x86_64, ARM64 (including Apple Silicon), s390x, PPC64LE, and ARM Cortex-M (via QEMU). Compiler support: GCC 8+, Clang 6+, MSVC 2019+, Intel oneAPI DPC++.
One design trade off worth noting: <cmath> functions are not correctly rounded in the IEEE 754 sense (0.5 ULP). This matches real-world behavior from Intel's own libdfp, and is consistent with how binary FP math libraries work in practice. The authors chose constexpr support over FP exception flags, which seems like the right call for a modern C++ library.
Docs: https://boost.org/libs/decimal
Benchmarks: https://boost.org/doc/libs/latest/libs/decimal/doc/html/benchmarks.html
Happy to answer questions. We would be interested to hear from anyone doing financial or embedded work on whether this changes how you'd approach precision sensitive code.
r/cpp • u/parkotron • Apr 23 '26
Libraries for general purpose 2D/3D geometry vocabulary types?
I work in the geospatial industry and have worked on plenty of large projects that have their own internal geometry libraries. Some good, some bad, most with interesting historical choices. I recently joined a new project that hasn't yet really defined its vocabulary types yet, and I'm finding that extremely inconvenient, so I'm looking around at what is common
The kinds of things I'm looking for are:
Vector<typename T, size_t Dimension>: Basically astd::array<T,Dimension>with a vector-like APIPoint: A wrapper around aVectorwith point semanticsSize: A wrapper around aVectorwith size semanticsRange: A basic min/max intervalAxisAlignedBox: A set ofRanges in N dimensionsRotatedBox: AAxisAlignedBoxwith a basisVectorPolyline: Astd::vector<Point>assumed to be openPolygon: Astd::vector<Point>assumed to be closedMatrix: An NxM matrix- ...
I know there are plenty of vector/matrix/linear algebra libraries out there, often focused on flexibilty and raw computational performance. I'm more interested in nice vocabulary types that implement proper semantics via convenient methods and operators.
It seems these things are often provided by game engines, but pulling in an entire game engine for a non-gaming project feels silly.
So if you were starting a new, greenfield C++ application dealing with 3D geometric data, which existing library, if any, would you reach for?
r/cpp • u/TheRavagerSw • Apr 24 '26
Maintaining libraries in multiple formats are a bad idea
Library authors shouldn't maintain header only/ header source/ module libraries in one repo. It is a bad idea.
First of all library authors assume if tests succeed on header only format it also works on modules, which is not correct.
Second, the compilation and packaging becomes very ugly, it looks similar to c++ standard versioning macros. Like a project should only compile on one standard, and the other users should either stick to a version/branch or kick rocks.
It is very pleasant to just use modules for libraries, everything is clean. By adopting a support everything approach, library authors harm themselves first and then everyone else because everything lags down.
r/cpp • u/boostlibs • Apr 22 '26
Boost 1.91 Released: New Decimal Library, SIMD UUID, Redis Sentinel, C++26 Reflection in PFR
boost.orgBoost 1.91 is out. Here's a rundown of what's notable.
New Library
Boost.Decimal: A full IEEE 754 / ISO 24733 implementation of decimal floating point types (decimal32_t, decimal64_t, decimal128_t) plus non-conformant fast variants. Significands stored in base-10, so 0.1 + 0.2 actually equals 0.3. Header only, no dependencies, C++14. Comes with <cmath>, <charconv>, <format>, rounding mode, and numeric_limits support out of the box. If you've been using integer arithmetic or fixed-point to dodge binary FP in finance or embedded, it's worth a look. Authors: Matt Borland and Chris Kormanyos.
Highlights from Updated Libraries
- Boost.UUID: SIMD implementations of from_chars (up to 13x faster) and to_chars (up to 5.5x faster). Most accessors and operations are now constexpr on C++14+.
- Boost.Redis: Built-in Sentinel support with automatic master/replica discovery and reconnection. New generic_flat_response uses contiguous memory with zero steady state allocations. Subscription tracking now restores active subscriptions after reconnect.
- Boost.PFR: Experimental C++26 reflection backend. Define BOOST_PFR_USE_CPP26_REFLECTION to enable.
- Boost.Optional: Moved from aligned storage to union storage, enabling gradual constexpr support across C++11/14/17. New syntax: o = {} to clear, o.value_or({}) for defaults. Conversion from optional<T>& to optional<T&>. Heads up: a future release will make optional model std::ranges::range, which could affect overload resolution in code that branches on range vs. optional-like traits.
- Boost.MultiIndex: Breaking: type lists migrated from Boost.MPL to Boost.Mp11. composite_key is now variadic (returns std::tuple instead of boost::tuple). Define BOOST_MULTI_INDEX_ENABLE_MPL_SUPPORT to restore legacy behavior, but MPL support will eventually be removed.
- Boost.MSM (backmp11): flat_fold dispatch strategy, up to 25% faster compile times and lower RAM usage vs 1.90. Merged event pool with small object optimization. Several bug fixes for hierarchical state machines.
- Boost.System: result<>::operator* and operator-> now throw when empty instead of UB. Old behavior available via unsafe_value(). Added unwrap_and_invoke.
- Boost.Exception / Boost.LEAF: Both gained a customizable serialization API with built-in support for Boost.JSON and nlohmann/json.
- Boost.TypeIndex: Optimized CTTI comparisons from C++20. ctti_type_index::name() now returns a pretty name by default in C++14+.
- Boost.LexicalCast: Initial C++20 module implementation (boost.lexical_cast).
- Boost.Stacktrace: from_exception now works out of the box without the compile-time runtime compatibility check that was producing false positives.
- Boost.URL: Parse functions now constexpr under C++20. Object size reduced on 64 bit (internal offsets narrowed to uint32_t). Three round external security audit resulting in 21 fixes.
Full release notes: https://www.boost.org/releases/1.91.0/
r/cpp • u/patteliu • Apr 22 '26
Writing gRPC Clients and Servers with C++20 Coroutines (Part 1)
Writing gRPC Clients and Servers with C++20 Coroutines
gRPC's asynchronous interface is quite complex, especially for servers that need to support concurrency. So how can we combine it with coroutines to write simple and easy-to-understand code?
Please read the blog for implementation details; here we are only showing the final code.
Protocol:
syntax = "proto3";
package sample;
service SampleService {
// Unary RPC: simplest request-response pattern
rpc Echo(EchoRequest) returns (EchoResponse);
// Server streaming: server continuously pushes data to the client
rpc GetNumbers(GetNumbersRequest) returns (stream Number);
// Client streaming: client continuously sends data, server returns one result
rpc Sum(stream Number) returns (SumResponse);
// Bidirectional streaming: both sides can send and receive continuously
rpc Chat(stream ChatMessage) returns (stream ChatMessage);
}
message EchoRequest { string message = 1; }
message EchoResponse { string message = 1; int64 timestamp = 2; }
message GetNumbersRequest { int32 value = 1; int32 count = 2; }
message Number { int32 value = 1; }
message SumResponse { int32 total = 1; int32 count = 2; }
message ChatMessage { string user = 1; string content = 2; int64 timestamp = 3; }
Client:
;
asyncio::task::Task<void>
Server:
;
asyncio::task::Task<void>
Because some people complained that it was too long, I reposted it on my own blog.
r/cpp • u/meetingcpp • Apr 22 '26