Looking for ideas for the next version of my low-latency C++ project



**Planning the next version of my low-latency C++ project**

A few weeks ago I shared my C++20 low-latency trading project, **Pulse-Order**, GitHub: [https://github.com/Shivfun99/Pulse-Order](https://github.com/Shivfun99/Pulse-Order) and I was genuinely surprised by the response. Thanks to everyone who took the time to review the project, challenge my design decisions, and explain trade-offs from real low-latency systems. Those discussions helped me identify several areas where the project can be improved.

**Original post:**
[https://www.reddit.com/r/quantindia/s/u45s60B33Q](https://www.reddit.com/r/quantindia/s/u45s60B33Q)

[https://www.reddit.com/r/quant/s/IHKVkv0UGv](https://www.reddit.com/r/quant/s/IHKVkv0UGv)

The current version includes:

* Binary market data parsing
* L2 OB
* Risk checks
* DPDK packet processing
* Application-side latency benchmarking

I'm now starting work on the next version.

Some areas I'm considering are:

* Lock-free multi-core architecture
* Multi-symbol order books
* Real market data replay
* Hardware timestamping
* AF\_XDP vs DPDK
* Exchange gateway simulation
* Order lifecycle (new/modify/cancel/fills)
* Tail-latency analysis under burst traffic

For those who have worked on low-latency systems or exchange infrastructure, **which of these would you tackle first? Is there an important systems component that you think should be added before anything else?**

I'm mainly interested in improving the systems engineering aspects rather than the trading strategy itself.

https://redd.it/1v11g3n
@r_cpp

C++ 20 named modules with clang-cl is finally added in CMake 4.4

I've been using named modules in my hobby C++ projects for years but they always trigger some unexpected ICEs when I used MSVC, and I got really tired of experimenting workarounds. After I switched to clang-cl recently, all the related problems I've encountered so far were resolved. The only thing missing now is import std

https://redd.it/1v1hq9a
@r_cpp

Żmij 1.1 released with fixed notation support, up to 38% faster double-to-string conversion, SIMD-optimized float formatting, a smaller binary footprint and more

https://github.com/vitaut/zmij/releases/tag/v1.1

https://redd.it/1v1ljec
@r_cpp

New C++ Conference Videos Released This Month - July 2026 (Updated to Include Videos Released 2026-07-13 - 2026-07-19)

**C++Now**

2026-07-13 - 2026-07-19

* Keynote: Benchmarking - It's About Time - Matt Godbolt - [https://youtu.be/EU\_nQh8wg5A](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](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](https://youtu.be/VAwW_s1uEHY)

**C++Online**

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](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](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](https://youtu.be/XxeqHRDhHkU)

**ADC**

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](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](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 - [https://youtu.be/HKlnn0hd8J0](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](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](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](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](https://www.youtube.com/watch?v=87jvuDbnwqQ) which will have its first showing at CppCon this year

https://redd.it/1v1p3nc
@r_cpp

C++26: what is “template for”? Learning with simple example.
https://techfortalk.co.uk/2026/07/20/c26-what-is-template-for/

https://redd.it/1v1zd2c
@r_cpp

Pure Virtual C++ 2026: MSVC, are we there yet? Status of C++23 and C++26 features
https://youtu.be/ZHsQ58ROEhI?si=WMidU5yfCGH3958U

https://redd.it/1v2bmeu
@r_cpp

Good web site/GitHub repo for practice

Hi everyone,

I'm looking for one good web site with coding exercises for practice c++.

Ofc I know that Leetcode/Codeforces is good but I'm looking for web sites where I can practice all topics of c++ from OOP to concurrent and parallel programming.

Good thing will be if you know for some sites where you get code snippet and then need to predict output/what is error.

https://redd.it/1v2idr3
@r_cpp

Is there something like a VM to wrap tools such as LLVM IRBuilder?

I'm working on a lightweight embedded scripting language for C++ applications. This is intended for modest extensions to the applications themselves, such as adding context-menu options to GUI controls (scripts are handlers for when the option is activated); parsers for loading data in custom serialization formats (scripts might be pairs of regex rules with match callbacks); or statistical analyses for data sets. The language has a VM which aims to be almost trivial, or at least have a minimal working core -- mostly instructions to build up a parameter list and call C++ code via function pointers. One of my goals is to minimize the distinction between calling C++ functions from a host application versus methods that implement basic language elements, like declaring/initializing variables, managing lexical scopes and variable lifetimes, and branching/loop blocks. For instance, instead of "jump" instructions if/else could be implemented as a C++ function whose second argument is an object encapsulating a code block.

My question is as follows: with this setup I am researching the feasibility of transpiling to C++ files rather than executing scripts immediately. For the basic language I seek to minimize heavy dependencies like LLVM (leaning more toward a much smaller infrastructure, like LuaVM). But I would accept external dependencies for optional extensions.

Generating C++ code directly via something like std::stringstream seems pretty awkward. I've read about Jank's IR from which C++ code is produced (and then, I believe, compiled immediately via Clang). Perhaps Gabriel dos Reis's IPR could be used to similar effect. Instead of compiling \*to\* IR, generate IR and decompile to C++ source code.

But since my compiler pipeline is designed to emit VM code, I'm hoping some tools might exist for which IR is more akin to instructions in some special-purpose bytecode format. Functionally, I'm envisioning something like LLVM IRBuilder, where code-generation is decomposed into lots of small actions (add some token to an argument list, open/close some code block, etc.). Even just a wrapper around IRBuilder might work. But what I hope to find is a sort of DSL where various IRBuilder methods (or the equivalent) could be written in sequence, one-line-per-instruction style. One thing confusing me is that online discussions about .ll files "decompiling" to C++ aren't clear as to whether the goal is generating IRBuilder code that would produce the equivalent .ll code, or conversely reconstructing the actual C++ originally written. Substantially though I'm not sure how much it matters. Here's what AI spits out as a simple IRBuilder example:

Type* Int32Ty = Type::getInt32Ty(Context);
std::vector<Type*> ParamTypes = {Int32Ty, Int32Ty};
FunctionType *FuncType = FunctionType::get(Int32Ty, ParamTypes, false);
Function *AddFunc = Function::Create(FuncType, Function::ExternalLinkage, "add", OwnerModule.get());
Function::arg_iterator Args = AddFunc->arg_begin();
Value* ArgA = Args++;
ArgA->setName("a");
Value* ArgB = Args;
ArgB->setName("b");

I could certainly envision an interface like this to produce equivalent C++ code:

int32_t add(int32_t a, int32_t b)

and so forth. But it would be excellent if the IRBuilder code could be replaced by something more VM-like:

init-arg-list
add-param-type @Int32Ty
add-param-type @Int32Ty
add-return-type @Int32Ty
reset-arg-cursor
set-arg-name "a"
inc-arg-cursor
set-arg-name "b"
inc-arg-cursor
set-proc-name "add"
write-function-signature

or something like that (imagining a "@" sigil on type names). The point is that the above lines might be pretty close to VM code intended to call the "add" function at runtime, so you could use the same compiler toolchain for multiple steps before generating one kind of code for runtime scripts and a different VM flavor for producing C++ source files.

I don't think there's any

LLVM target that works this way. But perhaps some third-party library?

https://redd.it/1v2nw60
@r_cpp