: Standard C++

Home »

« Prev Next »

Glaze 7.2 - C++26 Reflection | YAML, CBOR, MessagePack, TOML and more

By Blog Staff | Apr 28, 2026 03:24 PM | Tags: None

Glaze is a high-performance C++23 serialization library with compile-time reflection. It has grown to support many more formats and features, and in v7.2.0 C++26 Reflection support has been merged!

Glaze 7.2 - C++26 Reflection | YAML, CBOR, MessagePack, TOML and more

From the article:

Glaze now supports C++26 reflection with experimental GCC and Clang compilers. GCC 16 will soon be released with this support. When enabled, Glaze replaces the traditional __PRETTY_FUNCTION__ parsing and structured binding tricks with proper compile-time reflection primitives (std::meta).

The API doesn't change at all. You just get much more powerful automatic reflection that still works with Glaze overrides! Glaze was designed with automatic reflection in mind and still lets you customize reflection metadata using glz::meta on top of what std::meta provides via defaults.

CppCon 2025 The Wonderful World of Designing a USB Stack Using Modern C++ -- Madeline Schneider

By Blog Staff | Apr 27, 2026 02:24 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!

The Wonderful World of Designing a USB Stack Using Modern C++

by Madeline Schneider

Summary of the talk:

Have you ever wondered how to design a library to abstract and manage complex communication protocols like USB? Have you ever wondered which parts of a protocol need to be hardware abstractions and which parts are hardware agnostic? Well you’re in luck, my mentor and I have designed a USB stack from the ground up in modern C++! We found that the public offerings did not meet our needs. Our requirements are:

Resource efficient

Portable

Modular

Convenient to use

Distributable via single pre-built binary using conan

Without allocations after initialization

In this talk you’ll learn the basics of how USB works at the lowest level from a software perspective. You’ll learn why malleability and freedom are so important for USB device development and how C++ makes such a library design easy to implement. Embark with me on a deep-dive into shaping a library where complexity runs wild. This talk will have lessons on library and API design in situations where the degrees of freedom are vast and all parts must magically fit together. By the end, you’ll carry away practical patterns for taming vast design spaces—skills that apply to any ambitious library, far beyond USB.

BeCPP Symposium 2026 - Herb Sutter - C++ Growing in a world of competition, safety, and AI

By Marc Gregoire | Apr 26, 2026 06:17 AM | Tags: c++26 becppsymposium2026 becpp

BeCPP Symposium 2026 (organized by BeCPP): Now on YouTube!

Herb Sutter - C++: Growing in a world of competition, safety, and AI

Abstract:

These are exciting times for C++. This talk will cover why to be excited about the new C++26 standard, which is expected to be technically finalized 48 hours before this talk. More broadly, it will cover why C++’s strong market growth — and the strong growth of human software development in general — are likely to continue for the foreseeable future in a world of explosively growing software demands for performance, security, and AI.

About the Speaker:

Herb is a technical fellow at Citadel Securities, designer of several Standard C++ features, chair emeritus of the ISO C++ committee, and chair of the Standard C++ Foundation. His current interest is simplifying C++.

CppCon 2025 Can Standard C++ Replace CUDA for GPU Acceleration? -- Elmar Westphal

By Blog Staff | Apr 23, 2026 02:22 PM | Tags: None

Can Standard C++ Replace CUDA for GPU Acceleration?

by Elmar Westphal

Summary of the talk:

On top of the woes of multi-threaded programming itself, coding for GPUs used to be about dealing with kernels, separate memory domains, warps, blocks and other strange things. Later, life became easier and you could sprinkle in a bunch of pragmas, hoping that your favorite language extension would deal with all of this for you, and better memory model abstractions came up that were less painful to deal with. In recent years, new drivers (seemingly) levelled the boundaries between memory domains and new compilers allow us to deploy code to the GPU using standard C++ execution policies. The performance of the generated code is often similar to that of its CUDA-C++ counterpart. Of course there is no magic bullet to shoot at your (legacy) code and there are caveats, but come and see how using standard parallelism (also) for programming GPUs makes it a lot easier to write portable and more future-proof high-performance C++ code.

Behold the power of meta::substitute -- Barry Revzin

By Blog Staff | Apr 22, 2026 12:49 PM | Tags: None

What if string formatting could do far more than just substitute values—and do it all at compile time? This deep dive explores how modern C++ features like reflection unlock powerful new possibilities for parsing, analyzing, and transforming format strings before your program even runs.

Behold the power of meta::substitute

by Barry Revzin

From the article:

Over winter break, I started working on proposal for string interpolation. It was a lot of fun to work through implementing, basically an hour a day during my daughter’s nap time. The design itself is motivated by wanting to have a lot more functionality other than just formatting — and one of the examples in the paper was implementing an algorithm that does highlighting of the interpolations, such that:

would print this:

x=5 and y=*10* and z=hello!

without doing any additional parsing work. I got the example from Vittorio Romeo’s original paper.

Now, when I wrote the paper, I considered this to be a simple example demonstrating something that was possible with the design I was proposing that was not possible with the other design. I thought that because obviously you need the format string as a compile-time constant in order to parse it at compile time to get the information that you need.

