Interesting behavior from C++20 to C++23

Consider the following snippet

int& get()
{
    int x;
    return x;
}


int main()
{
}

on GCC it compiles for C++20 but not for C++23

It returns with the error:

test.cpp:4:12: error: cannot bind non-const lvalue reference of type 'int&' to an rvalue of type 'int'

C++ is now suddenly treating the variable x as an rvalue?


Edit: Im not talking about dangling reference, thats just for the sake of the example

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

Trying to create a paper piano

Trying to create a paper piano

I came across many paper piano projects where they detect finger and paper touch using opencv and some even use neural network but the problem still remains that it's not accessible for everyone. Some people still don't have computers or even laptops. So I thought about a paper piano project that uses only the mobile phone and itscamera and using a cheap phone stand to set the correct angle and a printed paper. So a mobile phone which most people have, an app to download for free and a mobile stand with a printed paper which altogether costs approx $ 2.5. The reason for this post is that I may not work on this project anytime sooner so if anyone wants to work on this project help yourself and if you come across some references or a project similar to this then add it in the comment.

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

Libraries of, installing, and depending on C++20 modules

Until now, much of the discourse around C++20 modules has been around the tooling, and actually getting modules to work at all. I believe that now, in mid-2026, the tooling is mostly mature: the three largest compilers support most use-cases of modules. IDEs like CLion, and lint tools like ReSharper C++ and clangd support modules, with some caveats. CMake, xmake, Ninja, and other fledgling build systems have full support for modules. Many prevalent C++ libraries and projects have been recently modularised or are in the process of modularising.

I hope I'm not being too presumptive in saying the community is more or less ready (albeit horribly late...) to move to the next step, and start discussing how C++20 modules can and should tie in to inter-project work, rather than simply using modules within a project.

To begin with, I don't think the standard says anything about 'libraries'; these are existing paradigms grandfathered in from C or earlier. There are many axes we have to discuss here:

- Static archives
- Dynamically-linked libraries
- Symbol visibility defaults with `__declspec( dllexport )`
- Primary module interface-only (hereafter, PMI) libraries such as `module vulkan`
- Configuring such modules with macros
- Built module interface (hereafter, BMI) and binary interface (hereafter, ABI) compatibility; currently, BMIs are simply not portable, not even within a compiler toolchain across versions
- How shared objects, static archives, BMIs, and PMIs interact
- How build systems, toolchains, and package managers like conan and vcpkg interact with everything

For instance, consider I'm writing a 3D game engine. I want the following modules:

- vulkan which export imports std
- argparse
- glm
- glaze
- quill, which imports fmt
- fmt itself
- winrt, if running on Windows

I want to provide my own PMI that has export class Engine, and maybe some other functionality like abstractions over the 3D graphics APIs, an object and entity manager, a mini shader graph generator, and more. I also have export imported some symbols from my dependencies, especially std. I want to choose to configure my engine to render on D3D or Vulkan. Consumers can then load the library, add assets like textures, meshes, skeletons, shaders; they can plug the engine into a bigger project which might include a script interpreter in C++, real-time spatial audio and physics packages, some networking, and an XML-based UI system, and produce a complete game or visualisation executable.

Now, I mention these details just to flesh out the example to give a sense of a reasonably complicated library-esque project.

How does one even think about delivering this 'engine library' to the consumer? The traditional three configs are headers + precompiled DLL, headers + source, or headers only. Each have their established workflows. Source-available can be compiled into the entire binary with whole-program optimisation; headers-only libraries are exceptionally easy to vendor (just copy-paste). Header-only libraries can also be easily customised with consumer macros. PMIs, however, being translation units, cannot; we hit this when installing `module vulkan`. We need some module-compatible way to describe 'library configuration' beyond simply co-opting macros, something like Rust's `cfg`.

There is talk of the Common Package Specification (CPS), P1689R5, and P3286, but nothing concrete yet, especially since there has been no massive (commercial) push for

modules (at least, not until recently). This talk at NDC looks at a possible cargo-esque future for C++.

I'm writing this to spur some discussion here in the C++ community, and ask what some veterans of the build system/toolchain/package manager community think.

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

Propagating exceptions from destructors with std::exception_ptr
https://www.sandordargo.com/blog/2026/07/08/exception_ptr

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

C++Now 2026 Keynote: Reflection Is Only Half the Story - Barry Revzin
https://youtu.be/DZTkT1Cq_aY

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

What Made You Fall in Love With C++—and What Almost Made You Quit?

This is a great opportunity to share your life story as a C++ programmer: how you started, why you chose C++, what your first impressive project made purely for fun was, and what kind of job you do.

You can share all of that here!

I would also love to hear the criticism—the days when you wanted to escape from boring CRUD and API projects, as well as the happiest days of your life when you finally got the chance to work on your dream job.

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

