Can someone please break down lambdas for me



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

Efficient C++ Programming on Modern 64-bit CPUs, part 1 of Chapter 4

Well, I'm starting to publish (VERY DRAFT) Chapters from my (and Dmytro Ivanchykhin's) upcoming book, "Efficient C++ Programming for Modern 64-bit CPUs". Comments are extremely welcome (as before, we're committed to fixing all the issues highlighted in comments).

The first installment is the first part of Chapter 4: https://6it.dev/blog/on-cpu-physics-and-cpu-cycles-80730

In Vol. 1, the most interesting will probably be Chapter 9, with about 200 (sic!) practical de-pessimization hints.

Beware: this is not a book on optimizations (though some techniques will be covered in Appendixes A and B in Vol. 2) - this is a book on de-pessimizations; for optimizations - please refer to the excellent book by Denis Bakhvalov (though we're sure that de-pessimizations should be seen as a prerequisite for optimizations 😉).

Bracing for impact...

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

Comparing std::simd with Highway

From TL of Highway, some thoughts on pros and cons of std::simd by comparison:

https://github.com/google/highway/blob/master/g3doc/std\_simd\_comparison.md

Happy to discuss.

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

Recommendations for brushing up on modern cpp (ideally C++ 20)

Starting my first job as a new grad in the aerospace sector and need to brush up on modern C++ and looking for solid resources to understand the current fundamentals of the language. Thanks in advance!

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

C++

I want to learn C++ to make games on unreal engine 5, any suggestions from where I can learn C++ level 0 to advance ???

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

Crazy idea: reducing function coloring in function templates and enabling reuse, is it possible by caller-injected marker?

I was reading a paper about resumable functions short ago and I wonder if a language extendion would be possible that would work the following way:


// Poor man's syntax
std::copyif(myrange, coawaitable (...) { coawait ... });

How would it work? Taking advantage that templates are code to be generated, at the place where the function is called, the compiler would generate a coawait for the function, making it reusable.




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

Trip report: June 2026 ISO C++ standards meeting (Brno, Czechia)
https://herbsutter.com/2026/06/13/brno-trip-report/

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

Spatial Canvas: a single-file C++/Win32/Direct3D 11 zoomable window manager that puts your live windows on an infinite canvas

I've been building a zoomable-UI (ZUI) window manager for Windows in C++ and

wanted to share the architecture, since the interesting part is how you keep

dozens of live windows rendering at once.



Each window is captured via Windows.Graphics.Capture (FreeThreaded frame pool,

poll-based, lock-free) into a persistent D3D11 texture, then drawn as a

1:1-pixel textured quad in world space on a borderless fullscreen swapchain.

Pan/zoom is just a camera transform. A D2D/DWrite overlay draws the rest:

title labels, a world-anchored dot grid, the minimap, docks.



The hard problem: if you move/hide windows off-screen to composite them, DWM

occlusion-throttles them and Windows.Graphics.Capture starts returning black

or stale frames. Your canvas fills with black tiles. So there is no input

simulation and no off-screen hiding. Instead, each window "parks" in a 2px

visible strip at the bottom of the primary monitor — 2px is enough that DWM

keeps compositing it, so the capture stays live, but it's hidden behind the

canvas. When you cross a zoom threshold (or double-click), the real HWND is

moved (SetWindowPos) onto its quad's screen rect and given focus; now you're

typing into the actual window, not a proxy. Pull back and it returns to the

strip. Two states per window: parked (live texture on the canvas) and

swapped-in (the real window).



Other bits:

\- Single translation unit (\~3300 lines, Canvas.cpp), entry RunCanvasApp().

\- Idle-throttled main loop (dirty flag + MsgWaitForMultipleObjectsEx) so it

doesn't burn the GPU when nothing changes.

\- Device-lost (TDR / sleep-wake) does a full D3D/D2D/WGC rebuild; an unhandled-

exception filter un-parks windows on crash so nothing is stranded in the strip.

\- Single 559 KB exe, statically linked — no .NET / VC redist.



A few things that bit me along the way:

\- IsBorderRequired(false) / the borderless-capture path black out capture on

some Windows builds — removed.

\- Content-sized CopySubresourceRegion + a drain-to-newest loop also produced

black tiles; a single TryGetNextFrame + full CopyResource is the proven path.

\- Added a cbuffer field the pixel shader reads, but bound the cbuffer only to

the vertex stage → every tile came out alpha=0 (invisible). If a stage reads

a cbuffer, bind it to that stage.



Repo + 30s demo: https://github.com/13auth/spatial-canvas



It's an early prototype and I'd genuinely appreciate critique on the capture/

compositing approach. (Heads-up: source-available but not OSS-licensed — happy

to explain the reasoning in the comments.)

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

Report from the Brno 2026 ISO C++ Committee meeting - mp-units
https://mpusz.github.io/mp-units/HEAD/blog/2026/06/13/report-from-the-brno-2026-iso-c-committee-meeting/

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

Catcheer: A minimalist, zero-config native C++ WebView wrapper for HTML5 apps and games. Baseline executable is ~333 KB.
https://github.com/nzxy-dev/Catcheer

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

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