Getting the most out of your GPU with C++ doesn't require writing custom kernels or manually managing storage for everything! Come learn about the libraries and techniques that make writing CUDA C++ code easier and more performant. Through examples, we'll explore all aspects of writing modern C++ software for GPUs, including heterogeneous memory management, algorithm design, and synchronization.

During this talk, you'll:

• Learn to evaluate when you should use a CUDA library versus writing your own kernel.
• Explore popular CUDA C++ libraries such as Thrust, CUB, and libcu++.
• Understand how you can easily compose different CUDA libraries and your own custom CUDA C++ code together.
• Build intuition about the performance implications of CUDA libraries.
• You'll leave confident about how to select the best tool for the job to accelerate your C++ applications for your unique use cases.

Bryce Adelstein Lelbach has spent over a decade developing programming languages, compilers, and libraries. He is passionate about parallel programming and strives to make it more accessible for everyone.
Bryce is a Principal Architect at NVIDIA, where he founded the Core C++ Compute Libraries team and now leads the Vanguard Programming group that drives NVIDIA's roadmap for programming languages, compilers, and core libraries.
He is a leader of the systems programming language community, having served as chair of the C++ Library Evolution and the US programming language standards committee. He has been an organizer and program chair for many conferences over the years. On the C++ committee, he has worked on concurrency primitives, parallel algorithms, senders, and multidimensional arrays.
He previously worked at Lawrence Berkeley National Laboratory and Louisiana State University. He is one of the founding developers of the HPX parallel runtime system.
Outside of work, Bryce is passionate about airplanes and watches. He lives in Midtown Manhattan with his girlfriend and dog.

Time-travel debugging is a powerful technique to dive deep into the execution of your applications, providing visibility simply not available any other way and enabling rapid diagnosis of issues as well as understanding of unfamiliar code bases. With the AI revolution going on today, hallucinations are a major concern and limiting factor for adoption. Combining these two technologies enables us to give the AI Agent all the information it could possibly want about what happened in your application. This enables it to both investigate when something goes wrong to develop a hypothesis, but also a way to validate that hypothesis, and iterate on it as needed until the AI Agent is able to verifiably explain what happened and why.

Chris Croft-White is a Staff Solutions Architect at Undo, where he works at the intersection of debugging technology and developer productivity. With a career spanning field applications engineering, security, and technical pre-sales, he brings a practitioner's perspective to the challenge of helping engineering teams ship reliable software faster. Chris is currently focused on the emerging field of agentic debugging, exploring how AI can move beyond code generation to become a genuine partner in root cause analysis and defect resolution. He writes and speaks on practical approaches to integrating AI into real-world debugging workflows, cutting through the hype to find what actually works.

The word "abstraction" is used extensively when discussing the facilities of C++. But what does it actually mean? Can you spot an abstraction when you see one? Can you spot the correct level of abstraction? Can you spot what is being abstracted? And what does a zero-cost abstraction mean? All these questions and more will be answered in this talk.

Guy Davidson is the convenor of the C++ standards committee. He is also the Head of Engineering at Six Impossible Things Before Breakfast. He has been writing games for nearly 50 years, having spent about half that time at Creative Assembly as the Head of Engineering Practice on the Total War franchise. He is the co-author of Beautiful C++, and you can find many of his talks online. In his copious free time, he plays the piano as well as singing first bass for the Brighton Festival Chorus. He lives in Brighton where he went to the University of Sussex back in the 80s.

Many codebases contain several spots of type punning, and unfortunately a whole lot of those are incorrect and undefined behavior. While many current versions of compilers seem to do the correct thing, they might no longer do that tomorrow. Safety considerations wants to reduce/eliminate UB.
It might be worthwhile to inspect your reinterpret_cast constructs, most probably they are wrong. In this talk we will inspect what is wrong about those, we will learn about alignment, strict aliasing, object lifetime. 3 areas which might flag a red card on our type punning constructions.
Luckily the language evolved and gave us more tools to do it correctly, things like memcpy, memmove, bit_cast, start_lifetime_as, launder. It does however remain a dark corner and a dangerous territory to wander in. Because let's face it, zero copy is something we love in C++, and those bytes that came from the network, really are an array of integers, array of coordinates, ... Compiler, trust me, I know what I am doing. Am I?

