News : Standard C++

Home » Blog » Categories » News

CppCon's first-ever keynote panel: Stroustrup, van Rossum, and Torgersen, together at CppCon 2026

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:

Bjarne Stroustrup, the creator of C++ (who will have just given his own Monday conference kickoff keynote the day before)
Guido van Rossum, the creator of Python
Mads Torgersen, the lead designer of C# and Anders Hejlsberg’s successor in that role
Moderator: Emma Tracey, founder of CultRepo and producer of its new feature film C++: The Documentary and Python: The Documentary

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.

Python is, by the numbers, C++’s truest sister language. In the Standard C++ Foundation’s annual C++ developer survey, when we ask which other languages C++ programmers use, Python always comes first, consistently around 70 percent — ahead even of C, which you might expect to win and is consistently around 45 percent. If you write C++, the odds are very good that you also write Python; the two have grown up side by side, gluing and being glued, and the relationship only deepens each year.
C# and C++ are the two dominant languages on Windows, and the two are constantly used together — native performance underneath, managed productivity on top — so the person designing C# is designing part of the world that a great many C++ developers ship into.

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.

CppCon 2025 Lazy and Fast: Ranges Meet Parallelism in C++ -- Daniel Anderson

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++.

C++26: string and string_view improvements -- Sandor Dargo

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_view is.

Reminder: the role of string_view

std::string_view was introduced in C++17 and its purpose is to provide read-only access to a string-like object. It can often replace const string& parameters 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 with string_view

A stringstream is a good old tool for dealing with operations on string-based streams. While C++23 introduced spanstreams, 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 a stringstream from a string_view, you first have to manually convert it into a string.

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.

CppCon 2025 How to Tame Packs, std::tuple, & the Wily std::integer_sequence -- Andrei Alexandrescu

By Blog Staff | Jun 16, 2026 03:02 PM | Tags: None

How to Tame Packs, std::tuple, and the Wily std::integer_sequence

by Andrei Alexandrescu

Summary of the talk:

Template parameter packs and std::tuple unlock powerful metaprogramming capabilities in C++, but they also introduce a parallel sublanguage—one with unfamiliar rules, verbose idioms, and surprising limitations. Packs were originally designed for perfect forwarding, not compile-time iteration, which makes even simple tasks like filtering or transformation awkward. std::integer_sequence helps, but mostly by shifting the burden rather than removing it.

Existing library utilities offer some relief, but often feel inconsistent and difficult to compose. This talk explores why working with packs and tuples feels harder than it should, and demonstrates a small set of clean, reusable abstractions that make these tasks simpler, safer, and more expressive. Attendees will leave with practical tools—(and, with luck, a renewed hope) that structured metaprogramming in C++ doesn't have to be so hard.

New features in GCC 16: Improved error messages and SARIF output -- David Malcolm

By Blog Staff | Jun 15, 2026 03:21 PM | Tags: None

GCC 16 is about to be released, so I'm sharing some of the new features I worked on this year. Some changes are visible to users, while others improve the system more subtly.

New features in GCC 16: Improved error messages and SARIF output

by David Malcolm

From the article:

A well-known challenge for C++ developers is the readability of template-related error messages. C++ compilers tend to either provide too little information or spew screenfuls of text at you. Either way, the errors can be difficult to decipher.

GCC error messages have a hierarchical structure to them. In GCC 15, I added an experimental option that shows this structure as a collection of nested bullet points.

In GCC 16, this behavior is now the default. You can return to the previous behavior using -fno-diagnostics-show-nesting or -fdiagnostics-plain-output. I fixed several bugs and made use of the hierarchical structure in more places. For example, it is easy to get declarations and definitions out of sync when manually adding const to a parameter:

class foo

{

public:

void test(int i, int j, void *ptr, int k);

};

// Wrong "const"-ness of param 3.

void foo::test(int i, int j, const void *ptr, int k)

{

}

Trip report: June 2026 ISO C++ standards meeting (Brno, Czechia) -- Herb Sutter

By Blog Staff | Jun 15, 2026 01:08 AM | Tags: None

Hot off the press from the latest ISO C++ meeting:

