CppCon 2026

** Separate registration is required for CppCon Academy Classes. **

Class Page

Whenever I give C++ trainings I run into the same topics of “half knowledge” even for expreienced programmers. We use a lot of features, for which looking into details opens a deep level of surprises and unexpected behavior. Even strings and vectors cause surprises (e.g., to understand when and how memory is allocated). Most of the time, day-to-day programmingthis works fine without full understanding, but once you hit corner cases (and it starts with error messages) good knowledge about what really goes on is key.

This tutorial will discuss all the common “tricky fundamentals” of C++, which application programmers see and use day by day. We will motivate them, understand them, and see how they should be used in practice. As a result, you will understand C++ way better and advance to the next level of an experienced C++ programmer.

As a long-time member of the C++ standards committee and experienced trainer, Nicolai will teach the essence spiced with useful background information about key design decisions.

** Separate registration is required for CppCon Academy Classes. **

Class Page

Remember writing a compiler in university? Not a real compiler, but something that handled a subset of a language and generated naive code. You’d never ship it. But decades later, you still understand how compilers work because you built one.

That’s what we’re doing here. In one intensive day, you will build a working AI coding agent in C++.
Not Claude Code. Not Cursor. A simple thing you fully understand, that talks to an LLM, defines tools, executes them, and runs the same agentic loop that powers every AI coding assistant on the market.

This workshop emerged from my own AI/C++ journey. I watched AI stumble through C++ like a freshman who skipped the first three weeks of class, until I discovered the problem wasn’t the models, it was me. The breakthrough came from understanding what’s actually happening under the hood.

In this workshop, you will write a fully functioning agent harness in C++. Like those university compilers, it will not be production ready, but will serve as a laboratory for learning how generative AI large language models can be used as C++ programmers.

By end of day, your agent will read code, write code, compile it, fix its own errors, and even modify its own source code to add new capabilities.

You won’t ship this agent. But you’ll understand what Claude Code and Cursor are actually doing. When they break, you’ll know why. When new tools emerge, you’ll evaluate them with comprehension instead of hype.

What You’ll Build:

A C++ program that talks to an LLM API
System prompts that shape model behavior
Tool definitions (read_file, write_file, run_command)
A working agentic loop
An agent capable of modifying its own source

What You’ll Understand:

Why the same model acts completely different with different prompts
What “tool calling” actually means (spoiler: you do all the work)
How context windows work and why you send the whole conversation every time
What “turns” are and how the conversation builds up
Why agents sometimes go off the rails and how to prevent it

Format: Lab-heavy. Students build; instructor guides. Starter code provided for API plumbing.

** Separate registration is required for CppCon Academy Classes. **

Class Page

“C++ Best Practices” is designed to help programmers elevate the quality of their C++ code. This course is intended for developers who have a beginner to intermediate knowledge of C++. You will learn how to write programs that perform well by default, are easier to maintain, memory safe, and have better compile times. We will cover best practices for new features added in C++17/20/23 and how to use the tools available to maintain code quality. Come prepared to interact and discuss.

** Separate registration is required for CppCon Academy Classes. **

Class Page

Your compiler is smart, but it is not a magician. It cannot fix a design that fights the hardware, nor can it optimize code that hides its intent. To achieve the peak performance C++ is capable of, you must master the deep interplay between the language, the compiler, and the physical machine. Most C++ developers know how to write code that is correct. Fewer know the actual cost of the abstractions they use. And only a small fraction understand how the compiler translates those abstractions into physical execution.

This class reveals the “secret life” of your application. We move beyond standard optimization advice to explore the mechanical sympathy required to squeeze every cycle out of modern systems. We will examine code from three perspectives: the hardware that executes it, the compiler that generates it, and the language rules that constrain it. We will demonstrate that performance is not an afterthought but a fundamental part of the design specification. You will learn how to validate that specification early—running “estimation benchmarks” on mock-ups to predict performance before writing a single line of production code.

We will unlock the specific behaviors that dictate speed across three critical layers:

• The Hardware Reality: Moving beyond “cache friendly” to understand the physics of the memory hierarchy, pipeline hazards, and why data layout often matters more than instruction count.
• The Compiler Partnership: How to read assembly to verify optimizations, how to structure code so the compiler can vectorize it, and understanding the critical (and often misunderstood) role of Undefined Behavior in generating efficient code.
• Design for Performance: How to integrate performance constraints into your architecture from day one, using estimation techniques to distinguish feasible designs from dead ends.

Crucially, we will challenge the myth that efficient code must be unreadable. We will point out concrete examples of how modern design practices and clean coding styles often align perfectly with hardware requirements, allowing you to write software that is maintainable, robust, and ruthlessly efficient.

This class is about performance and efficiency, spanning the entire range from the fundamentals of the hardware to the peculiarities of compiler optimizations. You will learn, on practical examples extracted from real-life programs, how to measure, analyze, and improve the performance of your programs. But most importantly, you will learn how to understand why your programs, compilers, and hardware behave the way they do. Some of the material will be basic and fundamental, some cutting-edge and esoteric, and the rest somewhere in between. All explanations will be reinforced with hands-on exercises, which you get to do in the classroom and can explore later in detail if you want to learn more.

** Separate registration is required for CppCon Academy Classes. **

Class Page

A good technical talk needs a compelling narrative as much as it needs absorbing information. At best, it is a shared experience between speaker and audience sparking questions, and conversations that go on throughout the hallway track. When done well, a good talk becomes a great one and leaves everyone, including the speakers, with more: more understanding, more curiosity, more interest.

We can help you discover what makes a great technical story. We can show you how even small small tweaks to existing presentations can make a huge difference. Learn clarity, the best use of detail, slides that illustrate rather than distract and how to be truly comfortable on stage.

We will also go over where AI can play a role in helping develop a talk. Like good code, a good talk is never written with an LLM taking the lead. However, LLMs can be trained to ask questions, make suggestions and help wade through piles of material, freeing you to craft, think, and share experiences. Be aware that we come with the strong opinion that AI art is vastly overused and is often awful.

The Red Rocks & Dinosaur Ridge Museum Field Trip.
Details are here.
A separate registration is required for this event.

For those who've registered for this year's Field Trip, let's meet up in Rockies Square.

Rockies Square is behind the Convention Coffee shop "the Cocoa Bean", convention center level 2.

The tour bus will meet us outside of this area 11:15 - 11:30. Don't be late!

We should return to the hotel around 17:00.

Tee Shirt Night is our way to helping you get to know other conference attendees even before the conference has officially started. It works best if you brought a C++ (or CppCon) shirt with you. But even if you didn't you can join the fun.

Here is how:

1. Put on your C++ or CppCon shirt (or don't, if you didn't bring one).
2. Go to any of the Gaylord Rockies eateries (except Hickory House).
3. Look for others wearing a C++ or CppCon tee-shirt.
4. Ask to join their group.
5. Enjoy getting to know other attendees before the conference starts!
6. Get a special offer from the restaurant!

Come for the registration and stay for the reception. Sponsored by Search Technology.

Get your badge and swag bag.

Stick around, check out the posters, get acquainted with new friends and get reacquainted with old friends.