Lieven is a passionate software developer, architect, team lead, manager, coach, with 30 years of experience. He is passionate about C++, software craftsmanship, and clean code. His career started in the text-to-speech domain and then moved to video recognition technology for traffic environments. During the last 15 years he is active in the satellite communication industry. Lieven also contributes to several open source projects and is the lead developer of the open source IDE Code::Blocks. He is also the lead coach of the Coderdojo division in Ghent, Belgium where he lives. A major focus is on sharing knowledge on C++, coaching people to grow in C++, and maintaining and raising the bar on quality.

The C++ community has been challenged to provide practical solutions to the problem of memory safety prevalent in some software with large blast radius. By "practical", I mean solutions that scale to billions of lines of existing running code that deliver value every single day. The constraints we are dealt afford us neither the luxury of pausing the world for complete rewrite from scratch, nor only focusing on "future", yet to be written, code. C++ profiles are a tooling-based evolutionary approach that meets those constraints. They enable the C++ community to tackle similar problems in a single, extensible, and flexible framework.

Dr. Gabriel Dos Reis is an Architect for Visual Studio at Microsoft, working in the area of large scale software construction, tools, and technique. His contributions to C++ include scalable generic programming, pioneering compile-time computation, language support for modularity, safety, and security. He is interested in all aspects of software construction with bias towards computational logic, formal methods, and the fun of building useful tools.

This is a story of identifying what I think is a hole in the C++ type system, describing a mitigation strategy, and starting the process of engaging the Committee with a change to the C++ language that would help users write the affected classes in a simpler and more intuitive way. With luck, this change may make it into C++29.

Andre Kostur has over 30 years of experience as a professional C++ developer, with a focus on designing and developing network solutions. As a young graduate he was responsible for introducing C++ to his employer; convincing them to take a chance on a language that was still years away from initial standardization.

As a corporate champion of C++ as well as the founder and lead of multiple C++ user groups, Andre routinely presents on all things C++ from the basics to the latest developments. His speaking credits also include corporate presentations and appearing as a speaker at CPPCon.

Andre is a member of the Standards Council of Canada one of the Canadian representatives on the ISO C++ Committee; and an active member of the online C++ community.

It's been 15 years since Catch claimed to be a "Modern C++ Testing framework". C++ has been through some game changing stages of evolution in that time. What would a test framework built for the C++ of today look like?

Phil is the original author of the C++ test framework, Catch2 and other open source libraries.
A Senior Software Engineer at Bloomberg he has had a career that spans finance, mobile and software security, with a diversion into Developer Advocacy at JetBrains and Sonar.
He's also a member of the ISO C++ standards committee, organiser of C++ London and ACCU on Sea (the merging of the ACCU conference with C++ on Sea), as well as former co-host and producer of CppCast, cpp.chat and No Diagnostic Required.

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.

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

Building on the recent work of improving the quality of Sea of Thieves' codebase by upgrading from C++14 to C++20, this talk will focus on the work that has went into enabling warnings as errors on the game, and more. Rare will discuss the motivations behind wanting to crank up the warning level, and to flick the "warnings as errors" switch after 10 years of development in their multi-million line Unreal Engine code base.

Keith is a Northern Irish senior software engineer who has been working on the Engine and Rendering teams at Rare Ltd for the last 9 years. He primarily works on Engine and Rendering level systems involving General Purpose GPU systems such as GPU particle systems. Keith is enthusiastic about promoting writing good quality code, whether it is running on the CPU on the GPU.