C++ - Reddit

I rewrote part of backtrader in C++23

I rewrote core parts of backtrader in C++23 because Python backtests were getting too slow for the iteration speed I wanted.
Called it StratForge. Header-only, Apache 2.0.

https://github.com/StratCraftsAI/StratForge

Most of the work went into validation. Every indicator is checked against JSON data from backtrader. Not "close enough", it has to match.
SMA(30) on bar 247 = 1847.2361? Same here or it's a bug. I kept adding test cases until I felt like most paths were covered.

548 test cases, 40k+ assertions.

Indicators use CRTP, so no virtual calls on the hot path. About 150+ indicators (trend, momentum, volatility, volume, candlesticks, etc).

SIMD: xsimd + runtime dispatch.

Performance (512-bar dataset, P50, GCC 14, Release):

- EMA(30): 16 ns/bar
- SMA(30): 29 ns/bar
- MACD(12,26,9): 22 ns/bar
- Bollinger(20,2): 45 ns/bar
- Ichimoku(9,26,52): 67 ns/bar

Allocations aren't perfect yet. No pmr or constexpr.
Ichimoku is fully pre-reserved. The rest… still work in progress.

I like header-only. Drop it into one file and compile. Makes FetchContent easy:

FetchContent_Declare(stratforge
  GIT_REPOSITORY https://github.com/StratCraftsAI/StratForge.git
  GIT_TAG v0.1.0)
FetchContent_MakeAvailable(stratforge)
target_link_libraries(your_app PRIVATE stratforge)

Includes a few example strategies (SMA crossover, RSI mean reversion). All tested, all produce trades.

Uses some C++23 stuff (std::expected, [likely], designated initializers). Not heavy, but not C++20. Is that a problem for people?

About 5K LOC in headers. Builds fine locally. If it kills your compile times in a big codebase, let me know.


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

Are you satisfied with the current state of C++ CLI parsers?

There are already many excellent C++ CLI parsers out there, but most of them still revolve around mutable runtime builder APIs.

Most existing parsers look something like this:

CLI::App app{"example"};

std::string output;
bool verbose = false;
std::vector<std::string> inputs;

app.add_option("-o,--output", output, "output file");
app.add_flag("-v,--verbose", verbose, "verbose mode");
app.add_option("inputs", inputs, "input files")->required();

CLI11_PARSE(app, argc, argv);

Why are duplicate option names still runtime errors in C++ CLI parsers? Where is the compile-time validation?

Why is the command schema still built through runtime mutation? Many CLI schemas are effectively static. Why not treat them as a static schema and let the compiler enforce it?

One of the things I love about C++ is its ability to express intent and constraints in the type system and let the compiler enforce them.

But many C++ CLI parsers still rely heavily on runtime mutation and stringly-typed APIs.

Rust has `clap`, which is a great typed CLI parser. So what about C++?

So I wanted to explore what that direction could look like in modern C++20.

**I built a new C++ CLI parser** that takes a different approach:

#include <cli/cli.hh>

struct Args {
cli::Flag<"verbose", 'v'> verbose;
cli::StringOption<"output", 'o'> output;
cli::Positional<std::string, cli::nargs::one_or_more> inputs;
};

using namespace std;

auto main(int argc, char** argv) -> int {
// Returns parsed Args or exits with an error message.
const auto args = cli::parseOrExit<Args>(argc, argv);

std::cout << "verbose: " << args.verbose.value() << '\n';

if (args.output.has_value()) {
std::cout << "output: " << *args.output.value() << '\n';
}

for (const auto& input : args.inputs.value()) {
std::cout << input << '\n';
}
}

