Speaker: Stefan Fuhrmann

Audience level: 7

For about a decade now, the locos of compute power in modern CPUs has shifted.
The scalar execution units have far fallen behind the vector units (SIMD) within the same core.
Failure to utilize SVE2 or AVX512 may leave a whole order of magnitude of performance on the table.

Speaker: Andrei Zissu

Audience level: 6

After 2 full decades of multiple efforts aimed at introducing a contracts feature into the C++ language, contracts have finally been voted into C++26 at the February 2026 C++ Standards Committee (WG21) meeting in Hagenberg, Austria. To be more precise – confirmation into the standard was given to the Contracts MVP – Minimal Viable Product.

Speaker: Nicole Mazzuca

Audience level: 6

reMarkable is working on turning our monorepo into many repositories, and as part of that we have a unique chance to rewrite our build system as we pull components out, but with code behind them. This has meant that I've had a unique opportunity to work on a CMake build system library (named rho) that takes care of all of the hard parts for you, and gives you a simple, declarative set up which slots into existing CMake build systems, allowing you to fix your build system to be declarative over time.

It...

Speaker: Rainer Grimm

Audience level: 7

SIMD stands for Single Instruction Multiple Data. This means that an operation can be performed on multiple data simultaneously. Which allows for significant improvements in application performance. Unfortunately, SIMD instructions and registers are architecture-dependent.
The data-parallel types (SIMD) library in C++26 offers a solution: this library provides data-parallel types and operations on these data types in a portable manner.
In my talk, I will take a closer look at the powerful data-parallel types (SIMD) library.

...

Speaker: Boguslaw Cyganek

Audience level: 7

Recent C++ standards have introduced many new features. We often hear about them, but it would be interesting to test them in practice. Nothing could be simpler! We need to make a relatively simple project in which we will use many of them. And so the implementation of the FORTH compiler-interpreter was created. You may ask – what is that? I've never heard of it. Don't worry, after this talk you will know more about this language and about few cool features of modern C++.

In...

Speaker: Kerstin Keller

Audience level: 3

When developing C++ programs, you will inevitably get to the point where you want to do basic things like parsing a configuration file or opening a websocket connection, and you realize that this functionality is not part of the C++ standard library.
You will have to start managing dependencies. And, unlike in other programming languages, there is no standard way to go about it in C++.

Speaker: Hannes Hauswedell

Audience level: 3

C++ range adaptors provide a powerful and expressive, yet concise, way to transform and filter collections of elements. As one of the most significant additions to the C++ standard library, they have themselves transformed how we write Modern C++ today. However, in the five years since their introduction, they have also drawn substantial criticism. Numerous conference talks highlight "scary" examples or argue that the design is fundamentally flawed. Within the standards committee, range adaptors remain one of the most contentious topics, with ongoing debate—even around foundational issues such as the very definition of a range.

Unlike...

Speaker: Patrice Roy

Audience level: 3

We lie. We all lie. When programming, we have a cute name for lies: casts, a short name for «type casts», or those things we do when the compiler's view on the types in our program does not suit our needs.

Speaker: Nico Eichhorn

Audience level: 2

How confident are you in your C++ tests? Could they detect subtle errors lurking within your code? This session introduces mutation testing – a technique where tiny changes are introduced to your code to see if your tests can detect them.

Speaker: Hana Dusíková

Audience level: 7

Let's look at measuring (constexpr) test coverage, evaluating coroutines, and an undefined behaviour in program. These topic has all one thing in common: path analysis. I will show how these thing can be implemented in a compiler and how thinking about all possible paths can help you write better and safer code. 

Speaker: Raymi Klingers

Audience level: 6

This talk will be about how a pathfinding system written in C++ in 1997 went through several iterations by different developers over more than 25 years. From a C with classes style codebase with some inline assembly to a 64bit modern C++ code style while staying true to the original gameplay. This unsurprisingly was a bumpy road and issues ranging from simply the loss of knowledge of the algorithms to extended floating point precision being dropped due to a compiler flag which wasn't available anymore in 64bit.

We...

Speaker: Roth Michaels

Audience level: 7

For large C++ codebases, adding support for a new platform (e.g. Apple Silicon/ARM) can be a scary, expensive endeavor.  One of the biggest causes for alarm is undefined behavior (UB), which is an unfortunate part of many legacy codebases; luckily there are tools to help.  After a brief review of what undefined behavior (UB) is we will discuss what issues it can cause and why it should be avoided. We will look at a few real-life bugs caused by UB in our codebase and discuss a common type of UB in legacy codebases: "it works on Intel".  We’ll discuss how eliminating undefined behavior from a cross platform codebase can reduce maintenance costs and make it less stressful to support new platforms for your codebase.  Then, we’ll go over the specific cultural and tooling initiatives we used to eliminate undefined behavior in our C++ codebase, including how we used static analysis and clang sanitizers to identify and address issues.

...

Speaker: Roth Michaels

Audience level: 7

A sign of a good leader is that over time their team no longer requires their leadership. This allows a leader to look forward and take on new projects or larger teams/organizations to scale their impact. For an organization this trajectory of a leader also removes long-term reliance on a single point of success to ensure the ability to work with a codebase is not compromised when the original leaders are gone.

A...

Speaker: Sarthak Sehgal

Audience level: 3

Most software can tolerate occasional stalls. In high-frequency trading, a single unexpected wait can mean missing a chunky opportunity. Concurrency in these systems isn’t about maximizing throughput, it’s about shaving off microseconds without introducing tail latency or jitter. In this talk, we’ll explore the real-world synchronization strategies and hardware-aware techniques that help trading systems stay ahead.

We'll dive into why memory alignment matters, how to pin threads for cache locality, when spin-waiting beats locking, and how NUMA architectures affect latency. We’ll go over a lock-free single-producer single-consumer (SPSC) queue tuned for modern CPUs, and explore advanced concurrency patterns like Read-Copy-Update (RCU) for scalable, wait-free reads.

This talk aims to demonstrate real-world usage of common concurrency patterns and is targeted at beginner to intermediate developers who want to sharpen their mental model of what it takes to write C++ that doesn’t wait.

Speaker: Helmut Hlavacs

Audience level: 3

Entity Component Systems (ECS) are important data structures heavily used e.g. in video games. They implement a composition pattern, allowing them to cluster data belonging to particular entities dynamically. The proposed talk deals with possible architectural choices for ECS, how to optimize them for different purposes, and how to use them. We also show how to quickly create ECS from scratch using LLMs, although not being optimized. 

We...