Building a tool for offline coding practice on flights/trips — would you actually use this?

Hey everyone,

I'm a developer working on a side project/startup idea and wanted to get honest feedback before I sink more time into it.

The idea: a website where you pick a programming language and a specific track (e.g., Go basics, or backend development with Go), and it generates a downloadable offline package — documentation, tutorials, and exercises — packed into a zip file. You download it before you lose internet access (long flight, train, remote area, wherever), and once offline you just open it in your browser like a normal site. No connection needed.

I know there are already tools like DevDocs, Dash, and Zeal that let you save documentation offline. What I'm trying to do differently is focus on structured learning tracks with exercises, not just a raw doc viewer — more like a self-contained mini-course you can work through with zero connectivity.

I'm trying to figure out monetization without doing a subscription (that already feels like the wrong model for something people might use a handful of times a year). Current thinking is one-time purchase per track, or eventually partnering with airlines.

Genuine questions for you all:

1. Would you pay a small one-time fee for something like this? (like 5 dollars)
2. Would you use it even if it were free — or does existing offline documentation (Dash, DevDocs, etc.) already solve this well enough for you?

Trying not to build something nobody wants, so brutally honest feedback is welcome. Thanks!

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

Looking for C++ / Systems / HFT Internship or New Grad Opportunities

Title: Looking for C++ / Systems / HFT Internship or New Grad Opportunities

Hi everyone,

I'm currently looking for Software Engineering Intern, C++ Developer, Systems Programming, or HFT/Low-Latency Engineering opportunities.

Over the past year, I've focused heavily on C++, Linux, competitive programming, and building projects that pushed me beyond my comfort zone.

A few highlights about my profile:

Codeforces Specialist
CodeChef 4★
Strong foundation in DSA and Modern C++
Comfortable with Linux, Git, and CMake

I've built two major C++ projects:

A systems programming project focused on low-level software engineering and performance.
A low-latency order book/trading systems project that has received 50+ GitHub stars and valuable feedback from engineers with HFT backgrounds, including people associated with firms like IMC Trading and Jane Street. Their suggestions helped me improve both the project and my understanding of high-performance systems.

I'm particularly interested in roles involving:

High-Performance C++
Systems Programming
Backend Engineering
Low-Latency Infrastructure
Distributed Systems
Quant/HFT Technology

I'm always eager to learn, take on challenging engineering problems, and contribute to real-world systems.

If your company is hiring interns or new graduates, or if you know of any opportunities that match my profile, I'd greatly appreciate any referrals, advice, or connections.

Feel free to DM me if you'd like to connect.



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

Programs, Not Objects: How I Stopped Designing Architecture and Started Writing a 3D Editor
https://alexsyniakov.com/2026/07/11/programs-not-objects-how-i-stopped-designing-architecture-and-started-writing-a-3d-editor/

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

i had to port my odin game to cpp

i finally got the game working in web but it doesnt look right butler status rawptr/hexbound:html5 i had to use butler and port from odin to c https://rawptr.itch.io/hexbound

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

GoCL – A C++20 Vulkan proxy with zero‑overhead dispatch, SPIR‑V rewriting, and lazy‑loaded backends

I’ve been working on a Vulkan optimisation layer and static library called GoCL. The C++ side ended up more interesting than I expected, so I wanted to share a few design choices.

It’s a Vulkan proxy (vulkan_proxy.so / vulkan‑1.dll) and a static library (GoCL_core.a) that adapts rendering to the GPU’s actual capabilities at runtime. The proxy intercepts Vulkan calls and modifies them before they reach the driver, while the static library provides the same logic directly to engines that link against it. All C++20.

C++ details that might interest this sub:

Capability oracle – on device creation, the engine queries every relevant physical device feature (texture compression, float16 support, descriptor indexing tiers, memory budget, etc.) and stores the result in a plain `DeviceCapabilities` struct. Every subsystem reads from that struct; there’s no virtual dispatch or runtime capability checks on the hot path. Decisions are data‑driven and branch‑predictable.
Proxy dispatch chain – the proxy hooks Vulkan entry points by patching a dispatch table (the loader’s vkGetDeviceProcAddr pattern). The table is populated at vkCreateDevice time. On Linux the library is linked with -Wl,-z,now so all dynamic symbols are resolved eagerly at load time. Callgrind confirms zero lazy‑binding overhead in the render loop – dlopen/dlsym calls appear only in initialisation functions.
SPIR‑V rewriting – unsupported shader features (FP16, oversized descriptor sets) are detected and the binary is rewritten before the driver sees it. The rewriter is a lightweight in‑memory pass that widens FP16 ops to FP32 and splits large descriptor bindings. No external compiler, no LLVM dependency; it’s just a handful of C++ functions operating on the SPIR‑V binary blob.
Lazy‑loaded transcoder – the heavy Basis Universal encoder (used for ASTC→ETC2 texture conversion) is separated into gocl_transcoder.so, loaded via dlopen / LoadLibrary only when an ASTC texture is encountered. The static initialisers of the transcoder are therefore never invoked unless actually needed, keeping the proxy’s baseline footprint minimal.
Zero per‑frame overhead – Callgrind instruction counts on a GTX 960M running 75+ Sascha Willems Vulkan examples: the proxy has \~3.8% fewer total instructions than native (3.806B vs 3.955B). FPS and frame times are identical within noise. All the work happens once at pipeline creation or texture load; the render loop is untouched.
Dual‑licensed under Apache‑2.0 OR MIT. Tested in CI with Mesa Lavapipe.

