C++ - Reddit

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

The C++ Business Model, a new challenge for WG21 https://a4z.noexcept.dev/blog/2026/05/03/The-Cpp-Business-Model.html https://redd.it/1t2tajl @r_cpp

GoodLog: a small C++17 wrapper around Boost.Log for colored output, rotation and hex dumps Hi r/cpp, I built GoodLog, a small C++17 wrapper around Boost.Log. The goal is not to replace general-purpose logging libraries like spdlog. I wanted a reusable layer for C++ projects that already depend on Boost, so the common Boost.Log setup does not have to be repeated across modules. It currently supports: \- colored console output \- automatic file:line source location \- rotating log files \- separate severity filters for console and file sinks \- optional channel filtering \- hex dump helpers for binary buffers \- CMake demo and GoogleTest entry points GitHub: https://github.com/SoleyRan/Log The project is still early, and I would especially appreciate feedback on the macro API, CMake integration, and whether the channel logging interface should be simplified. https://redd.it/1t2pmyu @r_cpp

Auxid: An Orthodox C++20 Base Library for Data-Oriented Design NOTE: All and any colorations/PRs are welcome, **EXCEPT FOR AI GENERATED GARBAGE**. Hey folks, Let me introduce Auxid: a C++20 platform/library aimed at high-performance applications (specifically game engines and systems software) built around **Orthodox C++** and **Data-Oriented Design (DOD)**. I know the C++ ecosystem isn't short on utility libraries, but I built Auxid to bridge a specific gap: getting the predictable memory layouts and fast compile times of C-style systems programming, without losing the ergonomics of standard C++20 algorithms. Mainstream C++ often relies on heavily templated, node-based STL containers that can thrash CPU caches or introduce hidden heap allocations. Auxid strips that back. Where the STL is already the right tool for the job (like `std::filesystem`), Auxid exposes it through thin, zero-overhead wrappers. For the rest, it provides DOD-friendly replacements. Here’s a quick architectural overview of what’s inside: * **Cache-Friendly Containers:** Includes a sparse-dense hash map, strictly aligned vector types, and small-string-optimized (SSO) strings. * **Plays Nice with** `<algorithm>`: Auxid’s containers use iterators that satisfy C++20 iterator concepts (like contiguous iterators), meaning you can seamlessly pass them into `std::sort`, standard ranges, and other utilities. * **Total Allocator Control:** No surprise allocations in the hot path. Auxid integrates [rpmalloc](https://github.com/mjansson/rpmalloc) out of the box for extremely fast, thread-caching heap allocation, alongside custom arena allocators. * **Lightweight Error Handling:** Instead of exceptions, it relies on a union-based `Result<T, E>` and `Option<T>` that compile to tight representations, paired with Rust-style `AU_TRY` macros. * **Explicit Control Flow:** Auxid provides an opt-in CMake target (`auxid_platform_standard`) that strictly disables C++ exceptions (`-fno-exceptions` / `/EHs-c-`) to enforce predictable performance characteristics. It's designed to be dropped directly into existing CMake projects via `FetchContent`: FetchContent_Declare( auxid GIT_REPOSITORY https://github.com/I-A-S/Auxid.git GIT_TAG main ) FetchContent_MakeAvailable(auxid) If you are interested in DOD, alternative standard libraries, or just want to critique the architecture, I’d really value this community's feedback. * **Core Library:** [I-A-S/Auxid](https://github.com/I-A-S/Auxid) * **Project Scaffold:** [I-A-S/Auxid-Project-Template](https://github.com/I-A-S/Auxid-Project-Template) Licensed under Apache 2.0. Eager to hear what you think not just about the project, but the principles of Orthodox C++ as a whole! https://redd.it/1t2nyai @r_cpp

I built a C++ integer-to-string library based on a new AVX-512 paper I built a small C++ integer-to-string conversion library based on a new paper by Jael Champagne Gareau and Daniel Lemire, "Converting an Integer to a Decimal String in Under Two Nanoseconds": - Project: https://github.com/simditoa/simditoa - Paper: https://arxiv.org/abs/2604.26019 The paper looks at decimal formatting for integers, which shows up in logging, JSON/CSV/XML serialization, database output, and other places where numbers eventually become text. The interesting part, and the part I wanted to experiment with, is that it uses AVX-512 IFMA instructions to extract multiple decimal digits in parallel, avoiding the usual repeated division/modulo loop and avoiding large lookup tables. The library exposes a small to_chars-style API:

#include "simditoa.h"

char buf[simditoa::MAX_DIGITS + 1];
size_t len = simditoa::to_chars(12345, buf);
buf[len] = '\0';

Current project shape: - C++17 - int64_t and uint64_t support - AVX-512 IFMA + VBMI path for supported x86-64 CPUs - portable scalar fallback - CMake package/install support - tests for edge cases, digit lengths, and randomized values - a simple benchmark against std::to_chars The README benchmark currently shows simditoa::to_chars at about 15.82 ns/int versus 36.35 ns/int for std::to_chars on the tested setup, roughly 2.3x faster in that run. The paper reports stronger results for its full algorithm and benchmark suite, including single-core performance ahead of other tested methods, but my repo should be treated as a compact implementation based on the paper rather than a full reproduction of every variant in it. The core trick is neat: for 8-digit chunks, it uses AVX-512 IFMA with precomputed constants based on floor(2^52 / 10^k) to compute digit positions in parallel, then gathers the digit bytes with AVX-512 byte permutation. Larger values are split into chunks. https://redd.it/1t2ny62 @r_cpp

Migrating a small C++ code base to C++26 (modules, import std and contracts) https://jonastoth.github.io/posts/migrate_cxx26/ https://redd.it/1t2kkoh @r_cpp

When to actually use a set https://dubeykartikay.com/posts/why-never-use-std-unordered-set/ https://redd.it/1t2im2j @r_cpp

Modern C++ Programming https://federico-busato.github.io/Modern-CPP-Programming/ https://redd.it/1t2a4jz @r_cpp

I made C++ coding problems where you build things like a mini Redis or a tiny interpreter — looking for feedback I’ve been building a small platform with coding problems that are more “systems-style” rather than typical algorithm exercises. The idea is to practice by building simplified versions of real components, but still in a problem format (input/output + tests). Some examples: * implement a Redis-like server (TCP + protocol parsing) * build a tiny interpreter * create a virtual filesystem * write an expression evaluator The problems are: * runnable directly in the browser (no setup) * open-ended (you decide design/architecture) * supporting multi-file submissions I’m trying to keep them doable in a few hours, not huge multi-day projects. I’m curious what people here think: * does this kind of problem feel useful for improving practical C++ skills? * or would you prefer something more guided / closer to full projects? Still early, so any feedback would be really helpful. Link: [https://elitecode.pro/](https://elitecode.pro/) https://redd.it/1t2941b @r_cpp

oo-alloc: i made a comprehensive learning resource for allocators in C++ hi! i made a memory allocation library/learning resource. i wanted to learn more about them and i couldn't find one comprehensive source of knowledge, so i decided that i'll make one of my own:\]. it currently has these basic allocator types: arena (linear), stack, pool, free list, free tree, tracking, buddy, slab. i gave my best to describe everything clearly in the readme, also added svg diagrams (written in Typst, btw). i plan to implement a bucket/size-segregated free list allocator as well. hoping anyone will find this resource useful! https://github.com/nihiL7331/oo-alloc https://redd.it/1t287xq @r_cpp

Post examples of using reflections in your projects What the title says. I just want to see what interesting things people are using reflection for now that its in gcc. Thanks. https://redd.it/1t25byx @r_cpp

Does anyone maintain an impl of the Chandler Carruth map API? Lightning Talk (C++Now 2019, 8min): https://youtube.com/watch?v=kye4aD-KvTU In 2019, Chandler presented the above talk describing a C++ map API. It's not compatible with the standard map types, but for greenfield projects I think it's an excellent choice. I've considered implementing it myself, but hash tables are very subtle and finicky. I'd rather rely on a robust implementation. Abseil has some excellent hash tables, but to my knowledge they do not support the small size/small buffer optimization. Chandler's hypothetical API does. Would be great to have the SIMD probing algorithm from Abseil implemented for an SSO map type. https://redd.it/1t21nhu @r_cpp

CppCon 2025: Can Standard C++ Replace CUDA for GPU Acceleration? - Elmar Westphal https://www.youtube.com/watch?v=EOvukoCyW7A https://redd.it/1t1kopc @r_cpp

Mathieu Ropert: The Performance Mindset https://youtu.be/o-C6puc7nOk https://redd.it/1t1k7k2 @r_cpp