Latest News From Upcoming C++ Conferences (2026-06-16)

This is the latest news from upcoming C++ Conferences. You can review all of the news at https://programmingarchive.com/upcoming-conference-news/

TICKETS AVAILABLE TO PURCHASE

The following conferences currently have tickets available to purchase

ACCU on Sea (15th - 20th June) (Last Chance) \- You can buy standard tickets at [https://accuonsea.uk/tickets/](https://accuonsea.uk/tickets/) with discounts available for ACCU members.
CppCon (12th - 18th September) \- You can buy early bird tickets until June 26th at https://cppcon.org/registration/
C++ Under The Sea (14th - 16th October) \- You can buy early bird tickets at [https://sales.ticketing.cm.com/cppunderthesea2026/](https://sales.ticketing.cm.com/cppunderthesea2026/)
Meeting C++ (26th - 28th November) \- You can buy early bird tickets at https://meetingcpp.com/2026/

OPEN CALL FOR SPEAKERS

ADC (Last Chance) \- Interested speakers have until June 28th to submit their talks for ADC which is scheduled to take place on 9th - 11th November. Find out more including how to submit your proposal at [https://audio.dev/adc-bristol-26/call-for-speakers/](https://audio.dev/adc-bristol-26/call-for-speakers/)

OTHER OPEN CALLS

CppCon Call For Posters Now Open \- Interested poster presenters have until July 15th to submit their applications for the CppCon main conference which is scheduled to take place from 14th - 18th September. For more information including how to apply visit https://cppcon.org/cppcon-2026-call-for-poster-submissions/
CppCon Call For Authors Now Open! \- CppCon are looking for book authors who want to engage with potential reviewers and readers. Read the full announcement at [https://cppcon.org/call-for-author-2026/](https://cppcon.org/call-for-author-2026/) 

TRAINING COURSES AVAILABLE FOR PURCHASE

Conferences are offering the following training courses:

C++Online

1. AI++ 101 - Build an AI Coding Assistant in C++ \- Jody Hagins - 1 day online workshop available on Friday 24th July 16:00 - 00:00 UTC/0900-1700 PDT \- [https://cpponline.uk/workshop/ai-101/](https://cpponline.uk/workshop/ai-101/)
Watch the preview session here https://youtu.be/suP5zA7QqW4

CppCon Online Workshops

9th - 11th September

1. Modern C++: When Efficiency Matters \- Andreas Fertig - 3 day online workshop available on 9th – 11th September 09.00 – 15.00 MDT - https://cppcon.org/class-2026-when-efficiency-matters/
2. System Architecture And Design Using Modern C++ \- Charley Bay - 3 day online workshop available on 9th – 11th September 09.00 – 15.00 MDT - https://cppcon.org/class-2026-system-architecture-and-design-using-modern-cpp/

21st - 23rd September

1. C++ Fundamentals You Wish You Had Known Earlier \- Mateusz Pusz - 3 day online workshop available on 21st– 23rd September 09.00 – 15.00 MDT - https://cppcon.org/class-2026-cpp-fundamentals/
2. C++23 in Practice: A Complete Introduction \- Nicolai Josuttis - 3 day online workshop available on 21st– 23rd September 09.00 – 15.00 MDT - https://cppcon.org/class-2026-cpp23-in-practice/
3. Programming with C++20 \- Andreas Fertig - 3 day online workshop available on 21st– 23rd September 09.00 – 15.00 MDT - https://cppcon.org/class-2026-programming-with-cpp20/

26th - 27th September

1. Using C++ for Low-Latency Systems \- Patrice Roy - 2 day online workshop available on 26th– 27th September 09.00 – 17.00 MDT -

https://cppcon.org/class-2026-low-latency/

CppCon Onsite Workshops

All onsite workshops will take place in the Gaylord Rockies in Aurora, Colorado

12th & 13th September

1. Advanced and Modern C++ Programming: The Tricky Parts \- Nicolai Josuttis - 2 day in-person workshop available on 12th & 13th September - 09:00 - 17:00 - https://cppcon.org/class-2026-tricky-parts/
2. C++ Best Practices \- Jason Turner - 2 day in-person workshop available on 12th & 13th September - 09:00 - 17:00 - https://cppcon.org/class-2026-best-practices/
3. How Hardware Gets Hacked: Breaking and Defending Embedded Systems \- Nathan Jones - 2 day in-person workshop available on 12th & 13th September - 09:00 - 17:00 - https://cppcon.org/class-2026-hardware-hack/
4. Mastering `std::execution`: A Hands-On Workshop \- Mateusz Pusz - 2 day in-person workshop available on 12th & 13th September - 09:00 - 17:00 - https://cppcon.org/class-2026-execution/
5. Performance and Efficiency in C++ for Experts, Future Experts, and Everyone Else \- Fedor Pikus - 2 day in-person workshop available on 12th & 13th September - 09:00 - 17:00 - https://cppcon.org/class-2026-performance-and-efficiency/
6. Talking Tech \- Sherry Sontag - 2 day in-person workshop available on 12th & 13th September - 09:00 - 17:00 - https://cppcon.org/class-2026-talking-tech/

 13th September

1. AI++ 101 : Build a C++ Coding Agent from Scratch \- Jody Hagins - 2 day in-person workshop available on 12th & 13th September - 09:00 - 17:00 - https://cppcon.org/class-2026-AI101/
2. Essential GDB and Linux System Tools \- Mike Shah - 1 day in-person workshop available on 13th September - 09:00 - 17:00 - https://cppcon.org/class-2026-essential-gdb/

19th & 20th September

1. AI++ 201: Building High Quality C++ Infrastructure with AI \- Jody Hagins - 2 day in-person workshop available on 19th & 20th September - 09:00 - 17:00 - https://cppcon.org/class-2026-ai201/
2. Function and Class Design with C++2x \- Jeff Garland - 2 day in-person workshop available on 19th & 20th September - 09:00 - 17:00 - https://cppcon.org/class-2026-function-class-design/
3. High-performance Concurrency in C++ \- Fedor Pikus - 2 day in-person workshop available on 19th & 20th September - 09:00 - 17:00 - https://cppcon.org/class-2026-high-perf-concurrency/

OTHER NEWS

(NEW) C++Now Early Access Now Open \- Anyone who attended C++Now 2026 can now get early access to the C++Now YouTube Videos. Visit [https://cppnow.org/announcements/2026/06/attendee-early-video-access/](https://cppnow.org/announcements/2026/06/attendee-early-video-access/) for more information
(NEW) Voting on the Meeting C++ Talks Has Begun \- For more information on how to vote, visit https://meetingcpp.com/meetingcpp/news/items/The-voting-on-the-talks-for-Meeting-Cpp-2026-has-begun-.html for more information
ADC Call For Speakers Now Open \- Interested speakers have until June 28th to submit their talks for ADC which is scheduled to take place on 9th - 11th November. Find out more including how to submit your proposal at [https://audio.dev/adc-bristol-26/call-for-speakers/](https://audio.dev/adc-bristol-26/call-for-speakers/)
CppCon 2026 Attendance Support Ticket Program Now Open! \- Includes free tickets for people who would not be able to attend otherwise. Find out more including how to

apply at https://cppcon.org/cppcon-2026-attendance-support-ticket-program/

Finally anyone who is coming to a conference in the UK such as C++ on Sea or ADC from overseas may now be required to obtain Visas to attend. Find out more including how to get a VISA at https://homeofficemedia.blog.gov.uk/electronic-travel-authorisation-eta-factsheet-january-2025/

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

immutable<>, complement of C++26 std::indirect<> and std::polymorphic<>

C++26 introduces [`std::indirect<>` and `std::polymorphic<>`](https://wg21.link/p3019) (reference implementation at [github.com/jbcoe/value_types](https://github.com/jbcoe/value_types/)):

* `std::indirect<T>` is like a value-minded `std::unique_ptr<T>` sans polymorphism support. `std::indirect<T>` is movable if `T` is movable and copyable if `T` is copyable.
* `std::polymorphic<B>` is like a value-minded `std::unique_ptr<B>` for polymorphic bases `B`. `std::polymorphic<B>` can hold an object of any copyable class `D` which is an instantiable subclass of `B`. `std::polymorphic<B>` is copyable; its copy constructor will polymorphically clone the underlying object.

Both types are designed to be non-nullable. For lack of destructive move semantics, both have a moved-from state which can be identified with the `valueless_after_move()` member function.

As far as I can tell, the design of these is based on Sean Parent's "concept–model idiom". Remembering his presentation on the topic (https://sean-parent.stlab.cc/papers-and-presentations/#value-semantics-and-concept-based-polymorphism), I noticed that there is an obvious complement to `indirect<>` and `polymorphic<>` which I provisionally dub `immutable<>`:

* `immutable<T>` is like a value-minded `std::shared_ptr<const T>`. It is cheaply copyable (no deep copy), with no movability requirements imposed on `T`. It can hold an object of any instantiable subtype of `T`.

[Possible implementation + some tests on Compiler Explorer](https://gcc.godbolt.org/z/qh3K3d196)

Does this make sense? I find it very useful for building persistent data structures. In fact, it seems so obvious to me that I'm surprised this wasn't already in P3019.

*Edit:* minor correction

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

Boosting Adobe Photoshop’s Performance with MSVC and SPGO - C++ Team Blog
https://devblogs.microsoft.com/cppblog/boosting-adobe-photoshops-performance-with-msvc-and-spgo/

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

LibF++: Persistent Containers and Iterators with Value Semantics
https://github.com/GJDuck/libfpp

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

Function Composition Arc: C++17 -> C++20 -> C++23

For those that may be interested, I took a piece of educational code written years ago that composes an arbitrary number of functions and showed how to evolve it to take advantage of modern C++ features using ranges and functional programming.

https://freshsources.com/code-capsules/composing-functions/



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

When The C/C++ Users Journal Disappeared

https://freshsources.com/blog/files/cpp-source.html

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

GCC 17 Lands Initial Infrastructure For C++29
https://www.phoronix.com/news/GCC-17-std-CPP29-Experimental

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

Module setup guide for clang/LLVM + vscode stack + cmake

I was searching the interweb for any actual guide on how to setup modules with import std and everything.


Sadly i couldn't find any in my reasonable 10 minutes of googling that guides and explains on all the steps, a tutorial per say ( im not / didnt using AI )

I added cmake at the end in the title because from what i understand this is needed always currently with modules?

Can anyone guide me here on what's needed to move into the future brrr.

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

Seq v2.1 release
https://github.com/Thermadiag/seq

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

Project TSAR-MCP: A Zero-Dependency Orthodox C++ Framework for Edge AI. Because I write DB drivers for a living and AI was getting away from me.

Hi everyone,

Out of Minnesota 26 years ago IBM sent me to Germany, into a basement (truly) on-site at SAP in Walldorf to port kernels to run on IBM hardware (mostly on IBM i, the predecessor AS/400; but also database drivers for SAP application servers on everything else).

That's the background, the consequence is everything I do is written in C++ — mostly because I know and love it, but also because anything we ship needs to be self-contained. Intrigued by giving AI hands, I WANTED to make MCP servers I could use on-site and ship; therefore, I NEEDED to do it in C.

A true story before I sign off: In January I opened up Gemini and said, "I want to build a helloWorld MCP server in C."

The AI replied: "That will be somewhat difficult, there are easier ways."

I asked, "Why is it difficult??" (the second '?' was a bit of my ego).

Gemini replied: "Well, you'll need to parse JSON, handle raw I/O, and return strict JSON-RPC back to the client."

I told it, "One moment, let me show you something." (again my ego), I attached my JSON parser engine file (JSONParser.h) and said, "We have a JSON parser." (I typically talk to an LLM as a colleague working on the same project—for a reason, but that's a different story). This BNF parsing engine, by the way, is based on the same bedrock that powers our database driver (with SQL grammar, of course) built almost 2 decades ago.

Amusingly, the AI read the code and completely shifted its tone: "Oh, well then it's not so difficult."

My helloWorld became serious when I realized, with stdio over ssh, I could deliver an mcp endpoint in the SAP kernel to have it available on every database or remote application server running SAP. MCPServer_sapControl is my vision; approval is a different matter, but nevermind. Being enterprise-ready, TSAR-MCP-based servers are self-diagnosing — verbose operational traces are exposed to the client LLM, meaning even remote servers show the client what goes right and what goes wrong.

Enough details to bore you, the rest of the history is visible in the repository which I tagged with three teaching versions: the first is a simplistic sequential helloWorld MCP server that works out of the box; the second, an aspect server which does the same; the third tag is the version it is today — a fully asynchronous sampling MCP engine. The head version includes a full set of boilerplates.

I hope someone finds it useful, and I'm here for discussion if anyone wishes to.

Repository: https://github.com/IBM/tsar-mcp

Project Pages: https://ibm.github.io/tsar-mcp/

Cheers,

... Eric

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

What is the point of Emscripten?

Lately I was writing a manual for building my development environment incase I need to build it again.

&#x200B;

I look at the platforms I want to target, and see Emscripten, for wasm32 and wasm64. Lately, I saw an article, saying that all major browsers have supported wasm64 besides safari, and I don't care about Mac users so I thought why don't I just target wasm64, I don't really want to think about going over 4GB anyway.

&#x200B;

The problem is, I really want to get to multi language language projects, and rust doesn't have an Emscripten backend for 64 bits. It has one for 32 bits only.

&#x200B;

That got me thinking, why am I even doing this, why should anyone run compute intensive stuff from a browser rather than just downloading a binary. I really feel like it doesn't really solve real problems.

&#x200B;

Most stuff that people ported to web via emscripten is disgustingly slow, and they have zero toolchain control unlike native development. I can't just build a standard library of my choice from source and use it. Neither can I just use another allocator. It is all a giant black box.

&#x200B;

I mean, android development is also annoying, but libraries like SDL just give you the wrappers normally, and the way you build stuff makes sense, you build C/C++ parts normally and just run another build on top of that with gradle and friends.

&#x200B;

&#x200B;

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

Built over a decade a turing-complete Quantum Computing zachlike

Hi
Excited to be able to announce that QO is almost ready to leave Early Access! I published a large patch that covers more than a year of work (lots of analytics, I've been tracking where ppl were getting stuck).

If you are interested in a highly intuitive visual method that faithfully describes all universal quantum computing and physics behind, (including how time behaves) this is for you. I am the Dev behind Quantum Odyssey (AMA! I love taking qs) - worked on it for about 10 years (3.5 in phd), the goal was to make a super immersive space for anyone to learn quantum computing through zachlike (open-ended) logic puzzles and compete on leaderboards and lots of community made content on finding the most optimal quantum algorithms. The game has a unique set of visuals (that was actually my PhD research) capable to represent any sort of quantum dynamics for any number of qubits and this is pretty much what makes it now possible for anybody 15yo+ to actually learn quantum logic without having to worry at all about the mathematics behind.

This is a game super different than what you'd normally expect in a programming/ logic puzzle game, so try it with an open mind.

# Stuff covered

Boolean Logic – bits, operators (NAND, OR, XOR, AND…), and classical arithmetic (adders). Learn how these can combine to build anything classical. You will learn to port these to a quantum computer.
Quantum Logic – qubits, the math behind them (linear algebra, SU(2), complex numbers), all Turing-complete gates (beyond Clifford set), and make tensors to evolve systems. Freely combine or create your own gates to build anything you can imagine using polar or complex numbers.
Quantum Phenomena – storing and retrieving information in the X, Y, Z bases; superposition (pure and mixed states), interference, entanglement, the no-cloning rule, reversibility, and how the measurement basis changes what you see.
Core Quantum Tricks – phase kickback, amplitude amplification, storing information in phase and retrieving it through interference, build custom gates and tensors, and define any entanglement scenario. (Control logic is handled separately from other gates.)
Famous Quantum Algorithms – explore Deutsch–Jozsa, Grover’s search, quantum Fourier transforms, Bernstein–Vazirani, and more.
Build & See Quantum Algorithms in Action – instead of just writing/ reading equations, make & watch algorithms unfold step by step so they become clear, visual, and unforgettable. Quantum Odyssey is built to grow into a full universal quantum computing learning platform. If a universal quantum computer can do it, I aim to bring it into the game!

Streams to watch:

khan academy style tutorials on qm/qc: https://www.youtube.com/@MackAttackx

Physics teacher wholesome stream with over 500hs in https://www.twitch.tv/beardhero

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

Efficient C++ Programming for Modern 64-bit CPUs, Chapter 4/part 2

Here comes the 2nd installment of (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).

Second part of Chapter 4 (the one on CPU Physics and CPU Cycles): https://6it.dev/blog/infographics-operation-costs-in-cpu-clock-cycles-take-2-80736 . In addition to some interesting data (in particular, micro-research on the progress of MUL/DIV ops since 2017), it has that visualization of the different times quite a few ppl here have asked for.

DISCLAIMERS:

\- it is VERY DRAFT (editing is coming)

\- this is not a book on optimizations (though some techniques will be covered in Appendices 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 😉).

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

I want to make a mine sweeper in cpp but i dont know which gui to use

I thought about making a wpf gui and connect it to a cpp engine but i dont think that with wpf i can make a fun GUI, i really want it to look like a game and not a form

Do any of you have reccomendation for me?

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

One of the best C++29 features is already available?
https://meetingcpp.com/blog/items/One-of-the-best-Cpp29-features-is-already-available-.html

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

CMake and c++ libraries

Hi everyone,

At work, I stumbled upon something that seems completely absurd to me, but perhaps someone here will have a different perspective.

We have a software architect who defines the data model using .idl files (a kind of simplified struct, if you're not familiar with it). These .idl files generate C++ code.

Historically, it was C++ 98 code. And now it also includes "modern" C++ code, meaning that arrays are no longer T[\] but rather vector<T>, for example. Originally, these IDL files are used within our kind-of micro services. They update the data model within the distributed monolith, and we develop related features.

Under the pretext that these are the same source IDL files, our software architect imposes and provides us with the same CMake target name for both. This means we have to generate one install folder in 98 and another in "modern" C++.

And for the software where we'd like to start mixing the two within the same CMake project, we're stuck because we're limited to a single CMake target for two final .so files.

Do any of you see the point of his approach?

Would you recommend having a unique target name for each .so/.a ?

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

libc.so and libstdc++.so

Can someone tell me whether what I'm saying is correct or not? A Linux distribution running on x86 has to include the `libc.so` and `libstdc++.so` libraries. These libraries are needed to run C and C++ programs. They must be present so that programs can communicate with the operating system. For example, if a program uses printf, does it have to use `libc.so` in order to print text to the screen in C?

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

I built a custom DX11 engine that lets you layer 70+ real-time shaders over your entire Windows desktop (Zero input lag, no game hooking)

Hey everyone,

I’ve been developing a real-time post-processing engine called Shade Elements, and it is finally live. It essentially transforms your entire Windows operating system, applications, and games into a living canvas.

The main goal was to build something insanely powerful but completely non-invasive. Instead of injecting into game files (which triggers aggressive anti-cheat software), Shade Elements uses a custom C++ DirectX 11 engine to operate entirely as a screen-space overlay. It hooks the display compositor directly, meaning you get zero input lag and zero ban risks.

Here is what the engine can do:

70+ Stackable Shaders: You aren't limited to one effect. You can stack a CRT curvature filter over a VHS tape glitch, add realistic Phosphor Burn-in, or drop an ASCII visualizer over your favorite game.
Window-Aware Technology: The engine actively reads your Z-order. You can use the Bokeh Depth of Field shader to automatically track your active foreground window, keeping it razor-sharp while blurring out your messy desktop behind it.
Temporal Memory: The pipeline utilizes history buffers, allowing for buttery-smooth Motion Blur or the ability to "Save State" a snapshot of your screen mid-render and composite it back into the pipeline later.
Live Customization: Every shader has real-time sliders (Intensity, Radius, Speed, etc.) that parse dynamically. Plus, global hotkeys let you kill the overlay instantly without tabbing out.

I would love for you to try it out and tear it apart. I’ve set it up so the first 100 downloads are completely free!

You can check it out and grab a copy here:https://compaces.itch.io/shade-elements

Let me know what you think of the tech, or if you have any requests for new shaders to add to the vault!

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

P3984: A type-safety profile
https://wg21.link/p3984

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