Architecture write‑up (covers the capability model, shader emulation, proxy internals, and the lazy‑load design):
GoCL – Architecture

GitHub: GoCL

Happy to discuss the C++ side – the capability oracle and the SPIR‑V rewriter in particular were fun to keep simple and predictable.

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

AFXDP implementation in C++ plus benchmarks against DPDK on real NICs

I developed a C++ library which implements AF\XDP and DPDK as backends for latency critical network processing tasks. I notice there are only few benchmarks comparing AF_XDP against DPDK on the same NICs therefore I aim to fill this gap. I used C++20 since that is my strongest language and it interfaces nicely with the low-level driver or linux kernel code.

The AF_XDP implementation is here: https://github.com/ASherjil/ABTRDA3/blob/master/src/backends/AF\_XDP/AFXDP.hpp


The comprehensive benchmark 24h results are here:

https://github.com/ASherjil/ABTRDA3/blob/master/docs/Benchmarks.md

One point that I think is underappreciated: a commonly marketed advantage of AF_XDP is that it doesn't unbind the NIC driver, so the interface stays visible to ip link and ethtool. That's true for Intel NICs, where DPDK requires binding to vfio-pci. But it's not true for mlx5 (ConnectX-4/5/6/7), which is a bifurcated driver — the NIC stays fully visible to the kernel while DPDK runs. On Mellanox hardware, the main practical argument for AF_XDP largely disappears.

On implementation effort: even with libbpf and libxdp, custom AF_XDP has high code complexity and plenty of driver-specific quirks. Its four lock-free SPSC rings (fill/RX/TX/completion) are counterintuitive and fairly difficult to comprehend. Without the helper libraries I'd call it a serious long-term project. For most use cases I'd recommend DPDK's AF_XDP PMD instead of a from-scratch implementation — in my results, my custom implementation performed only marginally better than DPDK’s AF_XDP PMD. I've documented the driver specific issues in the repository.

Let me know if you guys have any feedback about the code, bench-marking methodology or anything else. Or any questions I'm happy to answer I don't really mind.

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

Upa URL parser library v2.5.0 released