**Try this out on Godbolt:** [https://godbolt.org/z/53d8rEMoP](https://godbolt.org/z/53d8rEMoP)

The goal is to explore a C++20-native parser API where the command line is represented as a typed schema rather than a mutable runtime builder.

The interesting part for me is that this works in **plain C++20**, without reflection, macros, code generation, or external tooling.

Repository: [https://github.com/CLI20-dev/cli20](https://github.com/CLI20-dev/cli20)

Still early-stage. I'm mainly looking for feedback on API ergonomics, diagnostics, and the compile-time/runtime tradeoff.

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

A few occasionally useful template container classes I made, Released under the Unlicense.

Written against C++ 20 although these templates would almost definitely work on lower versions. The repository is available [here](https://git.redacted.cc/Redacted/Containers/src/branch/main). Each is in it's own header so you can just copy them out.

* Circular Array (Similar to std::queue with additional features)
* Strided Span (I think c++ 23 has something like this, Acts as a memory view in to a continuous data structure where we can skip elements while still having it presented as continuous)
* Mapped Array (unordered\_map where the actual values are located in an std::vector for good cache locality during iteration and fast lookup for any one element)

I'm definitely not best programmer ever so sorry if there's bugs lol.

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

What makes a game tick? Special Issue - Buffy the Performance Slayer · Mathieu Ropert
https://mropert.github.io/2026/05/05/making_games_tick_buffy_special/

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

Ensinando a calcular senos em linguagem C sem bibliotecas

Olá pessoal. Este vídeo ensina a calcular senos em C usando a Série de Taylor, sem recorrer à biblioteca <math.h>.

https://youtu.be/-V3icd6VLJY

Este é um projeto de extensão da USP de São Carlos (BCC-ICMC). Agradeço quem puder responder ao formulário que está na descrição!

(Já tentaram calcular senos sem usar <math.h>?)

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

Strategies for requiring designated initializers when constructing a type?

Given some aggregate like this:

struct InitParams {
int size = 0;
int capacity = 0;
};

And given that it is used in some factory function like this:

auto Make(InitParams ip = {}) -> std::optional<MyClass>;

I want to design the aggregate type to allow callsites like...

Make({ .size = 10, .capacity = 20 });
Make({ .size = 10 });
Make({ .capacity = 20 });
Make({});
Make();

But I also want to reject callsites like...

Make({ 10, 20 });
Make({ 10 });
Make({ 20 }); // Oops! This is the size, not the capacity!

I was hoping that reflection would unlock the ability to specify this on the type alone somehow, but I've been unable to figure out how to do it.

I can approximate this behavior using an overload set where a similar-but-different param type is accepted by a different Make overload but then that would result in default construction being ambiguous too. You can see that in action here:

struct DesignatedInitRequired {
int DONOTSPELLTHISFIELDNAME0;
int DONOTSPELLTHISFIELDNAME1;
};

auto Make(DesignatedInitRequired dir = {}) -> void = delete("Use designated init");

Make({ 10 }); // Ambiguous, ill formed (which is what I want)
Make({ 10, 20 }); // Ambiguous, ill formed (which is what I want)
Make({}); // Ambiguous, ill formed (which is NOT what I want)
Make(); // Ambiguous, ill formed (which is NOT what I want)

So I could make something to reflect on InitParams and produce DesignatedInitRequired, but that wouldn't be enough. Every function that accepts InitParams would need an overload for DesignatedInitRequired meaning that it becomes a property of the type AND its users, not just the type itself.

Any ideas on how to achieve my goal?

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

over 30 different talks and workshops from June 1st – 3rd. See the full schedule at [https://audio.dev/adc-japan-26/schedule/](https://audio.dev/adc-japan-26/schedule/)
* **ACCU On Sea Schedule Announced** – The ACCU on Sea schedule has been announced and includes over 60 sessions across the four days. Visit [https://accuonsea.uk/schedule/](https://accuonsea.uk/schedule/) for the full schedule.
* **C++Online Workshops Available** – C++Online have announced 14 workshops that will take place between the end of March and the start of June with more potentially being added if any workshops are oversubscribed. Find out more including the workshops that are available at [https://cpponline.uk/workshop-tickets-for-cpponline-2026-now-available/](https://cpponline.uk/workshop-tickets-for-cpponline-2026-now-available/)

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

17:00 UTC* – [https://cpponline.uk/workshop/ai-101/](https://cpponline.uk/workshop/ai-101/)

**C++Online One Day Beginner Workshops** – **Reduced from £345 to £150/$200/€175** (£90/$120/€105 for students)

1. **From Hello World to Real World – A Hands-On C++ Journey from Beginner to Advanced** – Amir Kirsh – 1 day online workshop available on *Thursday 21st May 08:30 – 16:30 UTC –* [https://cpponline.uk/workshop/from-hello-world-to-real-world/](https://cpponline.uk/workshop/from-hello-world-to-real-world/)

**C++Online Half Day Workshops** – £172.50/$230/€200 (£45/$60/€55 for students)

1. **Splice & Dice – A Field Guide to C++26 Static Reflection** – Koen Samyn – Half Day online workshop available on *Monday 25th May 09:00 – 12:30 UTC* – [https://cpponline.uk/workshop/splice-and-dice/](https://cpponline.uk/workshop/splice-and-dice/)

**C++Online Two Day Workshops** – £690/$920/€800 (£180/$240/€210 for students)

1. **AI++ 201 – Build a Matching Engine with Claude Code** – Jody Hagins – 2 day online workshop available on *May 28th – May 29th 09:00 – 17:00 UTC* – [https://cpponline.uk/workshop/ai-201/](https://cpponline.uk/workshop/ai-201/)

Eleven of these workshops had previews at the main C++Online Conference which took place on the 11th – 13th March. You can watch these preview sessions here: [https://www.youtube.com/playlist?list=PLHG0uo5c6V3KIeoLqvBbIqy5AXt\_Me\_cm](https://www.youtube.com/playlist?list=PLHG0uo5c6V3KIeoLqvBbIqy5AXt_Me_cm)

**Anyone who purchased a C++Online Main Conference ticket can also get a discount of however much they paid to attend the main conference.** 

Also if anyone is from a lower-income background or live in a country where purchasing power is limited, then it is recommended to reach out to C++Online on [info@cpponline.uk](mailto:info@cpponline.uk) as they will be able to give you a discount.

**ACCU on Sea Two Day Workshops**

1. **C++ Best Practices** – Jason Turner – 2 day in-person workshop available on 15th & 16th June 10:00 – 18:00 – [https://accuonsea.uk/2026/sessions/cpp-best-practices/](https://accuonsea.uk/2026/sessions/cpp-best-practices/)
2. **C++ Templates for Developers** – Walter E Brown – 2 day in-person workshop available on 15th & 16th June 10:00 – 18:00 – [https://accuonsea.uk/2026/sessions/cpp-templates-for-developers/](https://accuonsea.uk/2026/sessions/cpp-templates-for-developers/)
3. **Talking Tech (A Speaker Training Workshop)** – Sherry Sontag & Peter Muldoon – 2 day in-person workshop available on 15th & 16th June 10:00 – 18:00 – [https://accuonsea.uk/2026/sessions/talking-tech-a-speaker-training-workshop/](https://accuonsea.uk/2026/sessions/talking-tech-a-speaker-training-workshop/)

**ACCU on Sea One Day Workshops**

1. **C++ Software Design** – Klaus Iglberger – 1 day in-person workshop available on 15th June 10:00 – 18:00 – [https://accuonsea.uk/2026/sessions/cpp-software-design/](https://accuonsea.uk/2026/sessions/cpp-software-design/)
2. **C++23 in Practice: A Complete Introduction** – Nicolai M. Josuttis – 1 day in-person workshop available on 16th June 10:00 – 18:00 – [https://accuonsea.uk/2026/sessions/cpp23-in-practice-a-complete-introduction/](https://accuonsea.uk/2026/sessions/cpp23-in-practice-a-complete-introduction/)
3. **Secure Coding in C and C++** – Robert C. Seacord – 1 day in-person workshop available on 16th June 10:00 – 18:00 – [https://accuonsea.uk/2026/sessions/secure-coding-in-c-and-cpp/](https://accuonsea.uk/2026/sessions/secure-coding-in-c-and-cpp/)

All ACCU on Sea workshops take place in-person in Folkestone, England.

**OTHER NEWS**

* **C++ Under The Sea 2026 Announced** – C++ Under The Sea will once again take place on 15 & 16th October 2026 at Breepark in Breda, the Netherlands
* **C++ Under The Sea 2026 Workshops Announced** – C++ Under The Sea have announced 3 workshops that will take place on the 14th October 2026. Find out more at [https://cppunderthesea.nl/#workshops](https://cppunderthesea.nl/#workshops)
* **ADC Japan Schedule Announced** – ADC have announced their full schedule for their Japan event which will feature

Latest News From Upcoming C++ Conferences (2026-05-05)

This is the latest news from upcoming C++ Conferences. You can review all of the news at [https://programmingarchive.com/upcoming-conference-news/](https://programmingarchive.com/upcoming-conference-news/)

**TICKETS AVAILABLE TO PURCHASE**

The following conferences currently have tickets available to purchase

* **ADC Japan (1st – 3rd June)** – You can buy tickets at [https://peatix.com/event/4840445](https://peatix.com/event/4840445)
* **ACCU on Sea (15th – 20th June)** – You can buy standard tickets at [https://accuonsea.uk/tickets/](https://accuonsea.uk/tickets/) with discounts available for ACCU members.
* **CppCon (12th – 18th September)** – You can buy early bird tickets until June 26th at [https://cppcon.org/registration/](https://cppcon.org/registration/)
* **C++ Under The Sea** **(NEW – 14th – 16th October)** – You can buy early bird tickets at [https://sales.ticketing.cm.com/cppunderthesea2026/](https://sales.ticketing.cm.com/cppunderthesea2026/)
* **Meeting C++ (26th – 28th November)** – You can buy early bird tickets at [https://meetingcpp.com/2026/](https://meetingcpp.com/2026/)

**OPEN CALL FOR SPEAKERS**

* **CppCon (Last Chance)** – Interested speakers have until May 17th to submit their talks for CppCon which is scheduled to take place on 12th – 18th September in Denver Colorado. Find out more including how to submit your proposal at [https://cppcon.org/cfs2026/](https://cppcon.org/cfs2026/)
* **Meeting C++** **(NEW)** \- Interested speakers have until June 4th to submit their talks for Meeting C++ which is scheduled to take place on 26th - 28th November. Find out more including how to submit your proposal at [https://meetingcpp.com/meetingcpp/news/items/Submit-your-talks-to-Meeting-Cpp-2026-.html](https://meetingcpp.com/meetingcpp/news/items/Submit-your-talks-to-Meeting-Cpp-2026-.html)

**OTHER OPEN CALLS**

* **CppCon Call For Authors Now Open!** – CppCon are looking for book authors who want to engage with potential reviewers and readers. Read the full announcement at [https://cppcon.org/call-for-author-2026/](https://cppcon.org/call-for-author-2026/) 

**TRAINING COURSES AVAILABLE FOR PURCHASE**

Conferences are offering the following training courses:

**Last Chance To Register:**

1. **Stop Thinking Like a Junior** **– The Soft Skills That Make You Senior** – Sandor Dargo – Half Day online workshop available on *Friday 8th May 20:00 – 23:30 UTC* – [https://cpponline.uk/workshop/stop-thinking-like-a-junior/](https://cpponline.uk/workshop/stop-thinking-like-a-junior/)
2. **Jumpstart to C++ in Audio – Learn Audio Programming & Create Your Own Music Plugin/App with the JUCE C++ Framework** – Jan Wilczek – 1 day online workshop available on both Monday 11th & Tuesday 12th May 13:00 – 16:30 UTC – [https://cpponline.uk/workshop/jumpstart-to-cpp-in-audio/](https://cpponline.uk/workshop/jumpstart-to-cpp-in-audio/) – £150/$200/€175 (£90/$120/€105 for students)
3. **Safe and Efficient C++ for Embedded Environments** – Andreas Fertig – 1 day online workshop available on *Tuesday 12th May 09:00 – 17:00 UTC* – [https://cpponline.uk/workshop/safe-and-efficient-cpp-for-embedded-environments/](https://cpponline.uk/workshop/safe-and-efficient-cpp-for-embedded-environments/)
4. **Mastering std::execution (Senders/Receivers)** – Mateusz Pusz – 1 day online workshop available on *Friday 15th May 09:00 – 17:00 UTC* – [https://cpponline.uk/workshop/mastering-stdexecution-senders-receivers/](https://cpponline.uk/workshop/mastering-stdexecution-senders-receivers/)

**C++Online One Day Workshops** – £345/$460/€400 (£90/$120/€105 for students)

1. **How C++ Actually Works – Hands-On With Compilation, Memory, and Runtime** – Assaf Tzur-El – One day online workshop that runs over two days on *May 18th – May 19th 16:00 – 20:00 UTC* – [https://cpponline.uk/workshop/how-cpp-actually-works/](https://cpponline.uk/workshop/how-cpp-actually-works/)
2. **AI++ 101 – Build an AI Coding Assistant in C++** – Jody Hagins – 1 day online workshop available on *Friday 22nd May 09:00 –

CMake distributed + cached builds of LLVM Clang in 30 seconds
https://www.loom.com/share/4a72f93282024fac9934a6af455f8dde

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

CMake cold build of LLVM Clang in 30 seconds
https://www.loom.com/share/4a72f93282024fac9934a6af455f8dde

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

2026 Annual C++ Developer Survey "Lite" Results [PDF]
https://isocpp.org/files/papers/CppDevSurvey-2026-summary.pdf

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

Guys I developed a minimal parser combinator library and wrote a blog post

Links:

Github

Blog

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

I built a real-time terminal audio visualizer in C++17

Built a real-time audio visualizer for your terminal in using WASAPI & FFTW3.

Just shipped v1.1.0 with static linking for users, and compiler agnosticism for potential contributors. (MinGW, MSVC, Clang).


The executable runs on any windows machine with no dependencies.

https://github.com/majockbim/spectrum (there is a GIF in the README)

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

New C++ Conference Videos Released This Month - May 2026

**CppCon**

2026-04-27 - 2026-05-03

* Lightning Talk: A Pragmatic Approach to C++: Designing, Organizing and Writing Maintainable Code - Oleg Rabaev - [https://youtu.be/re4Oy1IVj-s](https://youtu.be/re4Oy1IVj-s)
* Lightning Talk: Causal Inference for Code Writing AI - Matt K Robinson - [https://youtu.be/craQCfj73CI](https://youtu.be/craQCfj73CI)
* Lightning Talk: Cut the boilerplate with C++23 deducing\_this - Sarthak Sehgal - [https://youtu.be/o3vjUo2qXNg](https://youtu.be/o3vjUo2qXNg)
* Lightning Talk: The Lifecycle of This CMake Lightning Talk - Yannic Staudt - [https://youtu.be/3DqRIxXVfiI](https://youtu.be/3DqRIxXVfiI)
* Lightning Talk: Catching Performance Issues at Compile Time - Keith Stockdale - [https://youtu.be/YK8Kwj9okRk](https://youtu.be/YK8Kwj9okRk)

**C++Online**

2026-04-27 - 2026-05-03

* From 5000ns to 200ns - 5 Modern C++ Techniques Live Demo - Larry Ge - [https://youtu.be/9HqyiTWLENY](https://youtu.be/9HqyiTWLENY)

**Audio Developer Conference**

2026-04-27 - 2026-05-03

* From Paper to Plugin - A Guided Tour of Digital Filters - Ross Chisholm, Joel Ross & James Hallowell - ADC 2025 - [https://youtu.be/QlyWAfRUF30](https://youtu.be/QlyWAfRUF30)
* From Idea to Online Sale - The Full Journey of Building an Audio Plugin - Joaquin Saavedra - ADCx Gather 2025 - [https://youtu.be/mJoAArwAmkc](https://youtu.be/mJoAArwAmkc)
* Finding OSCar: Electronic and Software Secrets of a Classic Vintage Synth - Ben Supper - ADC 2025 - [https://youtu.be/NbIZEur3h7Q](https://youtu.be/NbIZEur3h7Q)

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

Compile Your First C++26 Program with GCC 16.1
https://techfortalk.co.uk/2026/05/04/compile-your-first-c26-program-with-gcc-16-1/

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

Quantity-safe analog literals
https://morwenn.github.io/c++/2026/05/02/TSB011-quantity-safe-analog-literals.html

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

What are you missing most from the C++ standard library?

I like C++ but I realized that I keep implementing functionality that should be part of the standard library. Here are the features I'm missing most:

- an easy way to spawn a subprocess while controlling the standard input/output. something like popen but integrated with the standard I/O streams.
- UTF-8 and Unicode: convert between UTF-8, UTF-16, and UTF-32. convert a string to lower case and to upper case.
- networking: an easy way to implement a HTTP client or server
- cross-platform memory-mapped files
- thread-safe (and possibly lock-free) queues.
- persistent data structures
- JSON serialization/deserialization

What are you missing most from the C++ standard library?

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

High-throughput log parsing (~500K lines/sec) in C++ without regex — looking for performance ideas

I’m building a log ingestion + parsing pipeline in C++ and trying to push throughput as far as possible.



Current setup:

\- \~500K lines/sec

\- custom tokenizer (no regex)

\- string_view everywhere to avoid copies

\- batch processing

\- append-only write path



Next step:

I want to optimize the query side using:

\- SIMD for substring search

\- possibly precomputed token patterns



Questions:

\- Best SIMD strategies for substring / token matching?

\- Any experience with AVX2/AVX512 for log-like workloads?

\- At what point does memory bandwidth become the bottleneck?



Also curious if anyone has benchmarked SIMD vs naive scan for log-style data.



Any pointers or war stories appreciated.

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

The Most Confusing C++ Behavior
https://codestyleandtaste.com/most-confusing-C++-behavior.html

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