CppNorth, The Canadian C++ Conference 2025

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.

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.

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.

This talk explores five widely taught C++ coding guidelines and the subtle but profound way that the special member functions interact with class invariants, all with the ultimate goal of learning how to write better code.

A pipeline is a chain of processing elements such as functions, threads etc., arranged so that the output of each element is the input of the next. We often encounter this pattern in practice. C++ also allows us to write in this way, e.g. using the `std::ranges` library with its characteristic overloaded pipe `operator |`. But modern C++ enables much more and this will be discussed in this talk. First, we'll show how to implement a custom pipeline framework that employs `std::expected`, available since C++23. Secondly, we will show pipelines in the serial version, where the functions communicate the results of their calculations, as well as in the parallel version, in which at least one thread operates on each link. In the last case we will need synchronized queues – and here we will also show how `std::expected` can be used again to create a flexible interface. Everyone is welcome!

Dynamic memory allocations are ever-present in most programs. A simple look at the RAM usage of the browser you are currently using to read this abstract will likely tell you something.
But what of the runtime performance cost? How much (or little) should you be concerned about it and keep it in mind while implementing new features or designing software?

In this talk, we will present a set of about 10 guidelines to keep in mind when dealing with dynamic memory allocation and mitigate its potential performance impact on execution speed. From quite simple to somewhat advanced, everyone should be able to walk away from this talk having learnt something.

C++ is a powerful language, but with great power comes… plenty of pitfalls. Memory management quirks (even when using smart pointers), subtle undefined behaviors, and bug-prone code can silently introduce dangerous behaviors—only to surface at the worst possible moment in production. While static code analysis can catch some of these issues, it requires proper usage and adherence to warnings, and even then, it won’t catch everything. Many of these traps can lead to hard-to-debug issues, safety problems, and security vulnerabilities.
In this talk, we’ll explore some of the most notorious C++ pitfalls and sharp edges, discussing strategies to avoid them and write safer, more resilient code. We’ll walk through both design best practices and C++ coding guidelines to help you navigate the language’s trickier corners with confidence.

The C++ programming language does not have a standard graphics library, However, there exists many popular graphics frameworks for cross-platform graphics. In this talk, I will provide an introduction to the Simple Directmedia Layer (SDL) library, which has at the start of 2025 released version 3. This library for several decades has been a standard in the games and graphics industry. Throughout this talk, I will show how to get started with the library, some more advanced examples (including compiling graphics applications to web), and then talk about what a standard graphics library could look like in C++, or if it is even necessary. I will also talk about the 3D GPU library in SDL3. Attendees will leave this talk ready to build multimedia / game applications and with an understanding on if SDL3 is the right tool for them.

Working with C++ code can be difficult, and it's made even more difficult when the code isn't your own. Everyone agrees that documentation is necessary when sharing a library. But, as a user of a library, the documentation may not help when you want to know the current state of your program. If you're a veteran C++ programmer then you may easily find your way around memory readouts, putting print statements in exactly the right spots, or reading "between the lines" of the documentation. Some of us are not very experienced, or we aren't able to recompile the code with print statements, or the documentation may not help with the problem. Hopefully, the author had written an extension to connect their code to your debugger of choice. But odds are, they didn't. Debuggers are advanced tools, often overlooked when discussing the day-to-day aspects of writing C++ code. Without modifying the source code or recompiling, we can glean large amounts of information about the program state through our debugger. As library writers, or as people writing classes for others to use and reuse, we can and should be writing debugger visualizers. We can empower our users by lowering the barrier to using the library successfully.

This talk will outline how to make the most out of debuggers like the Visual Studio debugger and GDB. Briefly touching on the of how to start up the debugger, this talk will cover topics like automating and scripting the debugger, and writing custom visualizations like Visual Studio Natvis and GDB pretty-printers. This talk is here for you to get started with writing debugger visualizers. Let's make our libraries more accessible. Software is about more than just the source code.

Every few years, someone will proudly declare they have an idea or technology that will replace expensive software engineers (or at least make us less expensive). These include everything from early programming languages such as Fortran and Cobol, WYSIWYG editors, diagram-based programming, modern programming languages such as TypeScript, and, most recently, AI coding tools. So far, these innovations have helped developers by abstracting away time consuming and repetitive tasks, which has made us more efficient, more specialized, and has allowed us to build increasingly complex systems. This talk will explore the history of technologies that were supposed to make us obsolete, how they’ve actually helped us, and why we’re so hard to replace.