C++ 2026 June Compiler Update
https://cppreference.com/cpp/compiler_support

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

C++ lifetimes. Is there an alternative way? Hylo subscripts achieve controlled lifetimes without viral annotations
https://hylo-lang.org/docs/user/language-tour/subscripts/

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

Logicwise: Factory for C++ Concepts
https://github.com/frog-singing/Logicwise

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

cppman.nvim: Browse C++ docs from inside Neovim

I hope it's okay that I post this here. If not, just let me know and I'll remove it.

I made a small Neovim plugin called cppman.nvim for browsing C++ reference docs directly inside Neovim.

I use it myself quite a bit, so I thought I'd share it in case anyone else finds it useful, or has ideas for improvements.

It adds :CPPMan, uses cppman's local index, and opens the docs in a floating buffer. It also supports both fzf-lua and snacks.nvim.

I tried to keep it lightweight and not too opinionated.

Repo: https://github.com/simonwinther/cppman.nvim

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

Vcpkg Binary Caching on GitHub Finally Made Easy
https://github.com/LegalizeAdulthood/vcpkg-github-cache

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

Repo of utilities written with C++ reflection

I started exploring C++26's static reflection, and I'm putting together a repo with utilities written with it
First utility I have, is std::visit, but for C unions (with some small constraints to avoid UB ofc)
I'd love to hear any suggestions and feedback! Repo

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

C++ RVO: Return Value Optimization for Performance in Bloomberg C++ Codebases - Michelle Fae D'Souza
https://www.youtube.com/watch?v=WyxUilrR6fU

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

Projects being in "Show and Tell" is bad.

Because of this, nearly all posts are just conference links and blog links. Projects deserve their own post and are the source of actual fun discussion. I propose that the Show and Tell rule be removed, but Show and Tell post can remain if a project that lame appears.

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

Parsing JSON at compile time with C++26 static reflection (Daniel Lemire)
https://lemire.me/blog/2026/06/14/parsing-json-at-compile-time-with-c26-static-reflection/

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

Looking for collaborators to build an OpenGL engine in C++

I'm currently developing a small OpenGL engine in C++ as a personal learning project and foundation for future graphics and simulation applications.

​

The project is open source:

https://github.com/HG9032/OpenGLengine

​

I'm looking for people who are interested in computer graphics, OpenGL, game engines, rendering, or C++ development and would like to contribute, learn together, or discuss ideas.

​

The engine currently includes:

​

\- Window management (GLFW)

\- Shader management

\- Mesh rendering

\- Transform system

\- Basic rendering pipeline

​

Planned features:

​

\- Camera system

\- Scene management

\- Materials and textures

\- STL model loading

\- Lighting

\- Thermal simulation visualization

​

Whether you're experienced or just learning OpenGL, feel free to reach out if you'd like to collaborate.

​

https://github.com/HG9032/OpenGLengine

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

Building a High-Throughput C++ FIX Server: From Single-Core Efficiency to Multi-Core Scaling
https://substack.com/home/post/p-202082856

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

arewemodulesyet.org passes the mark of 100 projects with modules support for the first time.
https://arewemodulesyet.org/

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

New C++ Conference Videos Released This Month - June 2026 (Updated to Include Videos Released 2026-06-08 - 2026-06-14)

**C++Online**

2026-06-08 - 2026-06-14

