CppNorth, The Canadian C++ Conference 2025

TBA

To accelerate machine learning research and to unlock the potential for cutting-edge in-game models, Ubisoft started using Microsoft’s open-source inference library ONNX Runtime in their proprietary engines.
This session offers insights into using this solution in game dev scenarios: performance topics, build requirements and processes, threads and memory management, library licenses, open-source contributions and the overall organization around this initiative.

Master the art of confident communication to showcase your value and unlock new career opportunities. This session offers practical tools to help you overcome self-doubt, articulate your achievements, and build influence through authentic, clear communication. Gain the confidence to navigate workplace dynamics and take charge of your professional growth.

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.
This talk will bring you the highlights of the MVP and occasionally also some forecasted features beyond it – some of which might still also make it into C++26, which should be known in time for CppNorth, with this talk duly reflecting any relevant updates. We will shift our focus away from the theoretical background behind contracts and more into some select minutiae and pitfalls encountered along the tortuous process of developing this MVP, while also inspecting the most important things future contracts users should be aware of. And you can also expect some am(a/u)sement along the way!
This talk is being designed based on the current state of the Contracts MVP, and will be brought up to speed with the outcome of the Sofia meeting in June.

The integration of C++20's new ranges library into JavaScript runtimes presents a promising avenue for enhancing performance and code clarity. We delves into how ranges can simplify the handling of collections and sequences in JavaScript engines such as Node.js and Cloudflare workerd. By leveraging lazy evaluation offered by C++20 ranges, JavaScript runtimes can achieve more efficient data processing, reducing both memory footprint and execution time. We explore the application of ranges in optimizing Node.js, showing how they can be used for tasks such as data transformation, filtering, and iteration with less boilerplate code. We examine the benefits of ranges in terms of code readability and maintainability, which are critical for the large teams working on these engines. We provide practical guidance on how developers can begin to incorporate ranges into their projects, considering both the technical and educational aspects of this transition. Our analysis concludes that while there's an adjustment period for developers, the long-term advantages in performance and ease of development make C++20 ranges an invaluable tool for modernizing JavaScript runtimes.

Type erasure is a powerful concept in C++ that allows us to work with heterogeneous types while hiding their concrete details behind a generic interface. In this talk, we will explore how the C++ Standard Library employs type erasure in constructs like std::function, std::shared_ptr, and std::any to provide flexible and efficient solutions for managing types at runtime. Further, we will unveil the hidden cost of using these constructs.
We will start by building our own version of std::function, which will help demystify how it can store and call any callable object, regardless of its type. Then, we'll look at how std::shared_ptr uses type erasure to maintain type safety via dynamic dispatch of the deleter. Finally, we will delve into std::any, some times claimed the modern void*, and explore a different technique of type erasure.

A good technical talk is as much about storytelling as it is about presenting information. At best, it is a shared experience between speaker and audience. Even the most complex topics can be presented simply and clearly, sparking questions, conversation, and perhaps even some argument. When this is done well, a good talk becomes a great one and leaves everyone, including the speakers, with more: more understanding, more curiosity, more interest.
Small tweaks to your presentations can make a huge difference. Learn how to add context and clarity to your talks; how much detail is enough; how to craft simple and effective slides; how to be truly comfortable on stage and engage your audience; and how to cope with the unexpected.

I envision much of this as a conversation with the audience where they can discuss their own ideas or works in progress if they choose; share experiences, find presentation ideas from the work they are doing day to day.

Two years ago a junior developer, doing her very first "introductory" task, asked the seemingly simple question "should I check for null here?".

This, of course, resulted in a multi page response from me, starting with:

"It depends"

and ending with:

"And that's the short version. For the long version, see my hour/day presentation on whether to check for null (which is actually not about null at all, but Contracts...)"

Aha! Two years later...

This is a talk about Error Handling - but in particular those errors you didn't expect - bugs.

And yes, this is really a talk about Contracts, in particular C++26 (and beyond) Contracts. What are they, What AREN'T they, how to use them and WHY.

Modules are the most impactful new addition to C++20 since they affect every developer. The other Big Five—concepts, ranges, coroutines, and three-way comparison—affect major segments of C++ users but not necessarily everyone.

This talk is a detailed, pragmatic discussion that uses simple to complex examples. It touches on the detailed workings of modules and build systems, particularly for GCC, Clang, and CMake. (Sorry, no MSVC since I'm on Linux.) At the end, attendees will have a comprehensive understanding of C++20 modules and be equipped to apply this knowledge to their projects.