CppCon 2026

Making native code fast is a team sport: efficient algorithms, high-performance libraries, memory-conscious design, and modern hardware all play a role. But the critical link between your code and the hardware it runs on is the optimizing compiler.

This talk explores new & improved compiler optimizations in Visual Studio 2026, and how these improve the performance of existing C++ code with minimal source changes. We will examine both architecture-independent optimizations (such as improved scalar replacement, vectorization, and loop transformations) and architecture-specific enhancements (such as AVX-512 and NEON specific optimizations). Along the way, we will connect high-level C++ constructs to the generated assembly and CPU behavior to build an intuition for how performance improvements are realized. While the talk discusses Visual Studio code generation & optimizations, the tools and analysis apply to all native platforms & compilers.

We will also introduce sample-based profile-guided optimizations (SPGO) which uses the runtime characteristics of your application to guide optimization decisions, WITHOUT requiring traditional instrumentation. You will learn how SPGO works, how to apply it in practice, and where it delivers measurable gains: typically in the 5-15% range across real world native codebases.

Attendees will leave with a practical understanding of how to reason about native code performance, and how to leverage SPGO to turbocharge the performance of their code.

C++ is used in many fields. One that sticks out is the embedded domain. You're often working with tight constraints. Writing software is challenging and fun at the same time.

What has C++ done to support this field? What new options do you have to avoid undefined behavior and write more efficient and robust code?

In this talk, I will present various library elements as well as language improvements that make writing embedded software better.

We'll look at real-world tasks like turning raw byte blobs into usable data structures, aka type punning, of course, without triggering undefined behavior. C++23 supports you in a new way with std::start_lifetime_as .

Transferring data via a network comes with its challenges. You have to care about the byte order. Oh, and how can you make sure that there are no padding bytes included? Well, I have an answer for you.

And then there is a brand-new feature in C++26: static reflection. I will present examples of how and where reflection in C++ eases embedded development.

By the end of this talk, you know the most important improvements in C++ for embedded or similar environments.

C++ runs the world’s systems, and with that comes a responsibility for safety and stability. Avoiding AI entirely gives up on incredible potential benefits, but using AI without guardrails poses significant risks to our critical systems. How does AI fit into this world? This talk examines effective and ineffective approaches to using AI in systems that cannot afford “slop.” We will explore several case studies where AI produced significant value in C++, and several where it did not. The pattern that emerges is consistent: AI thrives when it is orchestrating well-defined, deterministic components, translating between them intelligently without being trusted to reason correctly on its own. When AI is asked to be the system rather than connect the system, things fall apart.

Scripting in a C++ game engine should not cost you the engine's native performance. This talk shows how C++26 static reflection and std::meta::substitute in particular can lift a scripting language's bytecode into C++ template structures that the compiler optimizes away entirely, collapsing the interpreter dispatch loop into the same machine code you'd write by hand. Scripting languages like AngelScript and Lua are invaluable in C++ engines: they give designers a fast iteration loop without rebuilding the engine. But they come with a paradox. The engine you chose for raw performance now spends cycles on every frame interpreting a slower language, juggling a software stack and checking types at runtime. We will walk through the technique step by step, starting from a plain bytecode interpreter and ending at a fully reflected program where a scripted sum(0..10) compiles to mov eax, 45; ret. Along the way you'll learn the core C++26 reflection primitives (^^, [: :], std::meta::substitute), how to assemble bytecode into structural templates like block<> and loop<>, and how these techniques generalize to embedding any stack or register based scripting language in your engine with zero runtime overhead.