2026 Annual C++ Developer Survey "Lite"

By Blog Staff | Apr 21, 2026 05:58 PM | Tags: None

The annual global C++ developer survey is now open:

2026 Annual C++ Developer Survey "Lite"

Please share your feedback in this annual 10-minute survey to help inform C++ standardization and C++ tool vendors. This is the biggest opportunity we all have each year to make our voices heard and help improve our industry and community!

A summary of the results, including aggregated highlights of common answers in the write-in responses, will be posted publicly here on isocpp.org and shared with the C++ standardization committee participants and C++ tool vendors to help inform C++ evolution and tooling.

The survey closes in one week.

Thank you for participating and helping to inform our committee and community.

CppCon 2025 C++: Some Assembly Required -- Matt Godbolt

By Blog Staff | Apr 21, 2026 02:12 PM | Tags: None

C++: Some Assembly Required

by Matt Godbolt

Summary of the talk:

Join Matt in exploring how the C++ ecosystem has evolved through the interplay of intentional design and emergent collaboration. Standards committees craft language features and compiler teams implement them, but something amazing happens in the spaces between: tools appear, communities form, and solutions emerge that nobody quite planned for. What started as individual developers solving their own problems has grown into an interconnected ecosystem that shapes how we all write C++.

From documentation to testing, from build systems to package managers, we'll examine how the C++ community has assembled itself around shared pain points and accidental standards. Using examples and perhaps too many rainforest metaphors, this talk celebrates not just the language we've built, but the organic ecosystem that's grown up around it. Come discover why C++'s greatest strength might be that it's always required some assembly.

Let's check vibe code that acts like optimized C++ one but is actually a mess

By Andrey Karpov | Apr 21, 2026 04:04 AM | Tags: vibe code simd pvs-studio optimization markus code review claude opus

The value of a skilled developer is shifting toward the ability to effectively review code. Although generating code now is easier than ever, evaluating it for proper decomposition, correctness, efficiency, and security is still important. To see why it's important to understand generated code and to recognize what lies beneath a program's elegant syntax, let's look at a small project called markus, created using Claude Opus.

Let's check vibe code that acts like optimized C++ one but is actually a mess

by Andrey Karpov

From the article:

Clearly, the 64-bit code is much more efficient, except when SSE2 is involved. Even then, though, everything runs quickly. The code Claude Opus generated for the markus project is the worst of all the options. Not only is the simplest implementation with a regular loop faster, it's also shorter. The extra code lines only made things worse.

CppCon 2025 How C++ Finally Beats Rust at JSON Serialization -- Lemire & Thiesen

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

How C++ Finally Beats Rust at JSON Serialization

by Daniel Lemire & Francisco Geiman Thiesen

Summary of the talk:

JSON, or JavaScript Object Notation, has become a cornerstone for storing and exchanging data. Its appeal lies in its simplicity—human-readable text that elegantly captures structured data through attribute-value pairs and arrays: {"age": 5, "name": "Daniel", "toys": ["wooden dog", "little car"]}. JSON is intuitive yet powerful. But ingesting and producing JSON can turn into a performance choke point. In C++, it can be a tedious, error-prone task. Programmers wrestle with unexpected content, manually mapping data to and from native structures, all while striving for speed and safety.

With languages like Java, C#, Zig, Rust, or Python, JSON serialization and deserialization typically requires far less work. In particular, Rust's serde library blends convenience with high speed. We wish for a C++ library to automatically handle JSON production and consumption, seamlessly tied to native data structures. It is not merely to simplify life for developers; it is also about crafting code that is both fast and solid, generated at compile time by a battle-tested library.

Thankfully, C++ might soon be getting reflective metaprogramming ( PR2996 ). Leveraging the experimental Bloomberg LLVM fork with reflective metaprogramming, we have built a full-fledged implementation—complete with tests, benchmarks, and documentation. Our goal is to have production-ready code the moment mainstream compilers catch up. The results speak for themselves: we are parsing JSON directly into C++ structures at gigabytes per second, outpacing even mature heavyweights like Rust's serde. Better yet, the conversion between C++ data structures and JSON is fully automated, thanks to metaprogramming. It has the potential to be a leap forward for C++ in the data-driven age. Unfortunately, there are still problems and limitations: we present them and provide some solutions.

Devirtualization and Static Polymorphism -- David Álvarez Rosa

By Blog Staff | Apr 16, 2026 12:41 PM | Tags: None

Ever wondered why your clean, object-oriented design sometimes slows things down? This piece breaks down how virtual dispatch impacts performance—and how techniques like devirtualization and static polymorphism can eliminate that overhead entirely.

Devirtualization and Static Polymorphism

by David Álvarez Rosa

From the article:

Ever wondered why your “clean” polymorphic design underperforms in benchmarks? Virtual dispatch enables polymorphism, but it comes with hidden overhead: pointer indirection, larger object layouts, and fewer inlining opportunities.

Compilers do their best to devirtualize these calls, but it isn’t always possible. On latency-sensitive paths, it’s beneficial to manually replace dynamic dispatch with static polymorphism, so calls are resolved at compile time and the abstraction has effectively zero runtime cost.