Trip report: June 2026 ISO C++ standards meeting (Brno, Czechia)

by Herb Sutter

From the article:

tl;dr… A few highlights

Adopted this week in draft C++29: Complete catalog of all undefined behavior (UB) in C++. Contract pre/post support for virtual functions. Defaulting (=default) for postfix increment/decrement. Designated initializers for base classes. Python-style .lookup(key) for associative containers. And more…

Other significant progress: Progress on various features targeting C++29, including systematically addressing UB and adding safety profiles for C++.

Next six months: Telecon line-by-line review of a proposal to systematically address all undefined behavior in C++. Progress adding C++ memory safety subsetting profiles. Both aim for inclusion in C++29.

C++26: Structured Bindings can introduce a Pack -- Sandor Dargo

By Blog Staff | Jun 12, 2026 12:17 PM | Tags: None

In previous posts, we talked about how C++26 improves structured bindings by allowing them to be used in conditionals’ init statements. We also briefly touched on other improvements coming in C++26, such as individual binding annotations and constexpr bindings. There is, however, one important enhancement to structured bindings that we haven’t covered yet on this blog: Structured Bindings can introduce a Pack

C++26: Structured Bindings can introduce a Pack

by Sandor Dargo

From the article:

Before diving into the feature itself, let’s briefly clarify what a pack is. A reasonably accurate (and not overly simplistic) definition is the following:

A parameter pack is a language construct that represents an arbitrary number of types or values, allowing code to accept and operate on an arbitrary number of arguments in a type-safe way.

I deliberately avoided using the word template in this definition. Historically, packs only existed in templated contexts, but that limitation is slowly being relaxed. Earlier versions of the proposal behind this feature even aimed to support structured binding packs in non-templated contexts. That part was eventually dropped due to implementation complexity and related objections — but the direction is still telling.

The voting on the talks for Meeting C++ 2026 has begun!

By Meeting C++ | Jun 12, 2026 03:40 AM | Tags: meetingcpp events community

The yearly voting for the conference program of Meeting C++ has begun! You can vote on 118 talks until Sunday 21st.

The voting on the talks for Meeting C++ 2026 has begun!

by Jens Weller

From the article:

Once again its time for the C++ community to take a look at the submitted talks for Meeting C++ 2026! Thanks to all folks who have submitted a talk to this years conference! Your contribution will create another great conference in Berlin and online! And special thanks to all folks who have bought tickets already for the conference, you'll have a bit more weight in the voting to shape this years program! Same is true if you spoke at Meeting C++ in the past or attended last years conference.

CppCon 2025 Cache-Friendly C++ -- Jonathan Müller

By Blog Staff | Jun 10, 2026 03:00 PM | Tags: None

Cache-Friendly C++

by Jonathan Müller

Summary of the talk:

When you need a container, pick std::vector＜T＞ by default. This is because std::vector＜T＞ is cache-friendly.

What does that mean, though?

This talk will answer that from the ground-up. We will cover the need for CPU caches and their consequences, how the CPU tricks to make them as seamless as possible, and when and why those tricks sometimes fail. This means that you need to be careful when structuring your program to avoid slowdowns. We will thus explore cache-friendly data structures, data-oriented design, and how to avoid common pitfalls.

CppCon 2025 Cutting Down on Unnecessary Objects -- Prithvi Okade & Kathleen Baker

By Blog Staff | Jun 8, 2026 02:57 PM | Tags: None

C++ Performance Tips: Cutting Down on Unnecessary Objects

by Prithvi Okade & Kathleen Baker

Summary of the talk:

In C++, unnecessary temporary object creation can lead to costly runtime operations, increased code execution, and higher memory usage. Luckily this can be improved! This talk investigates common scenarios that result in the creation of temporary objects and how to detect these scenarios, demonstrated through code examples. We will then explore strategies to reduce the creation of such objects with techniques like explicitly moving objects, passing objects by reference, leveraging lightweight classes like std::string_view and std::span , using functions like reserve and emplace , and more. Join us to learn how to optimize your code’s performance and adopt better practices.

tl;dr… A few highlights