CppCon Video Archive
Thank you for visiting. Here you will be able to get Early Access to ALL CppCon 2026 YouTube Videos including lightning talks
New CppCon 2026 videos will be added on a weekly basis.
Currently there are 29 videos in the early access program.
Filter
Your selections:
Taking Compiler Warnings Seriously in Sea of Thieves – Keith Stockdale – CppCon 2026
Beyond the Scheduler: Designing Predictable Embedded Systems in Modern C++ – Elbert Dockery – CppCon 2026
From Firmware to Screen: Real-Time Control, Simulation, and Visualization in C++23 With CUDA and Unreal Engine – Kevin Gomez – CppCon 2026
Back to Basics: const, constexpr, consteval – Andreas Fertig – CppCon 2026
Works on My Machine, Works in CI: Treating Your Build Toolchain as a Dependency – Luis Caro Campos – CppCon 2026
Towards a Complete Contract-Assertion Facility for C++ – Timur Doumler – CppCon 2026
Back to Basics: Move Semantics – Ruslan Arutyunyan – CppCon 2026
std::simd Without Compromise: SIMD in C++26 and Beyond, as Fast as Silicon Allows – Ruslan Arutyunyan & Daniel Towner – CppCon 2026
What’s New for C++ in Visual Studio Code: C++ and AI Tooling for Your Build, Your Code, Your Workflow – Sinem Akinci & Ben McMorran – CppCon 2026
Scaling Robotics to 200 Developers: Flexible C++ Architectures for Kinematics, Dynamics, Simulation & Control – Carl Saldanha – CppCon 2026
AEMBER: Modern Embedded C++ Without the Chaos – Arian Ajdari – CppCon 2026
Capability Routing Grid: From Decoupled Plugins to the Hardware Ceiling – Cyril TISSIER – CppCon 2026
Pointers to Power: Navigating Organizational Influence – Matt Kulukundis – CppCon 2026
Same Bits Without Losing MIPS: Reproducible Numerics at Full Hardware Speed – Andrew Drakeford – CppCon 2026
The Latency Slippage: Understanding the Hidden Costs of Caching for Low Latency C++
CUDA Tile C++: Practical Automatic Parallelization for the GPU – Ezra Stein – CppCon 2026
Back to Basics: Memory Alignment – Sarthak Sehgal – CppCon 2026
Refactoring Techniques and Strategies (a Tale in Three Acts) – Dave Steffen – CppCon 2026
Inside a Small Game Engine: An Architecture Tour in Modern C++ – Elias Farhan – CppCon 2026
TypeLayout: Can I memcpy This Type? Compile-Time Checks with C++26 Reflection – Fanchen Su
Why Great C++ Libraries Fail (And How to Fix That) – Mateusz Pusz – CppCon 2026
Back to Basics: Code Analysis – Alexsandro Thomas – CppCon 2026
Component Based or Monolithic Development for Large C and C++ Projects: Why Not Both? – Diego Rodriguez-Losada Gonzalez – CppCon 2026
Familiar C++ Patterns That Fail at Scale and the Design Shifts That Prevent Them – Divya Chandrasekar & Devpriya Dave – CppCon 2026
C++26: A Curated Tour of What’s New – Marc Gregoire – CppCon 2026
Your Next 20 Days of Systems Engineering – Andrei Alexandrescu – CppCon 2026
The Address is Not The Place: Object Residency in C++26 – Laurie Kirk – CppCon 2026
How C++26 Changes the Way We Write Code – Timur Doumler – CppCon 2026
Language Designers Panel – Bjarne Stroustrup, Guido van Rossum, Mads Torgersen & Emma Tracey
Profiles for Simplicity and Guarantees – Bjarne Stroustrup – CppCon 2026
Clean code! Horrible Performance? – Sandor Dargo – CppCon 2025
From C+ to C++: Modernizing a GameBoy Emulator – Tom Tesch – CppCon 2025
CTRACK: C++ Performance Tracking and Bottleneck Discovery – Grischa Hauser – CppCon 2025
Persistence Squared: Persisting Persistent Data Structures – Juan Pedro Bolivar Puente – CppCon 2025
Beyond the Big Green Button: Demystifying the Embedded Build Process – Morten Winkler Jørgensen – CppCon 2025
groov: Asynchronous Handling of Special Function Registers – Michael Caisse – CppCon 2025
Rust/C++ Interop Challenges – Victor Ciura – CppCon 2025
Constexpr STL Containers: Challenges and a Limitless Allocator Implementation – Sergey Dobychin – CppCon 2025
Graphics Programming with SDL 3 – Mike Shah – CppCon 2025
Work Contracts in Action: Advancing High-performance, Low-latency Concurrency – Michael Maniscalco
Dynamic Asynchronous Tasking with Dependencies – Tsung-Wei (TW) Huang – CppCon 2025
Interesting Upcoming Low-Latency, Concurrency, and Parallelism Features from Wroclaw 2024, Hagenberg 2025, and Sofia 2025 – Paul E. McKenney, Maged Michael, Michael Wong – CppCon 2025
Beyond Sequential Consistency – Christopher Fretz – CppCon 2025
Type Traits without Compiler Intrinsics – The Promise of Static Reflection – Andrei Zissu – CppCon 2025
The Wonderful World of Designing a USB Stack Using Modern C++ – Madeline Schneider – CppCon 2025
Back to Basics: Move Semantics – Ben Saks – CppCon 2025
Panel: What We Learned About AI Tools For C++ Engineers – Hosted by Guy Davidson – CppCon 2025
ISO C++ Standards Committee Panel Discussion 2025 – Hosted by Herb Sutter – CppCon 2025
Practical Reflection – Barry Revzin – CppCon 2025
Duck Typing, the C++ Way: How Type Erasure Bends the Rules – Sarthak Sehgal – CppCon 2025
Sanitize It Before You Ship It: Catching Hidden Concurrency Bugs in C++ – Vishnu G Nath
Back to the Standard: From CUDA and Pragmas to GPU-Accelerated Parallel C++ – Elmar Westphal – CppCon 2025
Modern C++ for Embedded Systems: From Fundamentals to Real-Time Solutions – Rutvij Girish Karkhanis
The Pattern Matching We Already Have – Braden Ganetsky – CppCon 2025
End-to-End Latency Metrics From Distributed Trace – Kusha Maharshi – CppCon 2025
C++26 Reflection for JSON Serialization – A Practical Journey – Daniel Lemire & Francisco Geiman Thiesen – CppCon 2025
Building a Career Off-Road – Sherry Sontag – CppCon 2025
Wait is it POSIX? Investigating Different OS and Library Implementations for Networking – Katherine Rocha – CppCon 2025
From Pure ISO C++20 To Compute Shaders – Koen Samyn – CppCon 2025
Knockin’ on Header’s Door: An Overview of C++ Modules – Alexsandro Thomas – CppCon 2025
Seamless Static Analysis with Cppcheck: From IDE to CI and Code Review – Daniel Marjamäki – CppCon 2025
It’s Dangerous to Go Alone: A Game Developer Tutorial – Michael Price – CppCon 2025
Leverage AI Agents to Refactor and Modernize Code – Jubin Chheda – CppCon 2025
Cache Me Maybe – Optimize Your Code By Utilizing Your Cache – Michelle D’Souza – CppCon 2025
Back to Basics: Concepts – Jeff Garland – CppCon 2025
C++ ♥ Python – Alex Dathskovsky – CppCon 2025
Agentic Debugging Live! – Without a Safety Net – Daisy Hollman & Mark Williamson – CppCon 2025
Threads vs Coroutines: Understanding the Concurrency Models of C++ – Conor Spilsbury – CppCon 2025
Instrumenting the Stack: Strategies for End-to-end Sanitizer Adoption – Damien Buhl – CppCon 2025
Achieving Peak Performance for Matrix Multiplication – Aliaksei Sala – CppCon 2025
C++ Parallel Programming Models – Eran Gilad – CppCon 2025
First Principles While Designing C++ Applications – Prabhu Missier – CppCon 2025
Shadow Stack: Forget Memory Corruptions, Ultimate C and C++ Safety – Bartosz Moczulski – CppCon 2025
Best Practices for AI Tool Use – Jason Turner – CppCon 2025
Back to Basics: Common C++ Code Review Feedback – Chandranath Bhattacharyya & Kathleen Baker – CppCon 2025
MSVC C++ Dynamic Debugging: How We Enabled Full Debuggability of Optimized Code – Eric Brumer – CppCon 2025
Back to Basics: Custom Allocators – Kevin Carpenter – CppCon 2025
Back To Basics: C++ Strings and Character Sequences – Nicolai Josuttis – CppCon 2025
std::execution in Asio Codebases: Adopting Senders Without a Rewrite – Robert Leahy – CppCon 2025
A Case-study in Rewriting a Legacy Gui Library for Real-time Audio Software in Modern C++ (Reprise) – Roth Michaels – CppCon 2025
Back to Basics: static, inline, const, and constexpr – Andreas Fertig – CppCon 2025
Parallel Range Algorithms: The Evolution of Parallelism in C++ – Ruslan Arutyunyan – CppCon 2025
How to Avoid Headaches with Simple CMake – Bret Brown – CppCon 2025
An Introduction to the new C++ 26 “Reflection” Feature – Inbal Levi – CppCon 2025
Zero-Overhead Abstractions: Building Flexible Vector Math Libraries with C++20 Concepts and Customization Points – Greg von Winckel – CppCon 2025
The Programmer CEO – Greg Law – CppCon 2025
Compiler Explorer: The Features You Never Knew Existed – Matt Godbolt – CppCon 2025
Connecting C++ Tools to AI Agents Using the Model Context Protocol (MCP) – Ben McMorran – CppCon 2025
Networks in C++ – Ignas Bagdonas – CppCon 2025
Mastering the Code Review Process – Pete Muldoon – CppCon 2025
Cross-Platform Package Management for Modern C++ Development with Pixi – Ruben Arts – CppCon 2025
Using Floating-point in C++: What Works, What Breaks, and Why – Egor Suvorov – CppCon 2025
To Err is Human: Robust Error Handling in C++26 – Sebastian Theophil – CppCon 2025
C++ Performance Tips: Cutting Down on Unnecessary Objects – Prithvi Okade & Kathleen Baker – CppCon 2025
Engineering the Software, from DevEx to Delivery – Malin Stanescu – CppCon 2025
Modern CMake: Past, Present, and Future – Bill Hoffman – CppCon 2025
LLMs in the Trenches: Boosting System Programming with AI – Ion Todirel – CppCon 2025
Lazy and Fast: Ranges Meet Parallelism in C++ – Daniel Anderson – CppCon 2025
C++26 – What’s In It For You? – Marc Gregoire – CppCon 2025
Making C++ Safe, Healthy, and Efficient – John Lakos – CppCon 2025
Back to Basics: Ranges – Mike Shah – CppCon 2025
How to Tame Packs, std::tuple, and the Wily std::integer_sequence – Andrei Alexandrescu – CppCon 2025
API Structure and Technique: Learnings from Code Review – Ben Deane – CppCon 2025
15 Years Doing C++ Standardization Work: A Personal Retrospective – Nevin Liber – CppCon 2025
Cache-Friendly C++ – Jonathan Müller – CppCon 2025
Engineers Are Users Too: A Case Study in Design Thinking for Infrastructure – Grace Alwan – CppCon 2025
Rust Trait Runtime Polymorphism in C++ – Eduardo Madrid – CppCon 2025
Debugging C++ Coroutines in GDB – Zartaj Majeed – CppCon 2025
Building a High-Performance Binary Serialization Format with In-Place Modification – Hamish Morrison – CppCon 2025
What’s New in Visual Studio for C++ Developers in 2025 – Augustin Popa & David Li – CppCon 2025
What’s New for C++ in VS Code: CMake Improvements and GitHub Copilot Agents – Alexandra Kemper – CppCon 2025
Modern C++ for Robust Bundle Adjustment: From Outliers to Optimization – Vishnu Sudheer Menon – CppCon 2025
Implementing Your Own Atomics – Ben Saks – CppCon 2025
Inherently Unsafe: Practical Approaches for Writing Safer C++ – Assaf Tzur-El – CppCon 2025
Creating a Declarative UI Library in C++ – Richard Powell – CppCon 2025
The Missing Step: Making Data Oriented Design One Million Times Faster – Andrew Drakeford – CppCon 2025
Declarative Refactoring for the Masses – Andy Soffer – CppCon 2025
Building Secure C++ Applications: A Practical End-to-End Approach – Chandranath Bhattacharyya & Bharat Kumar – CppCon 2025
Where’d All that RAM Go? Measuring Objects With Ownership-Aware Memory Profiling in C++ – Alecto Irene Perez – CppCon 2025
Challenges and Benefits of Upgrading Sea of Thieves From C++14 to C++20 – Keith Stockdale – CppCon 2025
Back to Basics: Friendship – Mateusz Pusz – CppCon 2025
Performance Optimization for Automatic Differentiation in C++ – Steve Bronder – CppCon 2025
Building Robust Inter-Process Queues in C++ – Jody Hagins – CppCon 2025
Performance Is Not a Number: Avoiding Microbenchmarking Pitfalls – Kris Jusiak – CppCon 2025
Performance of std::expected With Monadic Operations – Vitaly Fanaskov – CppCon 2025
How to Affect the Future of C++ Standard in 60 Minutes – River Wu – CppCon 2025
Back to Basics: Refactoring – Amir Kirsh – CppCon 2025
Catching Bugs Early: Validating C++ Contracts with Static Analysis – Peter Martin & Mike Fairhurst
The Joy of C++26 Contracts (and Some Myth-Conceptions) – Herb Sutter – CppCon 2025
Cutting C++ Exception Time by +90% – Khalil Estell – CppCon 2025
Enhancing Exception Handling and Debugging Using C++23 std::stacktrace – Erez Strauss – CppCon 2025
Implement Standard Library: Design Decisions, Optimisations and Testing in Implementing Libc++ – Hui Xie – CppCon 2025
Could We Handle an ABI Break Today? – Luis Caro Campos – CppCon 2025
std::optional＜T&＞ — Optional Over References – Steve Downey – CppCon 2025
C++: Some Assembly Required – Matt Godbolt – CppCon 2025
More Speed & Simplicity: Practical Data-Oriented Design in C++ – Vittorio Romeo – CppCon 2025
Reflection: C++’s Decade-Defining Rocket Engine – Herb Sutter – CppCon 2025
Crafting the Code You Don’t Write: Sculpting Software in an AI World – Daisy Hollman – CppCon 2025
Concept-based Generic Programming – Bjarne Stroustrup – CppCon 2025
Leveraging C++ for Efficient Motion Planning: RRT Algorithm for Robotic Arms – Aditi Pawaskar – CppCon 2024
To Int or to Uint, This is the Question – Alex Dathskovsky – CppCon 2024
Guide to Linear Algebra With the Eigen C++ Library – Daniel Hanson – CppCon 2024
Security Beyond Memory Safety – Using Modern C++ to Avoid Vulnerabilities by Design – Max Hoffmann
Code Generation from Unified Robot Description Format (URDF) for Accelerated Robotics – Paul Gesel
Cost of C++ Abstractions in C++ Embedded Systems – Marcell Juhasz – CppCon 2024
Perspectives on Contracts for C++ – Lisa Lippincott – CppCon 2024
How to Hide C++ Implementation Details – Amir Kirsh – CppCon 2024
How to Quickly Convert Floating-Point Numbers in C++ – Cassio Neri – CppCon 2024
Implementing C++ Reflection Using the New C++20 Tooling Opportunity: Modules – Maiko Steeman – CppCon 2024
Boosting Software Efficiency in C++: A Case Study of 100% Performance Improvement in an Embedded C++ System – Gili Kamma – CppCon 2024
Newer Isn’t Always Better: Investigating C++ Legacy Design Trends and Their Modern Replacements – Katherine Rocha – CppCon 2024
Modern C++ Development – Limitations and Problems in std::function and Similar Constructs: Mitigations and Alternatives – Amandeep Chawla – CppCon 2024
Back to Basics: Rvalues and Move Semantics in C++ – Amir Kirsh – CppCon 2024
Template-less Metaprogramming in C++ – Kris Jusiak – CppCon 2024
C++ Sender Patterns to Wrangle C++ Concurrency in Embedded Devices – Michael Caisse – CppCon 2024
Monadic Operations in Modern C++: A Practical Approach – Vitaly Fanaskov – CppCon 2024
Back to Basics: Lifetime Management in Cpp – Phil Nash – CppCon 2024
spanny 2: Rise of C++ std::mdspan – Griswald Brooks – CppCon 2024
Why Is My C++ Build So Slow? Compilation Profiling and Visualization – Samuel Privett – CppCon 2024
Deciphering C++ Coroutines Part 2 – Mastering Asynchronous Control Flow – Andreas Weis – CppCon 2024
Lightweight Operator Fusion Using Data-Centric Function Interfaces in C++ – Manya Bansal – CppCon
Adventures with C++ Legacy Codebases: Tales of Incremental Improvement – Roth Michaels – CppCon 2024
Modern C++ Error Handling – Phil Nash – CppCon 2024
Moved-from Objects in C++ – Jon Kalb – CppCon 2024
C++ Data Structures That Make Video Games Go Round – Al-Afiq Yeong – CppCon 2024
Cross-Platform Floating-Point Determinism Out of the Box – Sherry Ignatchenko – CppCon 2024
C++/Rust Interop: A Practical Guide to Bridging the Gap Between C++ and Rust – Tyler Weaver – CppCon
Back to Basics: Object-Oriented Programming in C++ – Andreas Fertig – CppCon 2024
Ranges++: Are Output Range Adaptors the Next Iteration of C++ Ranges? – Daisy Hollman – CppCon 2024
Session Types in C++ – A Programmer’s Journey – Miodrag Misha Djukic – CppCon 2024
Numerical Integrators From Scratch in C++ – Vincent Reverdy – CppCon 2024
Recent Concurrency and Parallelism Proposals to the C++ Standard Committee – Paul E. McKenney, Maged Michael & Michael Wong – CppCon 2024
import CMake; // Mastering C++ Modules – Bill Hoffman – CppCon 2024
Rollback System in C++ for Online Multiplayer Games – Elias Farhan – CppCon 2024
Bridging the Gap: Writing Portable C++ Programs for CPU and GPU – Thomas Mejstrik – CppCon 2024
Beyond Compilation Databases to Support C++ Modules: Build Databases – Ben Boeckel – CppCon 2024
Performance Optimization in Software Development – Being Friendly to Your Hardware – Ignas Bagdonas
Implementing Particle Filters with C++ Ranges – Nahuel Espinosa – CppCon 2024
Blazing Trails: Building the World’s Fastest GameBoy Emulator in Modern C++ – Tom Tesch – CppCon 2024
C++ 20 Innovations: High-Performance Cross-Platform Architecture in C++ – Noah Stein – CppCon 2024
SuperCharge Your Intra-Process Communication Programs With C++20 and Contract-Concept-Implementation Pattern – Arian Ajdari – CppCon 2024
Making Hard C++ Tests Easy: A Case Study From the Motion Planning Domain – Chip Hogg – CppCon 2024
Build Safer Modern C++ Application: Mix Assertion, Logging, Unit Testing and Fuzzing with ZeroErr – Xiaofan Sun – CppCon 2024
Building Safe and Reliable Surgical Robotics with C++ – Milad Khaledyan – CppCon 2024
C++ Under the Hood: Internal Class Mechanisms – Chris Ryan – CppCon 2024
Refactoring C++ Code for Unit testing with Dependency Injection – Peter Muldoon – CppCon 2024
How to Design a Slimmer Vector of Variants in C++ – Christopher Fretz – CppCon 2024
Back to Basics: Functional Programming and Monads in C++ – Jonathan Müller – CppCon 2024
Secrets of C++ Scripting Bindings: Bridging Compile Time and Run Time – Jason Turner – CppCon 2024
How to Improve the Safety of C++ Code With a Quantities & Units Library – Mateusz Pusz – CppCon 2024
The Beman Project: Bringing C++ Standard Libraries to the Next Level – David Sankel – CppCon 2024
Cpp Contracts – How Contracts in C++26 Can Improve C++ Code Safety and Correctness – Timur Doumler
Associative Iteration – Composing Ancient Mathematical Knowledge Into Powerful Bit-fiddling Techniques – Jamie Pond – CppCon 2024
How to Use string_view in C++ – Basics, Benefits, and Best Practices – Jasmine Lopez & Prithvi Okade – CppCon 2024
Using Modern C++ to Build XOffsetDatastructure: A Zero-Encoding and Zero-Decoding High-Performance Serialization Library in the Game Industry – Fanchen Su – CppCon 2024
Designing C++ Code Generator Guardrails: A Collaboration Among Outreach and Development Teams and Users – CB Bailey & Sherry Sontag – CppCon 2024
Vectorizing a Computational Fluid Dynamics (CFD) Code in C++ Using std::simd – Olaf Krzikalla – CppCon 2024
Application of C++ in Computational Cancer Modeling – Ruibo Zhang – CppCon 2024
How to Use the Sender/Receiver Framework in C++ to Create a Simple HTTP Server – Dietmar Kühl – CppCon 2024
Work Contracts – Rethinking Task Based Concurrency and Parallelism for Low Latency C++ – Michael A Maniscalco – CppCon 2024
Async Stacks: Making Senders and Coroutines Debuggable – Ian Petersen & Jessica Wong – CppCon 2024
C++ Safety And Security Panel 2024 – Hosted by Michael Wong – CppCon 2024
C++ Design Patterns – The Most Common Misconceptions (2 of N) – Klaus Iglberger – CppCon 2024
Techniques to Optimise Multithreaded Data Building During C++ Game Development – Dominik Grabiec – CppCon 2024
The Most Important C++ Design Guideline is Testability – Jody Hagins – CppCon 2024
LLVM’s Realtime Safety Revolution: Tools for Modern Mission Critical Systems – Christopher Apple & David Trevelyan – CppCon 2024
C++ Game Development – Many Ways to Kill an Orc (or a Hero) – Patrice Roy – CppCon 2024
What’s New in Visual Studio for C++ Developers – Michael Price & Mryam Girmay – CppCon 2024
What’s New for Visual Studio Code: Performance, GitHub Copilot, and CMake Enhancements – Sinem Akinci & Alexandra Kemper – CppCon 2024
10 Problems Large Companies Have Managing C++ Dependencies and How to Solve Them – Augustin Popa
Fast and Small C++ – When Efficiency Matters – Andreas Fertig – CppCon 2024
Taming C++ Filter View in C++ Programming – Nicolai Josuttis – CppCon 2024
Introduction to Wait-free Algorithms in C++ Programming – Daniel Anderson – CppCon 2024
C++ Reflection Is Not Contemplation – Andrei Alexandrescu – CppCon 2024
Reusable Code, Reusable Data Structures – Sebastian Theophil – CppCon 2024
Back to Basics: Concepts in C++ – Nicolai Josuttis – CppCon 2024
User API & C++ Implementation of a Multi Producer, Multi Consumer, Lock Free, Atomic Queue – Erez Strauss – CppCon 2024
C++ Shared Libraries and Where To Find Them – Luis Caro Campos – CppCon 2024
Leveraging C++20/23 Features for Low Level Interactions – Jeffrey Erickson – CppCon 2024
So You Think You Can Hash – Victor Ciura – CppCon 2024
Common Package Specification (CPS) in Practice: A Full Round Trip Implementation in Conan C++ Package Manager – Diego Rodriguez-Losada Gonzalez – CppCon 2024
C++ RVO: Return Value Optimization for Performance in Bloomberg C++ Codebases – Michelle Fae D’Souza
C++ Relocation: Blazing Fast Save And Restore, Then More! – Eduardo Madrid – CppCon 2024
What’s Eating my RAM? – C++ Memory Management – Jianfei Pan – CppCon 2024
Coroutines and Structured Concurrency in Practice – Dmitry Prokoptsev – CppCon 2024
Building Cppcheck – What We Learned from 17 Years of Development – Daniel Marjamäki – CppCon 2024
Back to Basics: Generic Programming – David Olsen – CppCon 2024
Compile-Time Validation – Alon Wolf – CppCon 2024
Hidden Overhead of a Function API – Oleksandr Bacherikov – CppCon 2024
Back to Basics: Debugging and Testing – Greg Law & Mike Shah – CppCon 2024
Back to Basics: Function Call Resolution – Ben Saks – CppCon 2024
C++26 Preview – The Smaller Features – Jeff Garland – CppCon 2024
Reflection Based Libraries to Look Forward to – Saksham Sharma – CppCon 2024
Message Handling with Boolean Algebra – Ben Deane – CppCon 2024
Back to Basics: Almost Always Vector – Kevin Carpenter – CppCon 2024
What Volatile Means (and Doesn’t Mean) – Ben Saks – CppCon 2024
Back to Basics: Unit Testing – Dave Steffen – CppCon 2024
Gazing Beyond Reflection for C++26 – Daveed Vandevoorde – CppCon 2024
When Nanoseconds Matter: Ultrafast Trading Systems in C++ – David Gross – CppCon 2024
Embracing an Adversarial Mindset for C++ Security – Amanda Rousseau – CppCon 2024
ISO C++ Standards Committee Panel Discussion 2024 – Hosted by Herb Sutter – CppCon 2024
C++ Exceptions for Smaller Firmware – Khalil Estell – CppCon 2024
Peering Forward — C++’s Next Decade – Herb Sutter – CppCon 2024
Back to Basics: Testing in C++ – Phil Nash – CppCon 2023
Back to Basics: Initialization in C++ – Ben Saks – CppCon 2023
Safety and Security for C++: Panel Discussion – Hosted by Michael Wong – CppCon 2023
Great C++ is_trivial: trivial type traits – Jason Turner – CppCon 2023
Building Bridges: Leveraging C++ and ROS for Simulators, Sensor Data and Algorithms – Cesar Gerardo Bravo Conejo & Divya Aggarwal – CppCon 2023
Khronos APIs for Heterogeneous Compute and Safety: SYCL and SYCL SC – CppCon 2023
Plug-in Based Software Architecture for Robotics – Abishalini Sivaraman & Anthony Baker – CppCon 2023
Iteration Revisited: A Safer Iteration Model for Cpp – Tristan Brindle – CppCon 2023
Powered by AI: A Cambrian Explosion for C++ Software Development Tools – Emery Berger – CppCon 2023
C++ Object Lifetime: From Start to Finish – Thamara Andrade – CppCon 2023
Embracing CTAD – Nina Ranns – CppCon 2023
Getting Started with C++ – Michael Price – CppCon 2023
Abstraction Patterns for Cross Platform Development Using C++ – Al-Afiq Yeong – CppCon 2023
C++ Memory Model: from C++11 to C++23 – Alex Dathskovsky – CppCon 2023
C++ in the Developing World: Why it Matters – Mathew Benson – CppCon 2023
Single Producer Single Consumer Lock-free FIFO From the Ground Up – Charles Frasch – CppCon 2023
Undefined Behavior in C++: What Every Programmer Should Know and Fear – Fedor Pikus – CppCon 2023
Concurrency TS2: Improved C++ Concurrency and Lock-free Programming – Maged Michael & Michael Wong
Symbolic Calculus for High-performance Computing From Scratch Using C++23 – Vincent Reverdy – CppCon
Back to Basics: Iterators in C++ – Nicolai Josuttis – CppCon 2023
Is std::mdspan a Zero-overhead Abstraction? – Oleksandr Bacherikov – CppCon 2023
Exploration of Strongly-typed Units in C++: A Case Study from Digital Audio – Roth Michaels – CppCon 2023
A Common Package Specification: Getting Build Tools to Talk to Each Other – Lessons Learned – CppCon 2023
Building Effective Embedded Systems in C++: Architectural Best Practices – Gili Kamma – CppCon 2023
Designing Fast and Efficient List-like Data Structures – Yannic Bonenberger – CppCon 2023
Advanced SIMD Algorithms in Pictures – Denis Yaroshevskiy – CppCon 2023
Coroutine Patterns: Problems and Solutions Using Coroutines in a Modern Codebase – Francesco Zoffoli
Monads in Modern C++ – Georgi Koyrushki & Alistair Fisher – CppCon 2023
How to Build Your First C++ Automated Refactoring Tool – Kristen Shaker – CppCon 2023
Applicative: The Forgotten C++ Functional Pattern – Ben Deane – CppCon 2023
ISO C++ Standards Committee Panel Discussion – Hosted by Herb Sutter – CppCon 2023
Better CMake: A World Tour of Build Systems – Better C++ Builds – Damien Buhl & Antonio Di Stefano
Behavioral Modeling in HW/SW Co-design Using C++ Coroutines – Jeffrey Erickson & Sebastian Schoenberg
Better Code: Exploring Validity in C++ – David Sankel – CppCon 2023
Optimizing Away C++ Virtual Functions May Be Pointless – Shachar Shemesh – CppCon 2023
Six Ways for Implementing Math Expressions Calculator in C++ – Amir Kirsh – CppCon 2023
Writing Python Bindings for C++ Libraries: Easy-to-use Performance – Saksham Sharma – CppCon 2023
Better Code: Contracts in C++ – Sean Parent & Dave Abrahams – CppCon 2023
Back to Basics: Forwarding References – How to Forward Parameters in Modern C++ – Mateusz Pusz 2023
Tips on Surveying the C++ Community – Anastasia Kazakova – CppCon 2023
Building Consensus on a Set of Rules for Our Massive C++ Codebase – Sherry Sontag – CppCon 2023
Back to Basics: The Rule of Five in C++ – Andre Kostur – CppCon 2023
An Introduction to Tracy Profiler in C++ – Marcos Slomp – CppCon 2023
C++ Regular, Revisited – Victor Ciura – CppCon 2023
The Absurdity of Error Handling: Finding a Purpose for Errors in Safety-Critical SYCL – Erik Tomusk – CppCon 2023
Robotics at Compile Time: Optimizing Robotics Algorithms With C++’s Compile-Time Features – Stephen Brawner – CppCon 2023
BehaviorTree.CPP: Task Planning for Robots and Virtual Agents – Davide Faconti – CppCon 2023
More Ranges Please – Roi Barkan – CppCon 2023
Leveraging a Functional Approach for More Testable & Maintainable ROS 2 Code – Bilal Gill – CppCon 23
Why Loops End – Lisa Lippincott – CppCon 2023
C++23: An Overview of Almost All New and Updated Features – Marc Gregoire – CppCon 2023
Evolution of a Median Algorithm – Pete Isensee – CppCon 2023
Leveraging the Power of C++ for Efficient Machine Learning on Embedded Devices – Adrian Stanciu – CppCon 2023
Can C++ Data-oriented-design be Improved? – Ollivier Roberge – CppCon 2023
Advancing cppfront with Modern C++: Refining the Implementation of is, as, and UFCS – Filip Sajdak – CppCon 2023
Back to Basics: C++ Concurrency – David Olsen – CppCon 2023
Object Introspection: A C++ Memory Profiler – Jonathan Haslam & Aditya Sarwade – CppCon 2023
Expressing Implementation Sameness and Similarity – Polymorphism in Modern C++ – Daisy Hollman
C++ Modules: Getting Started Today – Andreas Weis – CppCon 2023
std::linalg: Linear Algebra Coming to Standard C++ – Mark Hoemmen – CppCon 2023
Exceptionally Bad: The Misuse of Exceptions in C++ & How to Do Better – Peter Muldoon – CppCon 2023
Things Happening in SG14… – Patrice Roy – CppCon 2023
Noexcept? Enabling Testing of Contract Checks in C++ – Pablo Halpern & Timur Doumler – CppCon 2023
Linkers, Loaders and Shared Libraries in Windows, Linux, and C++ – Ofek Shilon – CppCon 2023
C++20 Modules: The Packaging and Binary Redistribution Story – Luis Caro Campos – CppCon 2023
A Long Journey of Changing std::sort Implementation at Scale – Danila Kutenin – CppCon 2023
Customization Methods: Connecting User and Library Code – Inbal Levi
Lock-free Atomic Shared Pointers Without a Split Reference Count? It Can Be Done! – Daniel Anderson
Back to Basics: (Range) Algorithms in C++ – Klaus Iglberger – CppCon 2023
Taro: Task Graph-Based Asynchronous Programming Using C++ Coroutine – Dian-Lun Lin – CppCon 2023
The Au C++ Units Library: Handling Physical Units Safely, Quickly, & Broadly – Chip Hogg – CppCon 23
A Fast, Compliant JSON Pull Parser for Writing Robust Applications – Jonathan Müller
File I/O for Game Developers: Past, Present, and Future with C++ – Guy Davidson – CppCon 2023
Lifetime Safety in C++: Past, Present and Future – Gabor Horvath – CppCon 2023
Back to Basics: Debugging in Cpp – Greg Law – CppCon 2023
Expressive Compile-time Parsers in C++ – Alon Wolf – CppCon 2023
Effective Ranges: A Tutorial for Using C++2x Ranges – Jeff Garland – CppCon 2023
A Journey Into Non-Virtual Polymorphism in C++ – Rudyard Merriam – CppCon 2023
Cache-friendly Design in Robot Path Planning with C++ – Brian Cairl
Thinking Functionally in C++ – Brian Ruth – CppCon 2023
Back to Basics: Functions in C++ – Mike Shah – CppCon 2023
Continuous Regression Testing for Safer and Faster Refactoring in C++ – Pejman Ghorbanzade – CppCon
“Distributed Ranges”: Model for Building Distributed Data Structures, Algorithms & Views – Ben Brock
Finding Your Codebases C++ Roots – Katherine Rocha – CppCon 2023
How Visual Studio Code Helps You Develop More Efficiently in C++ – Alexandra Kemper and Sinem Akinci
New in Visual Studio: CMake Debugger, Better Diagnostics, and Video Games – David Li & Mryam Girmay
std::simd: How to Express Inherent Parallelism Efficiently Via Data-parallel Types – Matthias Kretz
Robots Are After Your Job: Exploring Generative AI for C++ – Andrei Alexandrescu
Cooperative C++ Evolution – Toward a Typescript for C++ – Herb Sutter
Coping With Other People’s Code – Laura Savino
Libraries: A First Step Toward Standard C++ Dependency Management – Bret Brown & Bill Hoffman
Delivering Safe C++ – Bjarne Stroustrup – CppCon 2023
Deciphering C++ Coroutines – A Diagrammatic Coroutine Cheat Sheet – Andreas Weis – CppCon 2022
Can C++ be 10x Simpler & Safer? – Herb Sutter – CppCon 2022
ISO C++ Standards Committee Panel Discussion – Hosted by Herb Sutter – CppCon 2022
C++ Lambda Idioms – Timur Doumler – CppCon 2022
C++ Concurrency TS 2 Use Cases and Future Direction – Michael Wong, Maged Michael, Paul McKenney
Understanding Allocator Impact on Runtime Performance in C++ – Parsa Amini – CppCon 2022
Using Incredibuild to Accelerate Static Code Analysis and Builds – Jonathan “Beau” Peck CppCon 2022
Help! My Codebase has 5 JSON Libraries – How Generic Programming Rescued Me – Christopher McArthur
Back to Basics: Cpp Value Semantics – Klaus Iglberger – CppCon 2022
HPX – A C++ Library for Parallelism and Concurrency – Hartmut Kaiser – CppCon 2022
import CMake, CMake and C++20 Modules – Bill Hoffman – CppCon 2022
Back to Basics: C++ Move Semantics – Andreas Fertig – CppCon 2022
C++ Performance Portability – A Decade of Lessons Learned – Christian Trott – CppCon 2022
Taking a Byte Out of C++ – Avoiding Punning by Starting Lifetimes – Robert Leahy – CppCon 2022
C++ Package Manager – C++ Dependencies Don’t Have To Be Painful! – Augustin Popa
How Microsoft Uses C++ to Deliver Office – Huge Size, Small Components – Zachary Henkel – CppCon 2022
Back to Basics: Templates in C++ – Nicolai Josuttis – CppCon 2022
Back to Basics: Debugging in C++ – Mike Shah – CppCon 2022
Functional Composable Operations with Unix-Style Pipes in C++ – Ankur Satle – CppCon 2022
C++23 – What’s In It For You? – Marc Gregoire – CppCon 2022
Optimizing Binary Search – Sergey Slotin – CppCon 2022
GPU Accelerated Computing & Optimizations on Cross-Vendor Graphics Cards with Vulkan & Kompute
Back to Basics: Standard Library Containers in Cpp – Rainer Grimm – CppCon 2022
Nth Pack Element in C++ – A Case Study – Kris Jusiak – CppCon 2022
What Is an Image? – Cpp Computer Graphics Tutorial, (GPU, GUI, 2D Graphics and Pixels Explained)
A Pattern Language for Expressing Concurrency in Cpp – Lucian Radu Teodorescu – CppCon 2022
-memory-safe C++ – Jim Radigan – CppCon 2022
What Can Compiler Benchmarks Reveal About Metaprogramming Implementation Strategies Vincent Reverdy
Value Semantics: Safety, Independence, Projection, & Future of Programming – Dave Abrahams – CppCon 2022
LLVM Optimization Remarks – Ofek Shilon – CppCon 2022
Modern C++: C++ Patterns to Make Embedded Programming More Productive – Steve Bush – CppCon 2022
Fast, High-Quality Pseudo-Random Numbers for Non-Cryptographers in C++ – Roth Michaels – CppCon 2022
What’s New in Conan 2.0 C/C++ Package Manager – Diego Rodriguez-Losada – CppCon 2022
Killing C++ Serialization Overhead & Complexity – Eyal Zedaka – CppCon 2022
10 Tips for Cleaner C++ 20 Code – David Sackstein – CppCon 2022
C++ in the World of Embedded Systems – Vladimir Vishnevskii – CppCon 2022
Breaking Enigma With the Power of Modern C++ – Mathieu Ropert – CppCon 2022
The Dark Corner of STL in Cpp: MinMax Algorithms – Šimon Tóth – CppCon 2022
Contemporary C++ in Action – Daniela Engert – CppCon 2022
A Faster Serialization Library Based on Compile-time Reflection and C++ 20 – Yu Qi – CppCon 2022
Breaking Dependencies – C++ Type Erasure – The Implementation Details – Klaus Iglberger CppCon 2022
Optimizing A String Class for Computer Graphics in Cpp – Zander Majercik, Morgan McGuire CppCon 22
GPU Performance Portability Using Standard C++ with SYCL – Hugh Delaney & Rod Burns – CppCon 2022
Back to Basics: Master C++ Value Categories With Standard Tools – Inbal Levi – CppCon 2022
From C++ Templates to C++ Concepts – Metaprogramming: an Amazing Journey – Alex Dathskovsky
Introduction to Hardware Efficiency in Cpp – Ivica Bogosavljevic – CppCon 2022
The Most Important Optimizations to Apply in Your C++ Programs – Jan Bielak – CppCon 2022
Back to Basics: RAII in C++ – Andre Kostur – CppCon 2022
10 Years of Meeting C++ – Historical Highlights and the Future of C++ – Jens Weller – CppCon 2022
The Hidden Performance Price of C++ Virtual Functions – Ivica Bogosavljevic – CppCon 2022
Managing External API’s in Enterprise systems – Pete Muldoon – CppCon 2022
A Lock-Free Atomic Shared Pointer in Modern Cpp – Timur Doumler – CppCon 2022
MDSPAN – A Deep Dive Spanning C++, Kokkos & SYCL – Nevin Liber – CppCon 2022
Embracing Trailing Return Types and `auto` Return SAFELY in Modern C++ – Pablo Halpern – CppCon 2022
An Introduction to Multithreading in C++20 – Anthony Williams – CppCon 2022
C++ Coding with Neovim – Prateek Raman – CppCon 2022
Scalable and Low Latency Lock-free Data Structures in C++ – Alexander Krizhanovsky – CppCon
Back to Basics: C++ API Design – Jason Turner – CppCon 2022
Case For a Standardized Package Description Format for External C++ Libraries – Luis Caro Campos
Graph Algorithms and Data Structures in C++20 – Phil Ratzloff & Andrew Lumsdaine – CppCon 2022
Using Modern C++ to Eliminate Virtual Functions – Jonathan Gopel – CppCon 2022
Back to Basics: C++ Smart Pointers – David Olsen – CppCon 2022
C++ for Enterprise Applications – Vincent Lextrait – CppCon 2022
C++ Function Multiversioning in Windows – Joe Bialek and Pranav Kant – CppCon 2022
Purging Undefined Behavior & Intel Assumptions in a Legacy C++ Codebase – Roth Michaels CppCon 2022
WebAssembly: Taking Your C++ and Going Places – Nipun Jindal & Pranay Kumar – CppCon 22
Refresher on Containers, Algorithms and Performance in C++ – Vladimir Vishnevskii – CppCon 2022
C++ MythBusters – Victor Ciura – CppCon 2022
Back to Basics: C++ Testing – Amir Kirsh – CppCon 2022
Undefined Behavior in the STL – Sandor Dargo – CppCon 2022
Understanding C++ Coroutines by Example: Generators (Part 2 of 2) – Pavel Novikov – CppCon 2022
Understanding C++ Coroutines by Example: Generators (Part 1 of 2) – Pavel Novikov – CppCon 2022
Taking Static Type-Safety to the Next Level – Physical Units for Matrices – Daniel Withopf CppCon 22
The Hidden Performance Price of C++ Virtual Functions – Ivica Bogosavljevic – CppCon 2022
High Speed Query Execution with Accelerators and C++ – Alex Dathskovsky – CppCon 2022
Aliasing in C++ – Risks, Opportunities and Techniques – Roi Barkan – CppCon 2022
Take Advantage of All the MIPS – SYCL & C++ – Wong, Delaney, Keryell, Liber, Chlanda – CppCon 2022
Using std::chrono Calendar Dates for Finance in Cpp – Daniel Hanson – CppCon 2022
Bringing a Mobile C++ Codebase to the Web – Li Feng – CppCon 2022
How C++23 Changes the Way We Write Code – Timur Doumler – CppCon 2022
A Tour of C++ Recognised User Type Categories – Nina Ranns – CppCon 2022
Structured Networking in C++ – Dietmar Kühl – CppCon 2022
Binary Object Serialization with Data Structure Traversal & Reconstruction in Cpp – Chris Ryan
Parallelism Safety-Critical Guidelines for C++ – Michael Wong, Andreas Weis, Ilya Burylov – CppCon22
C++ Algorithmic Complexity, Data Locality, Parallelism, Compiler Optimizations, & Some Concurrency
Breaking Dependencies – The Visitor Design Pattern in Cpp – Klaus Iglberger – CppCon 2022
Quantifying Dinosaur Pee – Expressing Probabilities as Floating-Point Values in C++ – John Lakos
Rules for Radical Cpp Engineers – Improve Your C++ Code, Team, & Organization – David Sankel
Val: A Safe Language to Interoperate with C++ – Dimitri Racordon – CppCon 2022
Implementing Understandable World Class Hash Tables in C++ – Eduardo Madrid & Scott Bruce – CppCon 2022
Cute C++ Tricks, Part 2.5 of N – Code You Should Learn From & Never Write – Daisy Hollman – CppCon22
New in Visual Studio 2022 – Conformance, Performance, Important Features – Marian Luparu & Sy Brand
Back to Basics: Declarations in C++ – Ben Saks – CppCon 2022
![C++20’s [[likely]] Attribute - Optimizations, Pessimizations, and [[unlikely]] Consequences - CppCon](https://cppcon.programmingarchive.com/wp-content/uploads/2023/09/rjpk3hkcouamaxresdefault-768x432.jpg)
C++20’s [[likely]] Attribute – Optimizations, Pessimizations, and [[unlikely]] Consequences – CppCon
Linux Debuginfo Formats – DWARF, ELF, dwo, dwp – What are They All? – Greg Law – CppCon 2022
C++ Class Template Argument Deduction – History, Uses, & Enabling it for Classes – Marshall Clow
Using C++14 in an Embedded “SuperLoop” Firmware – Erik Rainey – CppCon 2022
GitHub Features Every C++ Developer Should Know – Michael Price – CppCon 2022
Nobody Can Program Correctly – Lessons From 20 Years of Debugging C++ Code – Sebastian Theophil
Reflection in C++ – Past, Present, and Hopeful Future – Andrei Alexandrescu – CppCon 2022
Back to Basics – Name Lookup and Overload Resolution in C++ – Mateusz Pusz – CppCon 2022
Cross-Building Strategies in the Age of C++ Package Managers – Luis Caro Campos – CppCon 2022
Smarter Cpp Atomic Smart Pointers – Efficient Concurrent Memory Management – Daniel Anderson CppCon
The Observer Design Pattern in Cpp – Mike Shah – CppCon 2022
How to Use C++ Dependency Injection to Write Maintainable Software – Francesco Zoffoli CppCon 2022
The Surprising Complexity of Formatting Ranges in Cpp – Barry Revzin – CppCon 2022
Reproducible Developer Environments in C++ – Michael Price – CppCon 2022
Simulating Low-Level Hardware Devices in Cpp – Ben Saks – CppCon 2022
Back to Basics: The C++ Core Guidelines – Rainer Grimm – CppCon 2022
Pragmatic Simplicity – Actionable Guidelines To Tame Cpp Complexity – Vittorio Romeo – CppCon 2022
Architecting Multithreaded Robotics Applications in C++ – Arian Ajdari – CppCon 2022
tipi.build A New C++ Package Manager – Damien Buhl – CppCon 2022
Personal Log – Where No Init Has Gone Before in C++ – Andrei Zissu – CppCon 2022
Using Modern C++ to Revive an Old Design – Jody Hagins – CppCon 2022
Overcoming C++ Embedded Development Tooling Challenges – Marc Goodner – CppCon 2022
New in Visual Studio Code! Clang-Tidy, makefile, CMake, GitHub, & More Marian Luparu, Sinem Akinci
Fast C++ by using SIMD Types with Generic Lambdas and Filters – Andrew Drakeford – CppCon 2022
Observability Tools C++: Beyond GDB and printf – Tools to Understand the Behavior of Your Program
Reviewing Beginners’ C++ Code – Patrice Roy – CppCon 2022
“It’s A Bug Hunt” – Armor Plate Your Unit Tests in Cpp – Dave Steffen – CppCon 2022
Back to Basics: Object-Oriented Programming in C++ – Amir Kirsh – CppCon 2022
Generating Parsers in C++ with Maphoon (& Tokenizers) – Part 2 of 2 – Hans de Nivelle – CppCon 2022
Generating Parsers in C++ with Maphoon – Part 1 of 2 – Hans de Nivelle – CppCon 2022
C++ Coroutines, from Scratch – Phil Nash – CppCon 2022
Sockets – Applying the Unix Readiness Model When Composing Concurrent Operations in C++ CppCon 2022
Compilation Speedup Using C++ Modules: A Case Study – Chuanqi Xu – CppCon 2022
![The Imperatives Must Go! [Functional Programming in Modern C++] - Victor Ciura - CppCon 2022](https://cppcon.programmingarchive.com/wp-content/uploads/2023/10/m5huoz4sgjemaxresdefault-768x432.jpg)
The Imperatives Must Go! [Functional Programming in Modern C++] – Victor Ciura – CppCon 2022
What’s New in C++23 – Sy Brand – CppCon 2022
C++20’s Coroutines for Beginners – Andreas Fertig – CppCon 2022
Principia Mathematica – The Foundations of Arithmetic in C++ – Lisa Lippincott – CppCon 2022
C++ in Constrained Environments – Bjarne Stroustrup – CppCon 2022
A Crash Course in Calendars, Dates, Time, and Time Zones – Marc Gregoire – CppCon 2021
Implementing C++ Modules: Lessons Learned, Lessons Abandoned – Cameron DaCamara & Gabriel Dos Reis
Warning: std::find() is Broken! – Sean Parent – CppCon 2021
Dynamically Loaded Libraries Outside the Standard – Zhihao Yuan – CppCon 2021
Back to Basics: Algorithmic Complexity – Amir Kirsh & Adam Segoli Schubert – CppCon 2021
C++23 Standard Library Preview – Jeff Garland – CppCon 2021
Combining Co-Routines and Functions into a Job System – Helmut Hlavacs – CppCon 2021
Building an Extensible Type Serialization System Using Partial Template Specialization – CppCon 2021
Data Orientation For The Win! – Eduardo Madrid – CppCon 2021
Why You Should Write Code That You Should Never Write – Daisy Hollman – CppCon 2021
Evolving a Nice Trick – Patrice Roy – CppCon 2021
The Unit Tests Strike Back: Testing the Hard Parts – Dave Steffen – CppCon 2021
Units Libraries and Autonomous Vehicles: Lessons from the Trenches – Chip Hogg – CppCon 2021
How Can Package Managers Handle ABI (In)compatibility in C++? – Todd Gamblin – CppCon 2021
Zen and the Art of Code Lifecycle Maintenance – Phil Nash – CppCon 2021
Finding Bugs Using Path-Sensitive Static Analysis – Gabor Horvath – CppCon 2021
Up to Code – David Sankel – CppCon 2021
Using Clang LibASTMatchers for Compliance in Codebases – Jonah Jolley – CppCon 2021
Back to Basics: Smart Pointers and RAII – Inbal Levi – CppCon 2021
Embracing `noexcept` Operators and Specifiers Safely – John Lakos – CppCon 2021
Code Size Compiler Optimizations and Techniques for Embedded Systems – Aditya Kumar – CppCon 2021
Debugging Assembly Language and GPU Kernels in Visual Studio Code – Julia Reid – CppCon 2021
Custom Views for the Rest of Us – Jacob Rice – CppCon 2021
C++20’s ＜chrono＞ Calendars and Time Zones in MSVC – Miya Natsuhara – CppCon 2021
“unit”_test: Implementing a Macro-free Unit Testing Framework from Scratch in C++20 – Kris Jusiak
Back To Basics: Debugging Techniques – Bob Steagall – CppCon 2021
Embracing (and also Destroying) Variant Types Safely – Andrei Alexandrescu – CppCon 2021
What Classes We Design and How – Peter Sommerlad – CppCon 2021
Cool New Stuff in Gdb 9 and Gdb 10 – Greg Law – CppCon 2021
Software Engineering Is About Tradeoffs – Mateusz Pusz – CppCon 2021
Multi Threading Model in Paradox Games: Past, Present and Future – Mathieu Ropert – CppCon 2021
Breaking Dependencies: Type Erasure – A Design Analysis – Klaus Iglberger – CppCon 2021
A Case-study in Rewriting a Legacy GUI Library for Real-time Audio Software in Modern C++
Hazard Pointer Synchronous Reclamation Beyond Concurrency TS2 – Maged Michael – CppCon 2021
Deducing this Patterns – Ben Deane – CppCon 2021
Back to Basics: Casting – Brian Ruth – CppCon 2021
C++20 ❤ SQL – John Bandela – CppCon 2021
Generic Graph Libraries in C++20 – Andrew Lumsdaine & Phil Ratzloff – CppCon 2021
Back to Basics: Classic STL – Bob Steagall – CppCon 2021
The Factory Pattern – Mike Shah – CppCon 2021
Design Idioms from an Alternate Universe – Ivan Čukić – CppCon 2021
The Basics of Profiling – Mathieu Ropert – CppCon 2021
Sums, Products, Exponents, Monoids, Functors, Oh My! – Steve Downey – CppCon 2021
Testing Compile-time Constructs in a Runtime Unit Testing Framework – Igor Bogoslavskyi – CppCon 21
++namedtuple – Python-style Named Tuples in C++20 – Kris Jusiak – CppCon 2021
Interactive C++ for Data Science – Vassil Vassilev – CppCon 2021
Back To Basics: The Special Member Functions – Klaus Iglberger – CppCon 2021
PGAS in C++: A Portable Abstraction for Distributed Data Structures – Benjamin Brock – CppCon 2021
Deploying the Networking TS – Robert Leahy – CppCon 2021
Making the Most Out of Your Compiler – Danila Kutenin – CppCon 2021
Static Analysis and Program Safety in C++: Making it Real – Sunny Chatterjee – CppCon 2021
Composable C++: Principles and Patterns – Ben Deane – CppCon 2021
Bringing Existing Code to CUDA Using constexpr and std::pmr – Bowie Owens – CppCon 2021
The Preprocessor: Everything You Need to Know and More! – Brian Ruth – CppCon 2021
C++ to the RISCue! A Practical Guide for Embedded C++20 – Kris Jusiak – CppCon 2021
Back to Basics: Templates (part 2 of 2) – Bob Steagall – CppCon 2021
Back to Basics: Templates (part 1 of 2) – Bob Steagall – CppCon 2021
Faster, Easier, Simpler Vectors – David Stone – CppCon 2021
Embracing User Defined Literals Safely for Types that Behave as though Built-in – Pablo Halpern
Beyond struct: Meta-programming a struct Replacement in C++20 – John Bandela – CppCon 2021
Design Patterns: Facts and Misconceptions – Klaus Iglberger – CppCon 2021
C++ Standards Committee – Fireside Chat Panel – CppCon 2021
Back to Basics: Concurrency – Mike Shah – CppCon 2021
Implementing static_vector: How Hard Could it Be? – David Stone – CppCon 2021
Practical Advice for Maintaining and Migrating Working Code – Brian Ruth – CppCon 2021
Compile-Time Compression and Resource Generation with C++20 – Ashley Roll – CppCon 2021
Back to Basics: Pointers – Mike Shah – CppCon 2021
Configuration, Extension, Maintainability – Titus Winters – CppCon
Failing Successfully: Reporting and Handling Errors – Robert Leahy – CppCon 2021
Back to Basics: Designing Classes (part 2 of 2) – Klaus Iglberger – CppCon 2021
Back to Basics: Designing Classes (part 1 of 2) – Klaus Iglberger – CppCon 2021
C++11/14 at Scale: What Have We Learned? – Vittorio Romeo – CppCon 2021
Automatically Process Your Operations in Bulk With Coroutines – Francesco Zoffoli – CppCon 2021
Just Enough Assembly for Compiler Explorer – Anders Schau Knatten – CppCon 2021
Discovering a User-Facing Concept – Christopher Di Bella – CppCon 2021
Evolving an Actor Library Based on Lessons Learned from Large-Scale Deployments – Benjamin Hindman
Understanding and Mastering C++’s Complexity – Amir Kirsh – CppCon 2021
Law of Demeter: A Practical Guide to Loose Coupling – Kris Jusiak – CppCon 2021
Your New Mental Model of constexpr – Jason Turner – CppCon 2021
Plenary: Small Inspiration – Michael Caisse – CppCon 2021
C++20 Templates: The next level: Concepts and more – Andreas Fertig – CppCon 2021
GPU Accelerated Computing on Cross-Vendor Graphics Cards with Vulkan Kompute – Alejandro Saucedo
Making Libraries Consumable for Non-C++ Developers – Aaron R Robinson – CppCon 2021
Template Metaprogramming: Practical Application – Jody Hagins – CppCon 2021
Value-oriented Design in an Object-oriented System – Juan Pedro Bolivar Puente – CppCon 2021
Down the Rabbit Hole: An Exploration of Stack Overflow Questions – Marshall Clow – CppCon 2021
Real-time Programming with the C++ Standard Library – Timur Doumler – CppCon 2021
The Roles of Symmetry And Orthogonality In Design – Charley Bay – CppCon 2021
C++20 on Xilinx FPGA with SYCL for Vitis – Ronan Keryell – CppCon 2021
Asserting Your Way to Faster Programs – Parsa Amini – CppCon 2021
Why does std::format do that? – Charlie Barto – CppCon 2021
Using Coroutines to Implement C++ Exceptions for Freestanding Environments – Eyal Zedaka – CppCon 21
Branchless Programming in C++ – Fedor Pikus – CppCon 2021
Our Adventures With REST API in C++ : Making it Easy – Damien Buhl – CppCon 2021
Conquering C++20 Ranges – Tristan Brindle – CppCon 2021
C++ Standard Parallelism – Bryce Adelstein Lelbach – CppCon 2021
Back to Basics: Compiling and Linking – Ben Saks – CppCon 2021
Handling a Family of Hardware Devices with a Single Implementation – Ben Saks – CppCon 2021
A Hash Map for Graph Processing Workloads & a Methodology for Transactional Data Structures – CppCon
Embracing PODs Safely Until They Die – Alisdair Meredith & Nina Ranns – CppCon 2021
A (Short) Tour of C++ Modules – Daniela Engert – CppCon 2021
C++20: The Small Pearls – Rainer Grimm – CppCon 2021
What’s New in Visual Studio: 64-bit IDE, C++20, WSL 2, & More – Marian Luparu & Sy Brand – CppCon 21
Design and Implementation of Highly Scalable Quantifiable Data Structures in C++ – CppCon 2021
Building a Lock-free Multi-producer, Multi-consumer Queue for Tcmalloc – Matt Kulukundis – CppCon 21
Modern CMake Modules – Bret Brown – CppCon 2021
Back to Basics: Lambdas – Nicolai Josuttis – CppCon 2021
Back to Basics: Object-Oriented Programming – Rainer Grimm – CppCon 2021
From Problem to Coroutine: Reducing I/O Latency – Cheinan Marks – CppCon 2021
cudaFlow: Modern C++ Programming Model for GPU Task Graph Parallelism – CppCon 2021
Back To Basics: Undefined Behavior – Ansel Sermersheim & Barbara Geller – CppCon 2021
Typescripten: Generating Type-safe JavaScript Bindings for emscripten – Sebastian Theophil
SIMD in C++20: EVE of a new Era – Joel Falcou & Denis Yaroshevskiy – CppCon 2021
The Foundation of C++ Atomics: The Knowledge You Need to Correctly Use C++ Atomics – Filipe Mulonde
3D Graphics for Dummies – Chris Ryan – CppCon 2021
Value in a Procedural World – Lisa Lippincott – CppCon 2021
Using C Libraries in your Modern C++ Embedded Project – Michael Caisse – CppCon 2021
In-memory and Persistent Representations of C++ – Gabriel Dos Reis – CppCon 2021
The Upcoming Concurrency TS Version 2 for Low-Latency and Lockless Synchronization – CppCon 2021
Software Architecture Lessons from Multidimensional Spaces Explorations – CppCon 2021
Spooky Action at a Distance – Victor Ciura – CppCon 2021
Documentation in the Era of Concepts and Ranges – Christopher Di Bella & Sy Brand – CppCon 2021
Misra Parallelism Safety-critical Guidelines for C++11, 17, Then C++20, 23 – CppCon 2021
Back to Basics: const and constexpr – Rainer Grimm – CppCon 2021
Visualize Time Enabled Data using ArcGIS Qt (C++) and Toolkit – Gela Malek Pour – CppCon 2021
Extending and Simplifying C++: Thoughts on Pattern Matching using `is` and `as` – Herb Sutter
Back To Basics: Overload Resolution – CppCon 2021
Code Analysis++ – Anastasia Kazakova – CppCon 2021
Differentiable Programming in C++ – Vassil Vassilev & William Moses – CppCon 2021
Back to Basics: Move Semantics – Nicolai Josuttis – CppCon 2021
Lessons Learned from Packaging 10,000+ C++ Projects – Bret Brown & Daniel Ruoso – CppCon 2021
GraphBLAS: Building a C++ Matrix API for Graph Algorithms – Benjamin Brock & Scott McMillan
“Constexpr Everything” – The Standard Library, Microkernel, Apps, and Unit Tests – Rian Quinn
Type-and-resource Safety in Modern C++ – Bjarne Stroustrup – CppCon 2021
Exceptional C++ – Victor Ciura – CppCon 2021
Concurrency Patterns – Rainer Grimm – CppCon 2021
Heterogeneous Modern C++ with SYCL 2020 – Michael Wong, Nevin Liber, Tom Deakin & Gordon Brown
C++20: Reaching for the Aims of C++ – Bjarne Stroustrup – CppCon 2021
Plenary: Six Impossible Things – Kevlin Henney – CppCon 2021
Working with Asynchrony Generically: A Tour of C++ Executors (part 2/2) – Eric Niebler – CppCon 21
Working with Asynchrony Generically: A Tour of C++ Executors (part 1/2) – Eric Niebler – CppCon 21
1 / 12
Filter
Your selections:
Lightning Talk: Algebraic Path Problems Done Quick: Or how to find the best* path from one talk to another – Stefan Ivanov – CppCon 2025
Lightning Talk: Navigating Code Reviews as a Code Author – Ben Deane – CppCon 2025
Lightning Talk: But I was doing the right thing! – Andrei Zissu – CppCon 2025
Lightning Talk: Trust Nothing, Complain About Something, Want Everything – Jonathan Stein – CppCon 2025
Lightning Talk: The BS Principle – John Pavan – CppCon 2025
Lightning Talk: Execution Policies: Not a Forward Progress Guarantee – Ruslan Arutyunyan – CppCon 2025
Lightning Talk: Can `set_value` Actually Throw? – Robert Leahy – CppCon 2025
Lightning Talk: Crafting CUDA Compatible C++ Code – Jon White – CppCon 2025
Lightning Talk: A C++20 Modules Performance Field Report – Tyler Drake – CppCon 2025
Lightning Talk: Lambdas, Ranges and trivially_copyable: Why This Matters for Parallel Algorithms – Ruslan Arutyunyan – CppCon 2025
Lightning Talk: Understanding Data Dependency Chains – Makar Kuznietsov – CppCon 2025
Lightning Talk: How Fast Isn’t You Constexpr? – Hossein GhahramanzadehAnigh – CppCon 2025
Lightning Talk: Bool – Implicitly Dangerous – Jeff Garland – CppCon 2025
Lightning Talk: Proof Searching in DepC – Raffaele Rossi – CppCon 2025
Lightning Talk: The Classic Missed-Signal! – Gopal Rander – CppCon 2025
Lightning Talk: Poor Man’s Autocomplete for Template Arguments – Max Sagebaum – CppCon 2025
Lightning Talk: Reducing Binary Bloat With Thin Archives – Florent Castelli – CppCon 2025
Lightning Talk: std::move & Spirited Away: When Nameless Objects Walk the Spirited World – Siyu (Alice) Peng – CppCon 2025
Lightning Talk: Promote Modern C++ Usage With Coding Questions Part 2 – Zhenchao Lin – CppCon 2025
Lightning Talk: Learning C++ Through Writing Coding Questions – Christopher DeGuzman – CppCon 2025
Lightning Talk: Back When ChatGpt Was Young And Stupid – Andrei Zissu – CppCon 2025
Lightning Talk: The Type Safe Builder Pattern for C++ – John Stracke – CppCon 2025
Lightning Talk: Catching Performance Issues at Compile Time – Keith Stockdale – CppCon 2025
Lightning Talks: Optimizing Memcpy Reads From DMA Memory – Arjun Mariyala – CppCon 2025
Lightning Talk: Cut the boilerplate with C++23 deducing_this – Sarthak Sehgal – CppCon 2025
Lightning Talk: Causal Inference for Code Writing AI – Matt K Robinson – CppCon 2025
Lightning Talk: A Pragmatic Approach to C++: Designing, Organizing and Writing Maintainable Code – Oleg Rabaev – CppCon 2025
Lightning Talk: The Lifecycle of This CMake Lightning Talk – Yannic Staudt – CppCon 2025
Lightning Talk: We Are Family – Jody Hagins – CppCon 2025
Lightning Talk: A Pack as an Optional Parameter – Braden Ganetsky – CppCon 2025
Lightning Talk: Eight Consteval Queens and Compile-Time Printing – Sagnik Bhattacharya – CppCon 2025
Lightning Talk: Better Expressiveness with Parallel Range Algorithms – Ruslan Arutyunyan – CppCon 2025
Lightning Talk: Only Forward: Why Concurrency Works in C++ – Thomas Cassell – CppCon 2025
Lightning Talk: CppDefCon3 – WarGames – Kevin Carpenter – CppCon 2024
Lightning Talk: Amortized O(1) Complexity in C++ – Andreas Weis – CppCon 2024
Lightning Talk: From Macro to Micro in C++ – Conor Spilsbury – CppCon 2024
Lightning Talk: Rust Programming in 5 Minutes – Tyler Weaver – CppCon 2024
Lightning Talk: Just the Cliff Notes: A C++ Mentorship Adventure – Alexandria Hernandez Mann – CppCon 2024
Lightning Talk: When Computers Can’t Math – Floating Point Rounding Error Explained – Elizabeth Harasymiw – CppCon 2024
Lightning Talk: Brainplus Expression Template Parser Combinator C++ Library: A User Experience – Braden Ganetsky – CppCon 2024
Lightning Talk: Coding Like Your Life Depends on It: Strategies for Developing Safety-Critical Software in C++ – Emily Durie-Johnson – CppCon 2024
Lightning Talk: Using PMR in C++ Embedded Systems for Functional Safety – Scott Dixon – CppCon 2024
Lightning Talk: Chplx – Bridging Chapel and C++ for Enhanced Asynchronous Many-Task Programming – Shreyas Atre – CppCon 2024
Lightning Talk: How Far Should You Indent Your Code? The Number Of The Counting – Dave Steffen – CppCon 2024
Lightning Talk: Customizing Compilation Error Messages Using C++ Concepts – Patrick Roberts – CppCon 2024
Lightning Talk: Saturday Is Coming Faster – Convert year_month_day to Weekday Faster – Part 2 – Cassio Neri – CppCon 2024
Lightning Talk: Saturday Is Coming Faster – Convert year_month_day to Weekday Faster – Part 1 – Cassio Neri – CppCon 2024
Lightning Talk: Can’t we Just Synthesize std::tuple_element From Get? – Jonathan Müller – CppCon 2024
Lightning Talk: Improving an HTML Parser with Swift 6 Pattern Matching – Andrew Kaster – CppCon 2024
Lightning Talk: The UB Detector: constexpr – Andreas Fertig – CppCon 2024
Lightning Talk: The Main Points in C++ – Dots in C++ – Miodrag Misha Djukic – CppCon 2024
Lightning Talk: DevSecOps for C++? Keep Calm and use Conan – Luis Caro Campos – CppCon 2024
Lightning Talk: Micro C++ Benchmarks & Murphy’s Law – Lexington Brill – CppCon 2024
Lightning Talk: The Present and Future of Cross-Platform GUI in C++ – Matt Aber – CppCon 2024
Lightning Talk: What LLMs Won’t Ever be Able to Do – Ben Deane – CppCon 2024
Lightning Talk: Remote Execution Caching Compiler (RECC) for C++ Builds – Shivam Bairoliya – CppCon 2024
Lightning Talk: C++ in the Cloud: One NIF at a Time with Elixir – Sakshi Verma – CppCon 2024
Lightning Talk: What Does a CMake Developer Want From CMake? – Ben Boeckel – CppCon 2024
Lightning Talk: Generative C++ – Alon Wolf – CppCon 2024
Lightning Talk: C++ and Rust Bindings – Mixing It Best With CMake – Damien Buhl – CppCon 2024
Lightning Talk: Do You Love or Hate Your C++ Build System? – Helen Altshuler – CppCon 2024
Lightning Talk: Every Use Case of Colon and Ellipses in C++ – Ali Almutawa Jr. – CppCon 2024
Lightning Talk: Constraining Automated Trading Risk with Linux Signals – Max Huddleston CppCon 2023
Lightning Talk: Forbidden C++ – Ali Almutawa – CppCon 2023
Lightning Talk: Making Friends With CUDA Programmers (please constexpr all the things) Vasu Agrawal
Lightning Talk: Detecting Constant Folding to Prevent Substitution Failure – Patrick Roberts – CppCon 2023
Lightning Talk: Undefined Behavior – Toolkit to Improve Communication With Clients – Laura Kostur
Lightning Talk: Program Complexity and Thermodynamics – Vadim Alexandrov – CppCon 2023
Lightning Talk: Is Polymorphism in C++ Really That Bad? – Paul Tsouchlos – CppCon 2023
Lightning Talk: Enhancing C++ exceptions with Context – Shachar Shemesh – CppCon 2023
Lightning Talk: Writing a Better std::move – Jonathan Müller – CppCon 2023
Lightning Talk: Know Your Audience: Who’s Building Your C++ Code – Chris Thrasher – CppCon 2023
Lightning Talk: (Fine) Wine and MSVC: What Could Possibly Go Wrong? – Yannic Staudt – CppCon 2023
Lightning Talk: Let’s Fix Sparse Linear Algebra with C++. It’ll Be Fun and Easy! – Benjamin Brock
Lightning Talk: Higher-Order Template Metaprogramming with C++23 – Ed Catmur – CppCon 2023
Lightning Talk: The Responsibility of C++ – Neil Henderson – CppCon 2023
Lightning Talk: Whitespace: A Humorous Short Talk – Dan Curran – CppCon 2023
Lightning Talk: Thread Safety With synchronized_value in C++ – Jørgen Fogh – CppCon 2023
Lightning Talk: You Should Use AddressSanitizer – Brody Holden – CppCon 2023
Lightning Talk: Filling the Bucket: Reading Code, C++ Code Interviews & Exams – Amir Kirsh – CppCon
Lightning Talk: C++ and the Next Generation: How to Support Women and Families in Tech – Sara Boulé
Lightning Talk: Spanny: Abusing C++ mdspan Is Within Arm’s Reach – Griswald Brooks – CppCon 2023
Lightning Talk: Help! My Expression Template Type Names Are Too Long! – Braden Ganetsky CppCon 2023
Lightning Talk: Interfaces in C++ – Megh Parikh – CppCon 2023
Lightning Talk: Un-Undefining Undefined Behavior in C++ – Jefferson Carpenter – CppCon 2023
Lightning Talk: A Fast, Concurrent Data Loader for Time-Series Data – Glenn Philen – CppCon 2023
Lightning Talk: ClangFormat Is Not It – Anastasia Kazakova – CppCon 2023
Lightning Talk: The Power of Silence and Music in Agile Software – Valentina Ricupero – CppCon 2023
Lightning Talk: Implementing Coroutines Using C++17 – Alon Wolf – CppCon 2023
Lightning Talk: Introverts: Speak! – Rudyard Merriam – CppCon 2023
Lightning Talk: Let’s Write a Lambda in C++ – Ben Deane – CppCon 2023