June 17-20, Folkestone, UK
September 12-18, Aurora, CO, USA
November 16-21, Búzios, Rio De Janeiro, Brazil
November 26-28, Berlin, Germany
By Blog Staff | Jun 26, 2026 08:41 AM | Tags: None
The New York May 29 world premiere event for C++: The Documentary was followed by a live panel discussion with Matt Godbolt (moderator), Bjarne Stroustrup, Gabriel Dos Reis, Nina Ranns, Eric Lubin, and Herb Sutter. The video recording of that panel is being released worldwide on YouTube today at 19:00 UTC. Click Notify me on the YouTube Premiere page to get a reminder when it goes live.
By Blog Staff | Jun 24, 2026 03:07 PM | Tags: None
Registration is now open for CppCon 2026! The conference starts on September 12 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year's conference. Here’s another CppCon talk video we hope you will enjoy – and why not register today for CppCon 2026!
Implement the C++ Standard Library: Design, Optimisations, Testing while Implementing Libc++
by Hui Xie
Summary of the talk:
This presentation covers various practical examples in the designs, optimisations and testing in libc++, a standard library implementation.
In space optimisation section, it presents various examples of using compact type, reusing tail padding bytes, reusing unused bits in existing bytes, in various standard types: std::stop_token , std::expected , std::optional , std::variant , std::ranges library and std::move_only_function .
In time optimisations section, it presents examples of how we optimise std::atomic＜T＞::wait 's waiting strategy, how we optimised algorithms for segmented iterators, and also how we keep in mind optimisations by leaving the door open for future optimisations. At the same time, compilation time is also important so it also contains examples how unnecessary template instantiations can be avoided.
Finally, this talk covers the unit tests of libc++, including the high test coverage of standard spec, the technique we share tests between runtime and constexpr, negative testing and so on.
By Meeting C++ | Jun 24, 2026 12:45 AM | Tags: meetingcpp intermediate community c++26 c++23 c++20 c++17 basics advanced
With the voting on the talks ending on Sunday, Meeting C++ has now published its program, take a look at the talk listing.
A first release of the program for Meeting C++ 2026
by Jens Weller
From the article:
With the voting ending on Sunday, there is now a first overview on the program of Meeting C++ 2026 available!
As early bird tickets are selling out, its time to get your tickets!
You can take a look at the accepted talks, this is the main track:Robert Leahy - What Are We Synchronizing?
Ivan Čukić - Contracts and hardened libraries - a bright future for C++ safety?
Henrik Vallgren - Compile time is the future of Automotive Software
Dawid Zalewski - C++26 static reflection: All you need is annotations
Andreas Fertig - When Your Compiler Runs Your Code
Matt Godbolt - Compiler Explorer in 2026: Sandboxes, Storage & Strangers' Code
Antoine Morrier - Thread-safety compile-time guaranteed in C++
Daniela Engert - Same C++, but quicker to the finish line
Giuseppe D'Angelo - Not-so-trivial relocation in C++
Guy Davidson - Profiles are coming
Klaus Iglberger - Design Patterns - The Most Common Misconceptions (3 of N)
By Blog Staff | Jun 23, 2026 03:30 PM | Tags: None
We continue our deep dive into memory mechanics. If you are just joining us, I recommend reviewing the foundations first. The first part covered the basics and the magic of simple data alignment, while the second part focused on how ordinary inheritance affects memory layout.
Silent foe or quiet ally: Brief guide to alignment in C++. Part 3
by Elizaveta Zhegalova
From the article:
So far, we've treated an object as a static, rigidly determined data structure. Every field address was known at compile time, and inheritance simply layered parent and child attributes. Alas, object-oriented programming is impossible without dynamic polymorphism, which is implemented in C++ via the RTTI mechanism and virtual functions.What is virtuality?Let me start from an off-topic question. How does the compiler know which piece of machine code to execute at a specific line in your program? Answering this question will help us understand what virtuality really means.Imagine we writeobject.print(). For the processor, it's not an abstract action but a command to jump to a certain address in memory with some function instructions. But where do we take that address from?During compilation, each code line becomes one or more machine instructions, each receives a unique sequential address in memory. The same applies to functions. A compiler translates them into machine code and assigns the next available address. Stitching a function call in code to its actual memory address is called binding.Depending on when the call address is bound to the function address, there are two scenarios.1. Static/early binding.By default, static (early) binding is used. A compiler rigidly "hardwires" a specific function address at the call place in code during compilation. This decision relies solely on the pointer or reference type, not the actual object in memory. For instance, when a compiler sees aBase*pointer, it chooses the method address from the base class. It's fast and requires no additional evaluations. So, the jump goes to an already known address. It's also efficient, but it makes the program inflexible at runtime.
By Nico Josuttis | Jun 23, 2026 03:28 PM | Tags: None
I am happy to announce that my new book in the "The Complete Guide" series is out now as a draft ebook
C++23 - The Complete Guide
by Nicolai Josuttis
So far, the book has 350 pages and is not complete yet. However, many C++23 features are covered already. For details of the current content, look at www.cppstd23.com. There you can also find several example programs demonstrating how all the new features can be used.
You can order the book at leanpub.com/cpp23 for a reduced price and will get all updates for free. This way, you have early access to details of the new features and I have early income and can process feedback from you for the final version, which will also be available as hardcover (not included).
I hope it helps. Enjoy!
By Blog Staff | Jun 21, 2026 11:53 PM | Tags: None
Every year, CppCon promises you a strong keynote lineup, and every year we deliver. But this year we get to do something rarer: announce a once-in-a-lifetime keynote panel of interest not just to C++ developers, but to our whole industry.
On Tuesday morning, September 15, the CppCon main stage will host a Language Designers Panel featuring three of the people who decide what the languages you use every day actually become:
Three living and growing languages used by millions of developers, three design philosophies, one stage, one conversation.
Bjarne and Guido have never been on stage together anywhere and may never be again; add Mads to the stage, and we expect this special moment to be watched, cited, and argued over for years. You can be in the room when it happens.
Why should a C++ audience care about a panel that is two-thirds “other languages”? The answer is that these languages are two of C++’s closest neighbors and are used together all the time.
So this is a conversation among the architects of the three languages most of us actually live in. What do they envy in one another’s designs? Where do they think they got it right, and where would they start over? How do you steer a language with millions of users and decades of existing code without breaking the people who depend on you? And the lessons to learn from their shared experience reach well beyond language design — the same instincts that shape a language will sharpen how you design your own libraries and products. Bring your own questions, too — you will not get a chance like this often.
CppCon 2026 Early Bird registration discount is available until this Friday. After that, registration will continue to be available at the regular rate. CppCon 2026 runs September 12–18 at the Gaylord Rockies in Aurora, Colorado, and conference sessions are onsite-only this year — they will be recorded and posted to our YouTube channel afterward, but only the room gets the live experience and the chance to ask questions of all our speakers. If you have been waiting to register, this is the week to stop waiting.
Register now for CppCon 2026, and we’ll see you in Aurora.
By Marc Gregoire | Jun 19, 2026 09:27 AM | Tags: c++26 becppsymposium2026 becpp
BeCPP Symposium 2026 (organized by BeCPP): Now on YouTube!
Keith Stockdale - The journey to "/W4 /WX": How hard could it be?
Abstract:
Building on the recent work of improving the quality of Sea of Thieves' codebase by upgrading from C++14 to C++20, this talk will focus on the work that has went into enabling warnings as errors on the game, and more. Rare will discuss the motivations behind wanting to crank up the warning level, and to flick the "warnings as errors" switch after 10 years of development in their multi-million line Unreal Engine code base.
About the Speaker:
Keith is a Northern Irish senior software engineer who has been working on the Engine and Rendering teams at Rare Ltd for the last 9 years. He primarily works on Engine and Rendering level systems involving General Purpose GPU systems such as GPU particle systems. Keith is enthusiastic about promoting writing good quality code, whether it is running on the CPU on the GPU.
By Marc Gregoire | Jun 19, 2026 09:23 AM | Tags: c++26 becppsymposium2026 becpp
BeCPP Symposium 2026 (organized by BeCPP): Now on YouTube!
Chris Croft-White - Agentic Time-Travel Debugging
Abstract:
Time-travel debugging is a powerful technique to dive deep into the execution of your applications, providing visibility simply not available any other way and enabling rapid diagnosis of issues as well as understanding of unfamiliar code bases. With the AI revolution going on today, hallucinations are a major concern and limiting factor for adoption. Combining these two technologies enables us to give the AI Agent all the information it could possibly want about what happened in your application. This enables it to both investigate when something goes wrong to develop a hypothesis, but also a way to validate that hypothesis, and iterate on it as needed until the AI Agent is able to verifiably explain what happened and why.
About the Speaker:
Chris Croft-White is a Staff Solutions Architect at Undo, where he works at the intersection of debugging technology and developer productivity. With a career spanning field applications engineering, security, and technical pre-sales, he brings a practitioner's perspective to the challenge of helping engineering teams ship reliable software faster. Chris is currently focused on the emerging field of agentic debugging, exploring how AI can move beyond code generation to become a genuine partner in root cause analysis and defect resolution. He writes and speaks on practical approaches to integrating AI into real-world debugging workflows, cutting through the hype to find what actually works.
By Blog Staff | Jun 18, 2026 03:05 PM | Tags: None
Registration is now open for CppCon 2026! The conference starts on September 12 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year's conference. Here’s another CppCon talk video we hope you will enjoy – and why not register today for CppCon 2026!
Lazy and Fast: Ranges Meet Parallelism in C++
by Daniel Anderson
Summary of the talk:
Recent advances in the C++ standard have introduced powerful features like ranges and parallel algorithms—both aimed at writing faster, cleaner, and more expressive code. Ranges offer lazy, on-demand computation that improves I/O efficiency and composability. Parallel algorithms, on the other hand, harness multitasking to speed up compute-heavy workloads.
At first glance, these two features seem like a perfect match: lazy evaluation to minimize I/O overhead, and parallelism to maximize throughput. However, in practice, they don’t play well together. Many range operations—especially those over non-random-access sources—are inherently sequential due to their lazy pull-based, one-element-at-a-time nature.
In this talk, we’ll explore a modern library technique that unlocks the synergy between lazy ranges and parallelism. You’ll see how to build lazy, composable range pipelines that are parallel-friendly—capable of efficiently expressing operations like filter, scan, and flatten without sacrificing performance or elegance. We’ll walk through real-world examples where these techniques deliver strong parallel speedups with minimal programming overhead.
Whether you’re a library designer, performance enthusiast, or just curious about making your range-based code scale, this talk will equip you with practical tools to bridge the gap between composability and parallelism in modern C++.
By Blog Staff | Jun 17, 2026 03:27 PM | Tags: None
Let’s continue our exploration of C++26 improvements. Today we focus on string_view. Some types got new constructors accepting string_views, and concatenation of strings and string_views just got easier.
C++26: string and string_view improvements
by Sandor Dargo
From the article:
But let’s start with a brief reminder of what a
string_viewis.Reminder: the role of
string_view
std::string_viewwas introduced in C++17 and its purpose is to provide read-only access to a string-like object. It can often replaceconst string¶meters and offers a significant performance gain. It’s generally advisable to use it whenever you’d pass an immutable string-like input that you cannot move from source to target.We covered the topic earlier in more depth here.
P2495R3: Interfacing
stringstreams withstring_viewA
stringstreamis a good old tool for dealing with operations on string-based streams. While C++23 introducedspanstreams, due to fundamental semantic differences,stringstreams are not dead and it’s important to maintain them.Being a good old tool also means they predate
string_view. Given the available set of constructors, if you want to initialize astringstreamfrom astring_view, you first have to manually convert it into astring.P2495R3 fixes this by adding new constructors accepting
string_views.It’s worth noting that this is a purely additive library change — it doesn’t break existing code.
At the moment of publication, this change is already available on Clang 19.