* Aligned with the most recent revision of the [WHATWG URL Standard](https://url.spec.whatwg.org/).
* Implemented [URL Pattern Standard](https://urlpattern.spec.whatwg.org/).
* Added support for compiling as a [C++20 module](https://github.com/upa-url/upa/blob/main/doc/modules.md).

More information: [https://github.com/upa-url/upa/releases/tag/v2.5.0](https://github.com/upa-url/upa/releases/tag/v2.5.0)

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

C++Now 2026 Keynote: Multidimensional Parallel Standard C++ - Mark Hoemmen
https://youtu.be/VAwW_s1uEHY

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

Need free resources for dsa in C++

I don't want to watch video lectures as they are very time consuming but I want topic wise all the theory covered and questions to practice. . in a structured way so that I can track how much I know. . , . I have tried a few platforms but they ask for a subscription fee and it's annoying. . Need free resources for dsa in C++

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

AI usage for cpp at work

I am lead architect and maintainer of my firm main app backend, spanning around 2M LOC of c++.

Industry is : capital markets, low latency, custom kernel drivers, fpga...

I often talk with peers at other firms and I see a shy usage of AI compared to what feels like the global trend.

On my side, my firm does not pay for any AI related stuff. We are allowed to use our personnal plan for work in which case will get a pro membership compensation (claude or gpt or anything) on salary but we are not allowed to paste production code into it.

I know the app very well and do everything by hand (i mean the normal way) but use the chat version of any ai to generate some things for me, like "im using opensource lib x and lib y, please generate an SQL connection pool , you may use locks and condition variable for this, cpp 20".
Then i paste it and modify it a I see fit.

Im totally happy with that and the company is successful.

I do use AI but just chat, to gather data on subjects and summarize/report. Get some ideas but basically not much code related.

And you whats your experience as a c++ dev ?

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

New C++ Conference Videos Released This Month - July 2026 (Updated to Include Videos Released 2026-06-22 - 2026-06-28)

C++Now

2026-07-06- 2026-07-11

Keynote: Reflection Is Only Half the Story - Barry Revzin - C++Now 2026 - [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-06 - 2026-07-11

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-06 - 2026-07-11

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
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/1uvecu0
@r_cpp

[Project] Quantum Simulator | C++20 | Looking for Contributors

---
Hello!

We’re a team of two Computer Engineering students (UPC), about to start our second year, currently developing a **high-performance standalone quantum simulator** with its own visual interface. We’ve registered for the **Barcelona Supercomputing Center (BSC) Hackathon** and are looking to bring **one or two key contributors** into the team.

That said, the hackathon is **not** the reason this project exists—it’s actually the other way around. The project came first, so you can expect this to be a long-term effort (possibly lasting years).

The project is fully remote (you can contribute from anywhere in Spain without ever meeting us in person if that's what you prefer). However, if you're based in Barcelona and would like to join us physically for the hackathon, you'd be more than welcome. If you choose that option, we can register you as well.

**An important note about us:** We're students and beginners in this field. Even though we take the project very seriously and strive for technical rigor, we see it as both a production and a learning project. We want to build something ambitious, but our main goal is to learn, wrestle with the hardware, and grow as engineers. We're not looking for experts—we're looking for learning partners.

### **What is the project?**

The project follows a modular architecture split into three independent layers:

1. **Front-End / UX (Unity):** An interactive 3D environment for visualizing quantum registers and Bloch sphere rotations (C#).
2. **Backend / Orchestrator (C++):** The intermediate layer responsible for managing and routing computation requests from the front-end to the numerical core.
3. **Data Engine (C++):** A reusable data-processing engine optimized for CPU-intensive workloads through a data-oriented design (DOD). The quantum simulator is simply its first major use case. If the architecture proves successful, we'd like to reuse the engine for other high-performance computing problems in the future.

We should mention that the project is still in its early stages, but it's starting to take shape. In any case, this is the perfect moment to contribute to its foundations and make a meaningful impact.

---
### Main technologies

* C++20
* CMake
* Unity (C#)
* Linux
* Git
* Python (for mathematical prototyping)

---

### Who we're looking for

We're looking to fill one or both of the following roles. We don't expect previous professional experience—only enthusiasm for low-level development, an interest in quantum computing, and a willingness to learn as part of a team.

#### **Position A: Theory (Mathematics / Physics / Data Science)**

We're looking for someone with a solid understanding of Linear Algebra and an interest in Quantum Computing. Your work will focus on algorithmic formalization:

* Designing and structuring mathematical operators, complex transformation matrices, and the logic behind quantum state entanglement.
* Translating those ideas into clear algorithms that the rest of the team can later implement in C++.
* *Requirement:* Basic programming skills (Python, beginner C++, or similar) so you can communicate effectively with the team.

#### **Position B: C++ Developer (Beginner)**

If you're interested in C++, Linux, and understanding how hardware works under the hood, but you're still learning and looking for a real project to get your hands dirty:

* You'll help connect the different parts of the project: implementing efficient data loading and management, and helping build the bridge between our C++ code and the Unity environment. In the medium term, you'll also help plan and extend the computation engine alongside us.

* *What you'll gain:* Hands-on experience managing real memory, understanding cache optimization, and applying Data-Oriented Design (DOD) principles while working as part of a team.

---

### **Expected commitment**

* Around **8–12 hours per week** (flexible).
* Since this is a long-term project, we understand that people may eventually need to step away. If that happens,

we only ask that whatever you've been working on is documented or left in a clean state so the rest of the team can continue smoothly.

---

### **What we offer**

* A collaborative learning environment with no hierarchy or commercial pressure.
* A project with a modular architecture and a strong emphasis on code quality.
* The opportunity to compete in—and receive mentorship from experienced HPC professionals during—the BSC Hackathon.
* Complete flexibility and fully remote work if that's what you prefer.

If you're excited about learning by programming close to the hardware or designing the mathematics behind a real quantum simulator, send us a private message telling us a bit about yourself.

#### **Note:** Even if you don't fully master these topics yet, but you're passionate about low-level programming or quantum physics, feel free to contact us anyway. We're not experts either—we're just developers at an early stage of our journey.

---

### Repositories

- **Atomix (Data Processing Engine):**
https://github.com/ElectroX79/Atomix_sandbox

- **Entangle (Backend / Orchestrator):**
https://github.com/Ironduck2/Entangle

*(Still in a very early stage, as its development depends on the evolution of the engine.)*

---

### Hackathon

- **8th MareNostrum Hackathon (BSC):**
https://www.bsc.es/en/news/events/mnhack26-8th-marenostrum-hackathon

---

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