mp-units: a design for logarithmic quantities and units (dB, dBm, Np, pH). We believe it is novel, and we need domain experts to tell us where we are wrong before we implement it
https://mpusz.github.io/mp-units/latest/blog/2026/07/24/introducing-logarithmic-quantities-and-units/
https://redd.it/1v5kdbi
@r_cpp
https://mpusz.github.io/mp-units/latest/blog/2026/07/24/introducing-logarithmic-quantities-and-units/
https://redd.it/1v5kdbi
@r_cpp
mpusz.github.io
Introducing Logarithmic Quantities and Units - mp-units
The quantities and units library for C++
Switching from Java to C++
Having grasped of Java SE I cannot completely write mechanical sympathy code from it. Can you suggest how should I start C++ language? I want to get ready with syntax first is there any critics or guide is so when i start my C++ journey I need to be clear of it.
IDE suggestion ? (VsCode | CLion)
https://redd.it/1v62buy
@r_cpp
Having grasped of Java SE I cannot completely write mechanical sympathy code from it. Can you suggest how should I start C++ language? I want to get ready with syntax first is there any critics or guide is so when i start my C++ journey I need to be clear of it.
IDE suggestion ? (VsCode | CLion)
https://redd.it/1v62buy
@r_cpp
Reddit
From the cpp community on Reddit
Explore this post and more from the cpp community
muopt: a C++17 micro-library for argument parsing
Hello! I wanted to share a project that I've been working on for the last few days, a small argument parsing library called muopt. It started from a quite popular Rust crate called lexopt that I use in one of my CLI Rust projects. I wanted something similar to lexopt and couldn't find it for C++, so I decided to write my own.
muopt is more of a tokenizer/lexer than it is a parser. It doesn't "connect" a value to its option and just views them as an argument. muopt is intended to be minimal and bare-bones. Below is a really simple example of muopt in action.
#include "muopt/muopt.hpp"
#include <iostream>
int main(int argc, char argv) {
muopt::Parser parser(argc, argv);
while (std::optional<muopt::Arg> arg = parser.next()) {
if (arg->islong("help"))
std::cout << "usage: example [--input FILE]\n";
if (arg->islong("input"))
std::cout << parser.argvalue().valueor("") << '\n';
}
}
The code above will match the arguments
muopt is still very early; it's not even released yet. I'm still debating on how to take on certain things, for example the
GitHub: https://github.com/secona/muopt
https://redd.it/1v6342h
@r_cpp
Hello! I wanted to share a project that I've been working on for the last few days, a small argument parsing library called muopt. It started from a quite popular Rust crate called lexopt that I use in one of my CLI Rust projects. I wanted something similar to lexopt and couldn't find it for C++, so I decided to write my own.
muopt is more of a tokenizer/lexer than it is a parser. It doesn't "connect" a value to its option and just views them as an argument. muopt is intended to be minimal and bare-bones. Below is a really simple example of muopt in action.
#include "muopt/muopt.hpp"
#include <iostream>
int main(int argc, char argv) {
muopt::Parser parser(argc, argv);
while (std::optional<muopt::Arg> arg = parser.next()) {
if (arg->islong("help"))
std::cout << "usage: example [--input FILE]\n";
if (arg->islong("input"))
std::cout << parser.argvalue().valueor("") << '\n';
}
}
The code above will match the arguments
--help and -h. Both will print out the usage message. It will also match --input=Hello or --input Hello and print out the value. The README has a deeper explanation on how muopt works and the repo has more examples.muopt is still very early; it's not even released yet. I'm still debating on how to take on certain things, for example the
arg_value() return type and how errors should be handled. Any suggestions are welcomed!GitHub: https://github.com/secona/muopt
https://redd.it/1v6342h
@r_cpp
GitHub
GitHub - secona/muopt: μopt - a C++17 micro-library for argument parsing
μopt - a C++17 micro-library for argument parsing. Contribute to secona/muopt development by creating an account on GitHub.
C++26: what is reflection and how to use it
https://techfortalk.co.uk/2026/07/25/c26-what-is-reflection-and-how-to-use-it/
https://redd.it/1v6a8az
@r_cpp
https://techfortalk.co.uk/2026/07/25/c26-what-is-reflection-and-how-to-use-it/
https://redd.it/1v6a8az
@r_cpp
Tech For Talk
C++26: what is reflection and how to use it
The author aims to explore C++26 progressively, focusing on its new features, particularly reflection. C++26 introduces the `enumerators_of()` function, allowing easy access to enum class members w…
Modern c++: operations on function pointers will break the constexpr function.
I'm on MSVC/c++23.
I used some trick to generate type id at compile time:
export template<typename... T> void typeid() {}
export using typeidt = void(*)();
//
typeidt oneid = typeid<int>;
I’ve found that whenever I try to cast a \`type\id` value to an integer or simply perform a magnitude comparison within a `constexpr` function (even when the call chain is entirely resolved at compile time), the function ceases to be `constexpr`, or MSVC simply ignores the relevant code.
template<typename A, typename B>
constexpr auto someconstexprfunction()
{
typeidt a = typeid<A>;
typeidt b = typeid<B>;
//Total if block will be ignored, and the function will not be constexpr anymore.
if (a < b)
{
//discard
}
else
{
//discard
}
//cast the pointer to sizet then the function will not be constexpr anymore.
return (sizet)a;
}
How to fixed the case?
Or another type id solution at compile time will be nice(I have try so many implementation, none of them work correctly in compile time).
https://redd.it/1v6clnl
@r_cpp
I'm on MSVC/c++23.
I used some trick to generate type id at compile time:
export template<typename... T> void typeid() {}
export using typeidt = void(*)();
//
typeidt oneid = typeid<int>;
I’ve found that whenever I try to cast a \`type\id` value to an integer or simply perform a magnitude comparison within a `constexpr` function (even when the call chain is entirely resolved at compile time), the function ceases to be `constexpr`, or MSVC simply ignores the relevant code.
template<typename A, typename B>
constexpr auto someconstexprfunction()
{
typeidt a = typeid<A>;
typeidt b = typeid<B>;
//Total if block will be ignored, and the function will not be constexpr anymore.
if (a < b)
{
//discard
}
else
{
//discard
}
//cast the pointer to sizet then the function will not be constexpr anymore.
return (sizet)a;
}
How to fixed the case?
Or another type id solution at compile time will be nice(I have try so many implementation, none of them work correctly in compile time).
https://redd.it/1v6clnl
@r_cpp
Reddit
From the cpp community on Reddit
Explore this post and more from the cpp community
SUCO – Lightweight Distributed C/C++ Compiler Grid with intelligent SSD cache (alternative to Icecream/distcc)
Hi everyone,
I'd like to share my open-source project **SUCO** (SUper COmpiler Grid).
It's a lightweight, zero-config distributed C/C++ compilation and caching system for local networks. Designed as a simpler and faster alternative to Icecream/distcc and proprietary tools like IncrediBuild.
**Key features:**
\- Automatic worker discovery via UDP
\- SHA-256 based SSD cache → warm rebuilds can be up to \~4× faster
\- Windows client can cross-compile to Linux MinGW workers
\- Load-aware scheduling + automatic failover
\- Live web dashboard + Prometheus metrics
\- Easy CMake & IDE integration
Cold builds are roughly on par with Icecream, but cache hits skip the expensive compiler phases completely.
GitHub: https://github.com/MicBur/suco
I'd really appreciate any feedback, criticism or suggestions!
https://redd.it/1v7ce8q
@r_cpp
Hi everyone,
I'd like to share my open-source project **SUCO** (SUper COmpiler Grid).
It's a lightweight, zero-config distributed C/C++ compilation and caching system for local networks. Designed as a simpler and faster alternative to Icecream/distcc and proprietary tools like IncrediBuild.
**Key features:**
\- Automatic worker discovery via UDP
\- SHA-256 based SSD cache → warm rebuilds can be up to \~4× faster
\- Windows client can cross-compile to Linux MinGW workers
\- Load-aware scheduling + automatic failover
\- Live web dashboard + Prometheus metrics
\- Easy CMake & IDE integration
Cold builds are roughly on par with Icecream, but cache hits skip the expensive compiler phases completely.
GitHub: https://github.com/MicBur/suco
I'd really appreciate any feedback, criticism or suggestions!
https://redd.it/1v7ce8q
@r_cpp
GitHub
GitHub - MicBur/suco: 🚀 Distributed C/C++ Compiler Grid & Windows-to-Linux Cross-Compilation Engine — Accelerating C++ builds up…
🚀 Distributed C/C++ Compiler Grid & Windows-to-Linux Cross-Compilation Engine — Accelerating C++ builds up to 4.21x across LAN clusters. - MicBur/suco
std::optional Satisfies view. Does Not Model view. C++26 Ships Anyway.
https://godbolt.org/z/8jWGG68G8
https://redd.it/1v7gp48
@r_cpp
https://godbolt.org/z/8jWGG68G8
https://redd.it/1v7gp48
@r_cpp
godbolt.org
Compiler Explorer - C++
void
passing_views_by_value_is_cheap_trust_me_bro(std::ranges::view auto v) {
std::println("fn .data {}", (void*)v->data());
}
int main() {
std::optional ov{std::vector<int>(123456)};
passing_views_by_value_is_cheap_trust_me_bro(ov);
…
passing_views_by_value_is_cheap_trust_me_bro(std::ranges::view auto v) {
std::println("fn .data {}", (void*)v->data());
}
int main() {
std::optional ov{std::vector<int>(123456)};
passing_views_by_value_is_cheap_trust_me_bro(ov);
…
Memory-level parallelism: AMD is the king
https://lemire.me/blog/2026/07/25/memory-level-parallelism-amd-is-the-king/
https://redd.it/1v7jh93
@r_cpp
https://lemire.me/blog/2026/07/25/memory-level-parallelism-amd-is-the-king/
https://redd.it/1v7jh93
@r_cpp
Daniel Lemire's blog
Memory-level parallelism: AMD is the king
When your program asks for memory that is not in cache, the processor has to go to RAM. That trip costs on the order of 100 nanoseconds. On a 3 GHz core, that is about 300 cycles of doing nothing. Memory latency has not improved in ten years. The 2016 Broadwell…
I built a C++ options execution and back testing engine with Black-Scholes. Looking for feedback on my concurrency model and memory layout.
Hi everyone,
I recently built a C++ options execution and backtesting engine utilizing Black-Scholes pricing, walk-forward optimization, and regime-based strategy selection. It's fully wired to execute paper/live trades via Alpaca.
I'm looking for harsh, constructive feedback on my architecture—specifically regarding my order ledger concurrency model and C++ memory layout.
Specific areas I'd love feedback on:
1. Concurrency in "Orderledger":
I opted for standard `std::mutex` and `std::atomic` flags rather than a lock-free queue for position state management. I'm prioritizing preventing "ghost fills" over sub-millisecond latency. Did I make the right trade-off here, and are there any glaring race conditions I missed?
2. Memory Layout:
I’m relying on standard containers (`std::vector`, `std::unordered_map`) but minimizing dynamic heap allocations on the critical path. Are there better patterns I should adopt to avoid OS allocator pauses during market hours?
3.
Black-Scholes Math Precision:
I used standard `double` precision and `std::erfc` rather than fast-math approximations to ensure numerical stability when calculating Greeks like Gamma on short-dated options.
Here is the repo: github.com/kdyn-ctrl/Nox
If you want to see the rationale behind my decisions, check out `docs/guides/DESIGN_THINKING.md` in the repository.
I also have journals of my work and guides if any other info is needed. I'm still quite novice so please be as harsh as you can I'm really trying to improve.
Thanks in advance for your time and feedback!
https://redd.it/1v7v4ev
@r_cpp
Hi everyone,
I recently built a C++ options execution and backtesting engine utilizing Black-Scholes pricing, walk-forward optimization, and regime-based strategy selection. It's fully wired to execute paper/live trades via Alpaca.
I'm looking for harsh, constructive feedback on my architecture—specifically regarding my order ledger concurrency model and C++ memory layout.
Specific areas I'd love feedback on:
1. Concurrency in "Orderledger":
I opted for standard `std::mutex` and `std::atomic` flags rather than a lock-free queue for position state management. I'm prioritizing preventing "ghost fills" over sub-millisecond latency. Did I make the right trade-off here, and are there any glaring race conditions I missed?
2. Memory Layout:
I’m relying on standard containers (`std::vector`, `std::unordered_map`) but minimizing dynamic heap allocations on the critical path. Are there better patterns I should adopt to avoid OS allocator pauses during market hours?
3.
Black-Scholes Math Precision:
I used standard `double` precision and `std::erfc` rather than fast-math approximations to ensure numerical stability when calculating Greeks like Gamma on short-dated options.
Here is the repo: github.com/kdyn-ctrl/Nox
If you want to see the rationale behind my decisions, check out `docs/guides/DESIGN_THINKING.md` in the repository.
I also have journals of my work and guides if any other info is needed. I'm still quite novice so please be as harsh as you can I'm really trying to improve.
Thanks in advance for your time and feedback!
https://redd.it/1v7v4ev
@r_cpp
GitHub
GitHub - kdyn-ctrl/Nox
Contribute to kdyn-ctrl/Nox development by creating an account on GitHub.
I built a 3D network router that "senses" attacks instead of just watching an alarm number
Built a 3D grid network simulator in C++. Packets move between nodes and reroute around traffic jams. On top of that, I built a controller that watches the overall behavior of the network — not just one alarm number — using 4 signals together: how full it is, how much is getting dropped, how fast it recovers after a spike, and how much room is left.
I compared it against a normal "alarm" style monitor — the kind most systems use, which only reacts once one number crosses a fixed line (here: more than 5% of traffic dropped, or the network more than 40% full)..
I threw 5 different fake attacks at both systems, across two network sizes, and added up the totals:
\\-Packets delivered:
my controller 1,091,830 vs normal monitor 613,472
(mine delivered 1.8x more)
\\-Average traffic lost, across ALL 5 attacks: mine (23% ) vs. normal monitor (28%)
(Quick note on those two percentages — some attacks are brutal and cause heavy loss no matter what, others are quiet and barely register. 23% and 28% are just the average across all of them combined. The real story is in the next part.)
Two of the five attacks — a slow quiet flood, and a sneaky targeted overload — never dropped more than 1% of traffic. That means the normal alarm-style monitor never noticed them at all, because it was only built to react once something gets loud, and these two stayed quiet on purpose.
My controller still caught both of them. Even though no single number spiked, the overall pattern still looked different from what normal traffic looks like — kind of like noticing something feels "off" about a room, even when nothing's visibly broken.
Code: https://github.com/Antriksh005/arena3d.
Been working on this for now some months , so Genuinely want criticism, especially on how I'm measuring "detection" — that part deserves scrutiny.
https://redd.it/1v7xg86
@r_cpp
Built a 3D grid network simulator in C++. Packets move between nodes and reroute around traffic jams. On top of that, I built a controller that watches the overall behavior of the network — not just one alarm number — using 4 signals together: how full it is, how much is getting dropped, how fast it recovers after a spike, and how much room is left.
I compared it against a normal "alarm" style monitor — the kind most systems use, which only reacts once one number crosses a fixed line (here: more than 5% of traffic dropped, or the network more than 40% full)..
I threw 5 different fake attacks at both systems, across two network sizes, and added up the totals:
\\-Packets delivered:
my controller 1,091,830 vs normal monitor 613,472
(mine delivered 1.8x more)
\\-Average traffic lost, across ALL 5 attacks: mine (23% ) vs. normal monitor (28%)
(Quick note on those two percentages — some attacks are brutal and cause heavy loss no matter what, others are quiet and barely register. 23% and 28% are just the average across all of them combined. The real story is in the next part.)
Two of the five attacks — a slow quiet flood, and a sneaky targeted overload — never dropped more than 1% of traffic. That means the normal alarm-style monitor never noticed them at all, because it was only built to react once something gets loud, and these two stayed quiet on purpose.
My controller still caught both of them. Even though no single number spiked, the overall pattern still looked different from what normal traffic looks like — kind of like noticing something feels "off" about a room, even when nothing's visibly broken.
Code: https://github.com/Antriksh005/arena3d.
Been working on this for now some months , so Genuinely want criticism, especially on how I'm measuring "detection" — that part deserves scrutiny.
https://redd.it/1v7xg86
@r_cpp
GitHub
GitHub - Antriksh005/arena3d
Contribute to Antriksh005/arena3d development by creating an account on GitHub.
New C++ Conference Videos Released This Month - July 2026 (Updated to Include Videos Released 2026-07-20 - 2026-07-26)
C++Now
2026-07-20 - 2026-07-26
Generic Programming for Multidimensional Arrays - The Boost.Multi Experiment to Integrate MD Arrays with STL Algorithms in the CPU and GPU - Alfredo A. Correa - [https://youtu.be/WriSoV4nu5E](https://youtu.be/WriSoV4nu5E)
Typed Linear Algebra - How to Not Crash on Mars - François Carouge - https://youtu.be/xZO7X8LH6Dg
From Template Metaprogramming to User Convenience - API Design Stories - Ruslan Arutyunyan - [https://youtu.be/fPo\_Tff-L5Y](https://youtu.be/fPo_Tff-L5Y)
2026-07-13 - 2026-07-19
Keynote: Benchmarking - It's About Time - Matt Godbolt - https://youtu.be/EU\_nQh8wg5A
The Morning Briefing - C++ Concurrency Before the Hardware Reckoning - Fedor Pikus - [https://youtu.be/WtChBezurj8](https://youtu.be/WtChBezurj8)
Lock-free Programming is Dead - Long Live Lock-free Programming! - Fedor G Pikus - https://youtu.be/UdKqfQ3a\_sY
2026-07-06- 2026-07-12
Keynote: Reflection Is Only Half the Story - Barry Revzin - [https://youtu.be/DZTkT1Cq\_aY](https://youtu.be/DZTkT1Cq_aY)
Keynote: Multidimensional Parallel Standard C++ - Mark Hoemmen - https://youtu.be/VAwW\_s1uEHY
C++Online
2026-07-20 - 2026-07-26
When One Red Pill Is Not Enough - Compile-Time Optimization Through Dynamic Programming - Andrew Drakeford - [https://youtu.be/zUKqoBq6Sg4](https://youtu.be/zUKqoBq6Sg4)
Coroutines and C++ - Async Without The Pain? - Tamas Kovacs - https://youtu.be/4keXOkbr0UY
2026-07-13 - 2026-07-19
C++ Contracts - A Meaningfully Viable Product, Part II - Andrei Zissu - [https://youtu.be/1VUqOx6PCMU](https://youtu.be/1VUqOx6PCMU)
Sanitize it Before You Ship IT - Vishnu Nath - https://youtu.be/jzcGATR78Mk
2026-07-06 - 2026-07-12
Time to Introspect - A Beginner's Guide to Practical Reflection - Sarthak Sehgal - [https://youtu.be/9stn1o149pw](https://youtu.be/9stn1o149pw)
Refactoring Towards Structured Concurrency - Roi Barkan - https://youtu.be/6502xFEreI8
2026-06-29 - 2026-07-05
Why std::vector Can't Save You (And What to Use Next) - Kevin Carpenter - [https://youtu.be/78fYPix0mN4](https://youtu.be/78fYPix0mN4)
Modern C++ for Embedded Systems - From Fundamentals To Real-Time Solutions - Rutvij Karkhanis - https://youtu.be/XxeqHRDhHkU
ADC
2026-07-20 - 2026-07-26
Enumerate and Extract Audio Buffers When Debugging C++ Applications - Henning Meyer - [https://youtu.be/UHV4U\_ivm\_8](https://youtu.be/UHV4U_ivm_8)
A Sine By Any Other Language - David Su - https://youtu.be/5yEd1q\_\_cqo
When Code Writes Back: Making AI Coding Agents Actually Work - Tobias Baumbach - [https://youtu.be/K04ehohSdXc](https://youtu.be/K04ehohSdXc)
Mind the Spike - Benchmarking for Worst-Case Execution Time in Realtime Code - Christian Luther - https://youtu.be/7RrOjl996WQ
2026-07-13 - 2026-07-19
Building Inclusive Audio Tools - Accessibility with ARIA, WCAG, and Real-World Projects - Samuel John Prouse & David Shervill - [https://youtu.be/O5xX9a7P-SU](https://youtu.be/O5xX9a7P-SU)
PSD to DAW - Building a Pixel-Perfect UI Pipeline - Bence Kovács - https://youtu.be/hebLkAR5X3I
Analog Filters for Realtime Audio - George Gkountouras - [https://youtu.be/NLt0NqUtNLo](https://youtu.be/NLt0NqUtNLo)
A History of FLAC - The Free Lossless Audio Codec - Josh Coalson - https://youtu.be/tBb1STRW56s
2026-07-06 - 2026-07-12
Workshop: Audio Plugin DSP in Practice - Jan Wilczek & Linus Corneliusson - [https://youtu.be/Atc0GRWoolI](https://youtu.be/Atc0GRWoolI)
An Open Toolkit for Real-Time Audio Descriptors - Valerio Orlandini -
C++Now
2026-07-20 - 2026-07-26
Generic Programming for Multidimensional Arrays - The Boost.Multi Experiment to Integrate MD Arrays with STL Algorithms in the CPU and GPU - Alfredo A. Correa - [https://youtu.be/WriSoV4nu5E](https://youtu.be/WriSoV4nu5E)
Typed Linear Algebra - How to Not Crash on Mars - François Carouge - https://youtu.be/xZO7X8LH6Dg
From Template Metaprogramming to User Convenience - API Design Stories - Ruslan Arutyunyan - [https://youtu.be/fPo\_Tff-L5Y](https://youtu.be/fPo_Tff-L5Y)
2026-07-13 - 2026-07-19
Keynote: Benchmarking - It's About Time - Matt Godbolt - https://youtu.be/EU\_nQh8wg5A
The Morning Briefing - C++ Concurrency Before the Hardware Reckoning - Fedor Pikus - [https://youtu.be/WtChBezurj8](https://youtu.be/WtChBezurj8)
Lock-free Programming is Dead - Long Live Lock-free Programming! - Fedor G Pikus - https://youtu.be/UdKqfQ3a\_sY
2026-07-06- 2026-07-12
Keynote: Reflection Is Only Half the Story - Barry Revzin - [https://youtu.be/DZTkT1Cq\_aY](https://youtu.be/DZTkT1Cq_aY)
Keynote: Multidimensional Parallel Standard C++ - Mark Hoemmen - https://youtu.be/VAwW\_s1uEHY
C++Online
2026-07-20 - 2026-07-26
When One Red Pill Is Not Enough - Compile-Time Optimization Through Dynamic Programming - Andrew Drakeford - [https://youtu.be/zUKqoBq6Sg4](https://youtu.be/zUKqoBq6Sg4)
Coroutines and C++ - Async Without The Pain? - Tamas Kovacs - https://youtu.be/4keXOkbr0UY
2026-07-13 - 2026-07-19
C++ Contracts - A Meaningfully Viable Product, Part II - Andrei Zissu - [https://youtu.be/1VUqOx6PCMU](https://youtu.be/1VUqOx6PCMU)
Sanitize it Before You Ship IT - Vishnu Nath - https://youtu.be/jzcGATR78Mk
2026-07-06 - 2026-07-12
Time to Introspect - A Beginner's Guide to Practical Reflection - Sarthak Sehgal - [https://youtu.be/9stn1o149pw](https://youtu.be/9stn1o149pw)
Refactoring Towards Structured Concurrency - Roi Barkan - https://youtu.be/6502xFEreI8
2026-06-29 - 2026-07-05
Why std::vector Can't Save You (And What to Use Next) - Kevin Carpenter - [https://youtu.be/78fYPix0mN4](https://youtu.be/78fYPix0mN4)
Modern C++ for Embedded Systems - From Fundamentals To Real-Time Solutions - Rutvij Karkhanis - https://youtu.be/XxeqHRDhHkU
ADC
2026-07-20 - 2026-07-26
Enumerate and Extract Audio Buffers When Debugging C++ Applications - Henning Meyer - [https://youtu.be/UHV4U\_ivm\_8](https://youtu.be/UHV4U_ivm_8)
A Sine By Any Other Language - David Su - https://youtu.be/5yEd1q\_\_cqo
When Code Writes Back: Making AI Coding Agents Actually Work - Tobias Baumbach - [https://youtu.be/K04ehohSdXc](https://youtu.be/K04ehohSdXc)
Mind the Spike - Benchmarking for Worst-Case Execution Time in Realtime Code - Christian Luther - https://youtu.be/7RrOjl996WQ
2026-07-13 - 2026-07-19
Building Inclusive Audio Tools - Accessibility with ARIA, WCAG, and Real-World Projects - Samuel John Prouse & David Shervill - [https://youtu.be/O5xX9a7P-SU](https://youtu.be/O5xX9a7P-SU)
PSD to DAW - Building a Pixel-Perfect UI Pipeline - Bence Kovács - https://youtu.be/hebLkAR5X3I
Analog Filters for Realtime Audio - George Gkountouras - [https://youtu.be/NLt0NqUtNLo](https://youtu.be/NLt0NqUtNLo)
A History of FLAC - The Free Lossless Audio Codec - Josh Coalson - https://youtu.be/tBb1STRW56s
2026-07-06 - 2026-07-12
Workshop: Audio Plugin DSP in Practice - Jan Wilczek & Linus Corneliusson - [https://youtu.be/Atc0GRWoolI](https://youtu.be/Atc0GRWoolI)
An Open Toolkit for Real-Time Audio Descriptors - Valerio Orlandini -
YouTube
Generic Programming for Multidimensional Arrays - Alfredo A. Correa - C++Now 2026
https://www.cppnow.org
---
Generic Programming for Multidimensional Arrays - The Boost.Multi Experiment to Integrate MD Arrays with STL Algorithms in the CPU and GPU - Alfredo A. Correa - C++Now 2026
---
Alexander Stepanov introduced us to generic programming…
---
Generic Programming for Multidimensional Arrays - The Boost.Multi Experiment to Integrate MD Arrays with STL Algorithms in the CPU and GPU - Alfredo A. Correa - C++Now 2026
---
Alexander Stepanov introduced us to generic programming…
https://youtu.be/HKlnn0hd8J0
Bugs I’ve Seen in the Wild - From Confusion to Amazement - Olivier Petit - [https://youtu.be/LBWtb\_uXt0I](https://youtu.be/LBWtb_uXt0I)
Real-Time Audio in Python: Introducing the asmu Package - Felix Huber - https://youtu.be/X2vr81CJ934
2026-06-29 - 2026-07-05
Beyond iLok: Advanced Code Protection and Cryptography for the Next Generation - Protecting the Next Generation of Applications, Plug-ins, and AI Models - Neal Michie, Ryan Wardell & Bob Brown - [https://youtu.be/dbbK\_ry2cgo](https://youtu.be/dbbK_ry2cgo)
Database Synchronisation for Audio Plugins, Part Two - Here's One I Made Earlier - Adam Wilson - https://youtu.be/wJCy2G969ro
Perfect Oscillators in Less Than One Clock Cycle - Angus Hewlett - [https://youtu.be/Ssq0a-YdamM](https://youtu.be/Ssq0a-YdamM)
Driving Chaos - Virtual Analog Modelling of a Chaotic Circuit with Wave Digital Filters - Francisco Bernardo - https://youtu.be/PnEZNqyKlIw
Boost Documentary
There is also a teaser trailer for a new documentary on the history of the Boost C++ library https://www.youtube.com/watch?v=87jvuDbnwqQ which will have its first showing at CppCon this year
https://redd.it/1v83trq
@r_cpp
Bugs I’ve Seen in the Wild - From Confusion to Amazement - Olivier Petit - [https://youtu.be/LBWtb\_uXt0I](https://youtu.be/LBWtb_uXt0I)
Real-Time Audio in Python: Introducing the asmu Package - Felix Huber - https://youtu.be/X2vr81CJ934
2026-06-29 - 2026-07-05
Beyond iLok: Advanced Code Protection and Cryptography for the Next Generation - Protecting the Next Generation of Applications, Plug-ins, and AI Models - Neal Michie, Ryan Wardell & Bob Brown - [https://youtu.be/dbbK\_ry2cgo](https://youtu.be/dbbK_ry2cgo)
Database Synchronisation for Audio Plugins, Part Two - Here's One I Made Earlier - Adam Wilson - https://youtu.be/wJCy2G969ro
Perfect Oscillators in Less Than One Clock Cycle - Angus Hewlett - [https://youtu.be/Ssq0a-YdamM](https://youtu.be/Ssq0a-YdamM)
Driving Chaos - Virtual Analog Modelling of a Chaotic Circuit with Wave Digital Filters - Francisco Bernardo - https://youtu.be/PnEZNqyKlIw
Boost Documentary
There is also a teaser trailer for a new documentary on the history of the Boost C++ library https://www.youtube.com/watch?v=87jvuDbnwqQ which will have its first showing at CppCon this year
https://redd.it/1v83trq
@r_cpp
YouTube
An Open Toolkit for Real-Time Audio Descriptors - Valerio Orlandini - ADC 2025
https://audio.dev/ -- @audiodevcon
ADC Bristol - 9th - 11th November
---
An Open Toolkit for Real-Time Audio Descriptors - Valerio Orlandini - ADC 2025
---
In modern audio applications, from music production and interactive installations to scientific…
ADC Bristol - 9th - 11th November
---
An Open Toolkit for Real-Time Audio Descriptors - Valerio Orlandini - ADC 2025
---
In modern audio applications, from music production and interactive installations to scientific…
AVX-512 Intrinsics Optimization: Achieving ~7% speedup over libpopcnt on Sapphire Rapids
Benchmarking random 64B cache-line jumps on Intel Xeon Sapphire Rapids showed the custom kernel achieving 7.09 ns/line, compared to
While contiguous memory performance ties
Target is v40. Looking for insights on whether software prefetching (
https://redd.it/1v86xcs
@r_cpp
Benchmarking random 64B cache-line jumps on Intel Xeon Sapphire Rapids showed the custom kernel achieving 7.09 ns/line, compared to
libpopcnt (7.58 ns) and std::popcount (46.10 ns).While contiguous memory performance ties
libpopcnt at 0.47 ns/word, the performance gain on this gather hot-path comes from maintaining accumulator states inside ZMM registers across steps and applying 2-accumulator unrolling to break dependency chains.Target is v40. Looking for insights on whether software prefetching (
_mm_prefetch) provides measurable benefits for this gather pattern or if latency is memory-bound.https://redd.it/1v86xcs
@r_cpp
Reddit
From the cpp community on Reddit
Explore this post and more from the cpp community