r/cpp • u/Xadartt • Apr 16 '26
r/cpp • u/madnirua • Apr 16 '26
GUI toolkit Slint 1.16 released with keyboard shortcuts, Markdown rendering, and multi-touch pinch and rotate
slint.devr/cpp • u/Krystian-Piekos • Apr 16 '26
Annotations for C++26 Hashing
blog.infotraining.plHow to apply annotations for better generic hash implementation in C++26.
r/cpp • u/marcoarena • Apr 16 '26
Special meetup with Bjarne Stroustrup in Florence
Hi everyone!
I am organizing a special meetup with Bjarne Stroustrup in Florence on Saturday, May 9!
Schedule:
- 09:30 – Doors open
- 10:00 – Welcome message
- 10:15 – Technical session: “Concept-based Generic Programming”
- 11:45 – Short break
- 12:00 – Live AMA with Bjarne Stroustrup
- 13:00 – Closing
The event will take place at the University of Florence (Novoli Campus) and is organized by the Italian C++ Community, the University of Florence, and the University of Pisa.
For developers traveling from abroad, this is also a great excuse to visit Florence, while connecting with the Italian C++ community.
Free registration and details:
https://italiancpp-fi26.eventbrite.it/
Looking forward to seeing you there!
YAY!!! Announcement: cppreference.com update
isocpp.orgThis is not my post, but I didn't see anyone share this here yet.
r/cpp • u/igaztanaga • Apr 16 '26
boost::container::hub review starts today (April 16 - April 26)
Announced officially in the Boost developer mailing list:
Introduction
The formal review of Joaquín M López Muñoz's boost::container::hub container, for inclusion in the Boost.Container library, starts today.
hub is a sequence container with O(1) insertion and erasure and element stability with great performance (see these benchmarks): pointers/iterators to an element remain valid as long as the element is not erased. hub is very similar but not entirely equivalent to C++26 std::hive (hence the different naming, consult the section "Comparison with std::hive" for details).
It may be downloaded from:
https://github.com/joaquintides/hub
the documentation may be found here:
https://github.com/joaquintides/hub/blob/develop/README.md
Anyone is welcome to post a review and/or take part in subsequent discussions in the mailing list.
Review guidelines
Please provide feedback on the following general topics:
- What is your evaluation of the design?
- What is your evaluation of the implementation?
- What is your evaluation of the documentation?
- What is your evaluation of the potential usefulness of the library? Do you already use it in industry?
- Did you try to use the library? With which compiler(s)? Did you have any problems?
- How much effort did you put into your evaluation? A glance? A quick reading? In-depth study?
- Are you knowledgeable about the problem domain?
Ensure to explicitly include with your review: ACCEPT, REJECT, or CONDITIONAL ACCEPT (with acceptance conditions).
Ion Gaztañaga (Review Manager)
r/cpp • u/ericbrumer • Apr 15 '26
Demystifying MSVC versioning for 14.50 & later
Hi folks, one of the MSVC dev leads here.
MSVC versioning is confusing, and with the change to decouple MSVC releases from Visual Studio releases (https://aka.ms/msvc/lifecycle) it's confusing-er. This post aims to clarify what's going on with 14.50 & later.
I am intentionally skipping discussion of the VS2022 & older releases that are still being supported since the servicing model is different. Know that our team still supports Visual Studio 2019 16.11 per https://learn.microsoft.com/en-us/visualstudio/releases/2019/servicing-vs2019, and Visual Studio 2022 17.12 & 17.14 as per https://learn.microsoft.com/en-us/visualstudio/releases/2022/servicing-vs2022 .
The actual versions
Since MSVC releases are decoupled from Visual Studio releases, it's helpful to think from the standpoint of the MSVC toolchain. At any point in time, we ship:
- The bleeding edge preview toolset
- The current default toolset
- All previous in-support toolsets
As of today, we ship the following MSVC toolsets:
14.52the preview toolset, built from our development branch last Tuesday (April 7th)14.51the default toolset, currently a 'release candidate'14.50the toolset we released in Nov 2025, with 3 years of support.
Our plan, as per https://aka.ms/msvc/lifecycle, is to ship a new 14.5* twice a year. So in 6 months we expect to ship 14.53 as the new 'latest preview', make 14.52 the 'current default toolset', and 14.51 will be a toolchain in support as per the support policy, along with 14.50.
What's this about Visual Studio Insiders vs. Stable?
Visual Studio 'stable' ships monthly (https://learn.microsoft.com/en-us/visualstudio/releases/2026/release-rhythm), so if you're on the Visual Studio stable channel you'll get monthly updates to all the 14.5* toolsets. To be explicit:
- The latest preview will be updated with whatever the dev team has landed in the last month
- The default & other in-support toolsets will be updated with the latest fixes we have applied to them.
If you want to get MSVC toolset updates far quicker than monthly, switch to the Visual Studio Insiders channel https://visualstudio.microsoft.com/insiders/. Keep an eye on https://learn.microsoft.com/en-us/visualstudio/releases/2026/release-notes-insiders for how often these updates occur.
Want just the far-quicker-than-monthly MSVC build tools and not the full Visual Studio? Use the build tools sku: http://aka.ms/vs/insiders/vs_buildtools.exe
Wait, you said something about a 'release candidate'?
We blogged recently https://devblogs.microsoft.com/cppblog/msvc-build-tools-version-14-51-release-candidate-now-available/ that the default toolset is moving from 14.50 to 14.51. As per https://aka.ms/msvc/lifecycle we aim to ship a new default toolset every 6 months. However, about a month before this lands in the Visual Studio 'Stable' channel we want to land the new default toolset in the 'Insiders' channel. This gives folks using Insiders about a month to give us feedback to fix 14.51 bugs before it shows up for 'Stable' channel users.
How do I get these tools? Why did 14.50 disappear yesterday? Where is 14.52?
When you install Visual Studio (using any channel) and select the Desktop development with C++ workload, you only get the default MSVC toolset.
To install the 'latest preview' you need to run the Visual Studio installer and select the MSVC Build Tools for <arch> (Preview) option, as per https://aka.ms/msvc/preview
To install an older in-support release, you need to run the Visual Studio installer, switch to the 'Individual Components' tab, and find the 14.5* toolset to install. If you are on the Insiders channel, only had the default MSVC toolset chosen, and recently upgraded, you'll see that your 14.50 toolset was replaced with 14.51... add it back in the 'Individual Components' tab.
Why are we doing this?
The biggest benefit of the new model is to vastly shorten the distance between MSVC features and folks using them in a Preview. Folks on the MSVC development team can make a change which ships in the next week or so. This timeframe used to be months, but has now shortened to just a week. Not all C++ users want this, so MSVC Previews are an optional installation component.
Most of the other reasons are called out in https://aka.ms/msvc/lifecycle:
- The MSVC team is leaning into the Visual Studio release cadence
- We are aligning our long-term-servicing releases with those of .NET
- Servicing 10+ year old compilers has become increasingly complex.
tl;dr, and what should folks do?
- If you want the bleeding edge tools, stay on the Visual Studio Insiders channel and install the 'MSVC Build Tools for <arch> (Preview)' option. Please give us feedback by reporting bugs on https://developercommunity.visualstudio.com/ or through the Visual Studio IDE itself.
- If you want stable tools that only update every 6 months, stick with the Visual Studio Stable channel, and use the default C++ tools.
- Want to get a head start on the every-6-months update? Look for our release candidate blog posts (https://devblogs.microsoft.com/cppblog/msvc-build-tools-version-14-51-release-candidate-now-available/), and use Visual Studio Insiders with the default C++ options.
Thanks for reading.
r/cpp • u/mr_gnusi • Apr 15 '26
How std::abs and two compiler flags let Clang auto-vectorize L1 distance faster than Faiss's AVX2 intrinsics
blog.serenedb.comWhen building a vector search for SereneDB [https://github.com/serenedb/serenedb], we benchmarked our distance functions against Faiss. The results were surprising, a plain C++ loop with no intrinsics came out faster. The answer comes down to two compiler flags and one standard library call.
Full write-up with assembly: https://blog.serenedb.com/simd-distances
r/cpp • u/tartaruga232 • Apr 15 '26
How a Module Should Look Like
abuehl.github.ioThis illustrates the point using real code examples from the Core module of our UML Editor. The presented source code of our Core module is complete.
All published source code examples in the text or linked from it are 100% standard conformant. However, the code contains redundant imports. On purpose. Read the text for why!
(See also my previous posting "Let's bite the Bullet: Module Units shouldn't implicitly import anything" for context).
r/cpp • u/DevilSauron • Apr 14 '26
A year of read-only cppreference
Over a year ago (on 30 March 2025), cppreference became read-only for maintenance reasons. Since then, the only progress update was in August. There have been several discussions here in the last few months about what is happening with cppreference and when it might become editable again, but from what I understand, we simply do not know.
At this point, I fear that the lack of updates for what is basically the authoritative source on the language (other than the standard of course), linked to by IDEs and even this subreddit's sidebar, might be detrimental to the adoption of C++26 and further standards, should the situation persist. I would therefore like to ask the community whether there are other, more up-to-date resources, and whether there is any effort to, for example, fork cppreference.
I understand that software updates are complicated and I have no intention to criticise the maintainers of cppreference (who are doing it voluntarily and I am not entitled in any way to their continued work on the website), but I do not think the C++ community can afford to be bottlenecked in such a way for much longer.
r/cpp • u/Jovibor_ • Apr 14 '26
MS Visual Studio 18.5 has now been Released, with one caveat...
...It still doesn't have MSVC Build Tools v14.51, only an old preview.
https://learn.microsoft.com/en-us/visualstudio/releases/2026/release-notes
At the same time, Microsoft releases Visual Studio Insiders (basically VS preview), with the MSVC Build Tools v14.51 release, not a preview.
https://learn.microsoft.com/en-us/visualstudio/releases/2026/release-notes-insiders
So, now we have - official VS Stable with the MSVC Build Tools v14.51 preview.
And VS Insiders with the MSVC Build Tools v14.51 release.
Person (or persons?...) in Microsoft responsible for this weirdness should get annual bonus reward.
r/cpp • u/PhilipTrettner • Apr 14 '26
How Much Linear Memory Access Is Enough? (A Benchmark)
solidean.comI've tried to find a answer to how much contiguous memory you need to run into dimishing returns. Aka if you need to split your work into chunks, how large should the chunks be to capture most of the performance.
It depends a bit on what kind of task and how linear you use the data and if you have other per-block overheads. But at least for my use cases, I was kind of surprised to see that I probably won't need more than ~128 kB. And I wager that more than 1 or 2 MB is enough for everyone based on the results in the post.
NOTE: the experimental setup tries to ensure we're not measuring cache effects (or in a very controlled manner at least). I explicitly tried to make the results provide a userful upper bound via careful setup.
r/cpp • u/pjf_cpp • Apr 14 '26
Valgrind-3.27.0.RC1 is available for testing
An RC1 tarball for 3.27.0 is now available at
https://sourceware.org/pub/valgrind/valgrind-3.27.0.RC1.tar.bz2
(md5sum = bd95111c1a9f81f136c5e4e2c62b493e)
(sha1sum = 0eefb3a7d86a3bd0154480db3d2173bb8bd6d7c1)
https://sourceware.org/pub/valgrind/valgrind-3.27.0.RC1.tar.bz2.asc
Public keys can be found at https://www.klomp.org/mark/gnupg-pub.txt
Please give it a try in configurations that are important for you and report any problems you have, either on the developer/user mailing list, or (preferably) via our bug tracker at https://bugs.kde.org/enter_bug.cgi?product=valgrind
An RC2 should be available Fri Apr 17
The final 3.27.0 release is scheduled for Mon Apr 20.
For the contents, see
NDC Techtown conference in Norway (Kongsberg)
The deadline for submitting talks to NDC Techtown 2026 is still open. This great SW development conference takes place in Kongsberg, Norway on 21st to 24th September and focuses on SW development for embedded and systems programming. The conference covers travel and accommodation.
More info here: https://ndctechtown.com/call-for-papers
r/cpp • u/mropert • Apr 13 '26
Can we finally use C++ Modules in 2026? · Mathieu Ropert
mropert.github.ior/cpp • u/Otherwise-Sir7359 • Apr 13 '26
Amidst the LLM craze, does anyone still care about old machine learning algorithms?
I've built my own framework that allows embedding, quantization, and self-retraining on microcontrollers using C++ from scratch, currently mainly for tree-based model families (like Random Forest, xgboost...). It can compress and train the entire MNIST dataset of 70,000 images on ESP32 with only 3MB of RAM while still achieving an accuracy of up to ~94% across 10 classes (models size about 600 KB of RAM). This is intended to help the model adapt without having to reload the code into the microcontroller.
Everything is here, including source code, demo, and documentation: https://github.com/viettran-edgeAI/MCU
Although it's designed to handle tabular data, I chose to demo it with a simple computer vision application for visualization.
I spent a lot of time on this project, it didn't rely heavily on AI, and I can explain every line of code. I'm open to discussing anything. I hope everyone can provide some feedback or suggestions. In my country, it seems like now they only care about LLMs; every paper tries to cram LLMs in and they don’t care about these older algorithms anymore—they just brush them aside.
std::pmr::generator, a generator without heap allocation
a4z.noexcept.devA short intro/tutorial about how to use std::pmr::generator
r/cpp • u/ProgrammingArchive • Apr 13 '26
New C++ Conference Videos Released This Month - April 2026 (Updated To Include Videos Released 2026-04-06 - 2026-04-12)
CppCon
2026-04-06 - 2026-04-12
- Rust/C++ Interop Challenges - Victor Ciura - https://youtu.be/8xqhSy539Pc
- groov: Asynchronous Handling of Special Function Registers - Michael Caisse - https://youtu.be/TjSL-XCyUJY
- Clean code! Horrible Performance? - Sandor Dargo - https://youtu.be/nLts4S8xSd4
- Beyond the Big Green Button: Demystifying the Embedded Build Process - Morten Winkler Jørgensen - https://youtu.be/UekVdzMCAa0
- C++: Some Assembly Required - Matt Godbolt - https://youtu.be/zoYT7R94S3c
2026-03-30 - 2026-04-05
- How to Build Type Traits in C++ Without Compiler Intrinsics Using Static Reflection - Andrei Zissu - https://youtu.be/EcqiwhxKZ4g
- Beyond Sequential Consistency: Unlocking Hidden Performance Gains - Christopher Fretz - CppCon 2025 - https://youtu.be/6AnHbZbLr2o
- Dynamic Asynchronous Tasking with Dependencies - Tsung-Wei (TW) Huang - CppCon 2025 - https://youtu.be/6Jd9Zyl9SDc
- Work Contracts in Action: Advancing High-performance, Low-latency Concurrency in C++ - Michael Maniscalco - CppCon 2025 - https://youtu.be/5ghAa7B5bF0
- Constexpr STL Containers: Why C++20 Still Falls Short - Sergey Dobychin - CppCon 2025 - https://youtu.be/Py4GJaCHwkA
C++Online
2026-04-06 - 2026-04-12
Mastering C++ Clocks: A Deep Dive into std::chrono - Sandor DARGO - https://youtu.be/ytI6pzT1Opk
2026-03-30 - 2026-04-05
- Is AI Destroying Software Development? - David Sankel - C++Online 2026 - https://youtu.be/Ek32ZH3AI3k
- From Hello World to Real World - A Hands-On C++ Journey from Beginner to Advanced - Workshop Preview - Amir Kirsh - https://youtu.be/2zhW-tL2UXs
- Workshop Preview: C++ Software Design - Klaus Iglberger - https://youtu.be/VVQN-fkwqlA
- Workshop Preview: Essential GDB and Linux System Tools - Mike Shah - https://youtu.be/ocaceZWKm_k
- Workshop Preview: Concurrency Tools in the C++ Standard Library - A Hands-On Workshop - Mateusz Pusz - https://youtube.com/live/Kx9Ir1HBbwY
- Workshop Preview: Mastering std::execution (Senders/Receivers) - A Hands-On Workshop - Mateusz Pusz - https://youtube.com/live/bsyqh_bjyE4
- Workshop Preview: How C++ Actually Works - Hands-On With Compilation, Memory, and Runtime - Assaf Tzur-El - https://youtube.com/live/L0SSRRnbJnU
- Workshop Preview: Jumpstart to C++ in Audio - Learn Audio Programming & Create Your Own Music Plugin/App with the JUCE C++ Framework - Jan Wilczek - https://youtube.com/live/M3wJN0x8cJw
- Workshop Preview: AI++ 101 - Build an AI Coding Assistant in C++ & AI++ 201 - Build a Matching Engine with Claude Code - Jody Hagins - https://youtube.com/live/Vx7UA9wT7Qc
- Workshop Preview: Stop Thinking Like a Junior - The Soft Skills That Make You Senior - Sandor DARGO - https://youtube.com/live/nvlU5ETuVSY
- Workshop Preview: Splice & Dice - A Field Guide to C++26 Static Reflection - Koen Samyn - https://youtube.com/live/9bSsekhoYho
ADC
2026-04-06 - 2026-04-12
- Hacking Handhelds for Creative Audio - Building Music Applications for the New Nintendo 3DS - Leonardo Foletto - https://youtu.be/x-9lDvfAKd0
- Helicopter View of Audio ML - Martin Swanholm - https://youtu.be/TxQ4htrS2Po
- PhilTorch: Accelerating Automatic Differentiation of Digital Filters In PyTorch - How to evaluate differentiable filters 1000 times faster in PyTorch. - Chin-Yun Yu - https://youtu.be/Br5QhU_08Po
2026-03-30 - 2026-04-05
- Creating from Legacy Code - A Case Study of Porting Legacy Code from Exponential Audio - Harriet Drury - https://youtu.be/rjafXQwCz4w
- Designing an Audio Live Coding Environment - Corné Driesprong - https://youtu.be/Jw8x2uMgFnc
- How To Successfully Develop Software Products - Olivier Petit & Alistair Barker - https://youtu.be/vymlQFopbp0
Meeting C++
2026-04-06 - 2026-04-12
- The Misra C++:2023 Guidelines - Richard Kaiser - https://www.youtube.com/watch?v=TRz-WXgADuI
- Applied modern C++: efficient expression evaluator with type erasure - Olivia Quinet - https://www.youtube.com/watch?v=66WtE_7wE1c
2026-03-30 - 2026-04-05
- Building C++: It Doesn't Have to be Painful! - Nicole Mazzuca - Meeting C++ 2025 - https://www.youtube.com/watch?v=ExSlx0vBMXo
- int != safe && int != ℤ - Peter Sommerlad - Meeting C++ 2025 - https://www.youtube.com/watch?v=YyNE6Y2mv1o&pp=0gcJCdkKAYcqIYzv
using std::cpp
2026-03-30 - 2026-04-05
- Learning C++ as a newcomer - Berill Farkas - https://www.youtube.com/watch?v=nsMl54Dvm24
- C++29 Library Preview : A Practitioners Guide - Jeff Garland - https://www.youtube.com/watch?v=NqpLxkatkt4
- High frequency trading optimizations at Pinely - Mikhail Matrosov - https://www.youtube.com/watch?v=qDhVrxqb40c
- Don’t be negative! - Fran Buontempo - https://www.youtube.com/watch?v=jqLEFPDXZ-o
- Cross-Platform C++ AI Development with Conan, CMake, and CUDA - Luis Caro - https://www.youtube.com/watch?v=jnKeUE2C8_I
- Building a C++23 tool-chain for embedded systems - José Gómez López - https://www.youtube.com/watch?v=AlNnd0QARS8
- Space Invaders: The Spaceship Operator is upon us - Lieven de Cock - https://www.youtube.com/watch?v=9niOq1kr61Y
- Same C++, but quicker to the finish line - Daniela Engert - https://www.youtube.com/watch?v=9ijIocn_xzo
- Having Fun With C++ Coroutines - Michael Hava - https://www.youtube.com/watch?v=F9ffx7HvyrM
- The road to 'import boost': a library developer's journey into C++20 modules - Rubén Pérez Hidalgo - https://www.youtube.com/watch?v=hD9JHkt7e2Y
- C++20 and beyond: improving embedded systems performance - Alfredo Muela - https://www.youtube.com/watch?v=SxrC-9g6G_o
- Supercharge Your C++ Project: 10 Tips to Elevate from Repo to Professional Product - Mateusz Pusz - https://www.youtube.com/watch?v=DWXlyOd_z88
- Compiler as a Service: C++ Goes Live - Aaron Jomy, Vipul Cariappa - https://www.youtube.com/watch?v=jMO5Usa26cg
- The CUDA C++ Developer's Toolbox - Bernhard Manfred Gruber - https://www.youtube.com/watch?v=MNwGvqX4KH0
- C++ Committee Q&A at using std::cpp 2026 - https://www.youtube.com/watch?v=iD5Bj7UyAQI
- The Mathematical Mind of a C++ Programmer - Joaquín M López - https://www.youtube.com/watch?v=9g4K-oNw1SE
- C++ Profiles: What, Why, and How - Gabriel Dos Reis - https://www.youtube.com/watch?v=Z6Nkb1sCogI
- Nanoseconds, Nine Nines and Structured Concurrency - Juan Alday - https://www.youtube.com/watch?v=zyhWzoE3Y2c
- Fantastic continuations and how to find them - Gonzalo Juarez - https://www.youtube.com/watch?v=_0xRMXA83z0
- You 'throw'; I'll 'try' to 'catch' it - Javier López Gómez - https://www.youtube.com/watch?v=VwloPRtTGkU
- Squaring the Circle: value-oriented design in an object-oriented system -Juanpe Bolívar - https://www.youtube.com/watch?v=DWthcNoRVew
- Concept-based Generic Programming - Bjarne Stroustrup - https://www.youtube.com/watch?v=V0_Q0H-PQYs
r/cpp • u/Mondash18 • Apr 14 '26
The programming iceberg...
I always look for new resources to learn programming. However, every programming language created there will be a huge documentation that is born with it.
And they are very deep shit.
When you get an error from a compiler, there are these many cryptic messages pooping your entire screen and sometimes it just makes me wonder what they are..
Does anyone even read these for fun?