* Monads Meet Mutexes - Arne Berger - [https://youtu.be/AisGDOoF82U](https://youtu.be/AisGDOoF82U)
* Lock-free Queues in the Multiverse of Madness - Dave Rowland - [https://youtu.be/eHmjkFdQl00](https://youtu.be/eHmjkFdQl00)

2026-06-01 - 2026-06-07

* Writing C++ Code is Challenging, Writing Performant C++ Code is Daunting - Dmitrii Radivonchik - [https://youtu.be/R2sm9mailuU](https://youtu.be/R2sm9mailuU)
* Case Study - Purging Undefined Behavior and Intel Assumptions in a Legacy Codebase - Roth Michaels - [https://youtu.be/H-dHTeSR\_n8](https://youtu.be/H-dHTeSR_n8)

**ADC**

2026-06-08 - 2026-06-14

* Low Latency Android Audio with improved CPU Performance - Phil Burk - [https://youtu.be/DtBrKEu0R0g](https://youtu.be/DtBrKEu0R0g)
* Linux as the Conductor - Driving Pre-Compiled Audio DSP Kernels on C7x for Real-Time Processing - Vishnu Pratap Singh - [https://youtu.be/Auq9WnHNtPo](https://youtu.be/Auq9WnHNtPo)
* Overview of Granular Synthesis - Avrosh Kumar - [https://youtu.be/QpBV24nWg2M](https://youtu.be/QpBV24nWg2M)
* The Agentic Symphony - Multi-Agent Collaboration for Emergent Musical Composition - Meera Sundar - [https://youtu.be/QMUXoImgTIA](https://youtu.be/QMUXoImgTIA)

2026-06-01 - 2026-06-07

* Beyond the DAW - Designing a Procedural Sequencer Powered by Music-Theory - Romy Dugue & Cecill Etheredge - [https://youtu.be/48sH4wQUDAs](https://youtu.be/48sH4wQUDAs)
* From DAW Users to Audio Developers - Teaching JUCE to Creative Minds - Milap Rane - [https://youtu.be/200UrugEanY](https://youtu.be/200UrugEanY)
* Music Design and Systems - Achieving Inaudibly Complex Systems in Video Games - Liam Peacock - [https://youtu.be/R6raBvCNsQo](https://youtu.be/R6raBvCNsQo)
* Developing for Avid’s Audio Ecosystem - Rob Majors - [https://youtu.be/91-7YWVKRE4](https://youtu.be/91-7YWVKRE4)

**CppCon**

2026-06-01 - 2026-06-07

* Lightning Talk: Navigating Code Reviews as a Code Author - Ben Deane - [https://youtu.be/zygtgvHp\_MM](https://youtu.be/zygtgvHp_MM)
* Lightning Talk: Eight Consteval Queens and Compile-Time Printing - Sagnik Bhattacharya - [https://youtu.be/gNPhJrXLiIs](https://youtu.be/gNPhJrXLiIs)
* Instrumenting the Stack: Strategies for End-to-end Sanitizer Adoption - Damien Buhl - [https://youtu.be/TSrymTXw5w8](https://youtu.be/TSrymTXw5w8)

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

Cross-Language Data Types

https://ekxide.io/blog/cross-language-data-types

Have you ever thought about sharing data across language boundaries without serialization? This blog post highlights the challenges behind this endeavor and how they can be overcome. Note: I'm not the original author of the blog post, but since the author does not have a Reddit account, I post it on his behalf.

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

LLMs with C and C++ - switch from HFT to AI lab

I'm a senior C++ dev recently started working with a neolab (who works with anthropic). Thought I would write some of observations i made.

* I had experimented with LLMs for a while before making the switch. LLMs fail a lot on C and C++ due to harder nature and powerful nature of language.
* Talking purely from benchmarks, languages like python and JS (the vibecoder's first language) have very hard benchmarks - think fixing actual bug that touches 3 different modules from scratch with access to tools like grep, cat and python3 executer.
* Whereas, benchmarks for C and C++ are at basic QA style questions. I have added a task from benchmark, which fable 5 could not solve.
* LLMs do not have understanding of latest ISO standards - for some reasons it switches to C++17 again and again
* LLMs are trash at template metaprogramming. Try debugging CRTP type of errors.

Looking at the efforts and progress, I am still not sure if we will see LLMs writing MRs to linux kernel. The approach they used for vibecoding languages do not care about memory safety, thread safety and performance much. It would be interesting to see the space evolve.

PS: a example from benchmark

PS2: i'm not associated with benchmark. they say the code is taken from real github issues.

Observe the following faulty CPP code snippet and error type list. Your task is to select the error type of the code based on the error list provided.
You only need to answer error type. Do not write anything else in your response.
For example, if the code snippet is missing a semicolon, Your output should be 'missing_colons'.
faulty code:
```cpp
#include <bits/stdc++.h>

int countPermutations(int n, int k, int qq[])
{
const int N = 505, P = 998244353;
int *q = new int[n + 10];
int m, dp[N][N], jc[N], f[N], ans;
memset(q, 0, sizeof(int) * (n + 1));
memset(dp, 0, sizeof(dp));
memset(jc, 0, sizeof(jc));
memset(f, 0, sizeof(f));
ans = 0;

for (int i = 1; i <= n; i++)
q[i] = qq[i - 1];
dp[0][0] = f[0] = 1;
for (int i = jc[0] = 1; i <= n; i++)
jc[i] = 1LL * jc[i - 1] * i % P;
for (int i = 1; i <= n; i++)
{
f[i] = jc[i];
for (int j = 1; j < i; j++)
f[i] = (f[i] + P - 1LL * f[j] * jc[i - j] % P) % P;
}
for (int i = 1; i <= n; i++)
{
for (int j = 0; j < i; j++)
for (int k = 1; k <= n; k++)
dp[i][k] = (dp[i][k] + dp[j][k - 1] * 1LL * f[i - j] % P) % P;
}
m = 0;
for (int i = 1; i <= n; i++)
if (q[i] > q[i + 1])
{
m = i;
break;
}
if (m == n)
{
for (int i = k; i <= n; i++)
ans = (ans + dp[n][i]) % P;
}
else
{
for (int i = m + 1; i <= n; i++)
{
if (i != m + 1 && (q[i - 1] > q[i] || q[i] < q[m]))
break;
int c = k + i - n - 1;
if (c >= 0)
ans = (ans + dp[m][c] * 1LL * jc[i - m - 1] % P) % P;
}
}
return ans;
}
```
error list:
['Delayed Execution', 'Improper HTML structure', 'Missing $', 'Missing mut', 'Misused := and =', 'Misused === and ==', 'Misused =>', 'Misused Macro Definition', 'Misused Spread Operator', 'Misused begin/end', 'Misused match', 'Misused var and val', 'Unused Variable', 'algorithm_error', 'condition_error', 'double_bug', 'faulty_indexing', 'function_error', 'html_unclosed_label', 'html_value_error', 'html_wrong_label', 'illegal_comment', 'illegal_indentation', 'illegal_keyword', 'illegal_separation', 'json_content_error', 'json_digital_leader_is_0', 'json_duplicate keys', 'json_struct_error', 'markdown_content_error', 'markdown_title_error', 'markdown_unclosed_error', 'missing_backtick', 'missing_colons', 'misused ==and=',

'misused templte', 'misused_let', 'operation_error', 'Pointer error', 'quadruple_bug', 'triple_bug', 'type_error', 'unclosed_parentheses', 'unclosed_string', 'undefined_methods', 'undefined_objects', 'variable_error']

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

I built native Claude Code integration for Visual Studio (the one IDE that didn't have it)

Claude Code has official IDE plugins for VS Code and JetBrains but nothing for Visual Studio. There's an open GitHub issue with a lot of +1s, so I built it.

It speaks the same protocol the official plugins use, so the CLI connects automatically. Claude's edits open in Visual Studio's native diff window with Accept / Reject / Reject-with-feedback instead of terminal prompts. It also auto shares your compiler errors and current selection as context, and there's a panel with live token tracking for the session.

It doesn't make any model calls of its own, it just drives the IDE half.

Code and a quick 30-second visual demo: https://github.com/firish/claude\_code\_vs 

Would be grateful if anyone takes the time to actually check it out and share feedback!

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

Designing a plugin "collector" interface for a telemetry module — sanity check on C-ABI vs C++, self-describing schemas, and not over-engineering

I'm designing the interface for a telemetry/observability module in a C++ machine-vision inspection platform, and I'd love a sanity check from anyone who's built plugin/collector systems. I've made a bunch of decisions and mostly want to hear *where I'm wrong* or *what I'm not considering*.

**Context.** The platform is plugin-based — a host app dynamically loads modules and device adapters as DLLs/.so. The telemetry module collects HW/OS metrics and correlates them with the app's own activity (which stage is running, how many run concurrently, etc.) into a forensic log, under a hard constraint: **\~zero impact on the hot inspection path**. I want collection to be extensible — add a new metric source *without touching the core interface*.

**What I have so far — a "collector" abstraction with two tiers:**

1. **Internal collectors (in-process, C++ abstract interface).** These subscribe to the host's typed event bus. The subscribe API is a compile-time template keyed on the C++ event type, so these *can't* sit behind a C ABI — they're a C++ `ICollector` compiled into the module.
2. **External collectors (pure C-ABI plugin DLLs).** These only poll OS/HW/kernel (no host types). They implement a small C ABI (`init/finalize/open/close/describe/collect`), are `dlopen`'d at runtime, and run on a dedicated thread.

Boundary rule: *needs the event bus / a host type → internal C++; OS/HW polling only → external C-ABI.*

**Specific decisions I'm unsure about:**

* **Pull-based C-ABI:** host calls `collect(handle, row_sink_cb, userdata)` on a dedicated thread; the collector pushes result rows into the sink callback (scalar = 1 row, top-N = N rows).
* **Self-describing schema:** `describe(handle)` returns a JSON string declaring each field's `{key, type, unit}` \+ gating metadata (`minLevel`, `osMask`). The host's writer/viewer need no code changes for a new metric.
* **"Day-1" safety contracts** baked into the header: (1) every C function wraps its body in try/catch so no C++ exception crosses the `extern "C"` boundary; (2) the `describe()` string is owned by the collector, valid only until the next `describe`/`close`; (3) `close()` must quiesce the collector's threads before returning.

**Questions I'd love opinions on:**

1. **Two parallel interfaces (C++ internal + C-ABI external) — smell or justified?** Maintaining two shapes of the same idea bugs me, but forcing everything through a C ABI loses typed event subscription. Reasonable seam, or is there a cleaner approach (thin C++ wrapper over one C ABI, message-passing instead of typed events, …)?
2. **Self-describing JSON from** `describe()` **vs a versioned C struct.** JSON is flexible and avoids ABI breaks when fields change, but it's stringly-typed. How do you evolve a plugin schema/ABI safely — version constants, capability negotiation at init, a real IDL (flatbuffers/protobuf) at the boundary?
3. **C-ABI safety idioms.** Are try/catch-everywhere + string-ownership + teardown-quiesce the standard playbook for C++ behind a C ABI, or am I missing cleaner patterns (error codes + out-params, never returning owned pointers)? Is documenting these in header comments enough, or should they be enforced structurally?
4. **Pull vs push, mixed cadence.** Some collectors are cheap/fast (NVML poll), others slow/blocking (kernel queues). Everything is "host pulls on one thread" now. Would you isolate blocking collectors (thread per impact class? async with a deadline?), or is one slow-probe thread + an "impact" self-declaration in `describe()` enough?
5. **Versioning a plugin C-ABI for real.** What's worked for forward/backward compat as the ABI grows — a version int from `init`, additive-only rules, a vtable-of-function-pointers struct instead of named exports?
6. **Avoiding over-engineering.** I have exactly *one* real external collector today (kernel nonpaged pool) and a couple internal ones; the team is wary of speculative plugin machinery.

How do you decide how much extensibility to build now vs. when the 2nd/3rd collector actually shows up?

**Constraints, for context:** cross-platform (Windows/Linux), vendor-SDK-gated (don't build a collector if its SDK is absent), hot path untouched (producers only push to a lock-free ring; all heavy work off-thread).

Thanks — happy to expand on any part. Mostly after "here's what you'll regret" and "here's the boring standard way to do X."

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

{fmt} 12.2 released with a performant type-safe C11 API, faster float formatting, improved C++20 module support and more

https://github.com/fmtlib/fmt/releases/tag/12.2.0

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