CppCon GameDev Track

GameDev Representation at CppCon

This is only the second year of the GameDev track at CppCon, which is quite miraculous considering how many talks at CppCon (and other conferences) at least mention games. Even one of the keynotes this year was on the topic of games!

The track is chaired by Guy Davidson who was a fantastic cheerleader of all the talks. From what I saw, he went to all of the GameDev talks, even mine which I was shocked about since he had already seen it at ACCU. It felt great having a legend like him cheering on all the game dev talks!

This year there were only 6 game dev talks in the track. Of which, 4 of them were given by people in academia. In fact, I think I am correct in saying the following:

I was the only one giving a talk from a game studio about a game

To me this is a little crazy considering the entire game industry is built on C++. We have so many stories from Rare alone in the realm of “hard to solve problems in C++”. There is so much scope at C++ conferences for us as an industry to talk about our experiences and insert some influence on the language progression. We, as an industry, make up some of the largest C++ code bases in the world. Unreal Engine must be one of the largest publicly available C++ code bases, for example. I feel like we should be represented a little more than what I saw at this year’s CppCon. This lack of representation hasn’t always been the case.

If I go to the CppCon YouTube Channel and sort by popular, the most watched talk by a huge margin is “Data-Oriented Design and C++” from Mike Acton, of Insomniac fame. The tenth most popular talk is Jason Turner’s famous talk “Rich Code for Tiny Computers”. And, the eleventh most popular is Stoyan Nikolov’s talk “OOP Is Dead, Long Live Data-oriented Design”.

So clearly there is an appetite for more game dev related C++ talks at conferences. Think of this as a call to action! There is a market for game dev related talks at C++ conferences. We in the industry should capitalize on this more!

GameDev Talks

I went to all but 1 of the game dev talks. I unfortunately missed the one that I was probably the most excited for which was “From C+ to C++: Modernizing a GameBoy Emulator” which (I think) is a sequel to Blazing Trails: Building the World’s Fastest GameBoy Emulator in Modern C++. If you haven’t watched Tom’s talk from last year, please do, it is fantastic. Plus, I am pretty sure that most programmers love the topic of emulators.

From Theory to Practice: A Student Journey Building a C++ Game Engine in Open-Source:

This was a talk from student, Chu Yi Herr. The first thing I want to say about this talk is that it was awesome to see a student get up on stage at a major conference and talk so confidently about a project that they had worked on. This was great to see. There was quite a lot of good information in this talk around project and package management. There was definitely a lot of emphasis around using open-source libraries rather than reinventing the wheel. Spend your time on the code that you actually care about, and use other libraries for the stuff that you don’t care too much about.

One of the more interesting topics of this talk was on a lesser used type of smart pointer, which the speaker called “Strong Pointers”, and their cousin, “Optional Pointers”.

Strong pointers struck me as the same concept as TSharedRef<T> in Unreal Engine. In that the idea for them is that they can’t be nullptr. The other motivation for these pointers was to make use of std::pmr::polymorphic_allocator and to have better memory layouts than what std::shared_ptr provides. Particular attention is paid to how shared pointers layout their vtables in libstdc++.

I don’t know how strong_ptr was implemented in the engine that was being talked about, BUT, I believe the canonical way of making use of std::shared_ptr and std::pmr::polymorphic_allocator is std::allocate_shared. But of course that would not solve the criticisms with the vtable layout.

As someone who goes through a couple hundred CVs and portfolios a year (on average) for Rare’s intern program, there are quite a few patterns that I notice in a lot of students’ work. And, I couldn’t help but notice that a good amount of the architecture of the engine being talked about took a good amount of inspiration from TheCherno’s Hazel Engine. Things like the layer system and the event system were very familiar to me when they popped up on the slides! I point this out as yet another example of where the speaker built on top of other people’s work rather than reinventing the wheel.

Good stuff!

From pure ISO C++20 to Compute Shaders

This was a pretty awesome talk to be honest. It was given by Koen Samyn who is a teacher/lecturer/professor at DAE which is a game dev school in Belgium.

The gist of this talk is that Koen, in an effort to make teaching shaders easier hacked away at clang to allow students to write C++ code which would be transpiled to GLSL at compile time. The idea behind this was that this would allow students to test their shader code in C++ and step through if they needed to debug, while also allowing students to write tests for their shaders.

This was all music to my ears because I too have delved into trying to solve this problem myself. Shader Test Framework is a framework (which I am writing) which allows you to test your shader code as part of a C++ testing framework like GTest or Catch2. It also has facilities to make it easier to debug shader code.

Where my project and Koen’s differs, is that ShaderTestFramework does all the testing and debugging in the shading language, rather than in C++.

Comparisons aside, it was really cool to see what you can do with code when you have tools like clang. Makes me wish we had this power with MSVC…

Koen very kindly made his library available on github here for anyone who is interested in hacking at compilers. The slides for this talk are also in the docs section of this repo for those interested.

One thing, that I wonder is… With C++26 reflection, would it be possible to do all of this work without having to mess around with clang? Probably not since I think that might require statement level reflection which is not in C++26. But who knows, you might get further with C++26 reflection and require less hacking of Clang to get the same results. Perhaps that will be Koen’s talk for next year!

It’s Dangerous to Go Alone: A Game Developer Tutorial

This was a really fun and well produced talk from Michael Price on the Visual Studio team. In this talk, Michael takes us through the process of using Unreal Engine to bring his old Go clone from being a console output-based game, to a 2D graphics-based game. He talks about:

1. Source control
2. Setting up and installing Unreal Engine
3. What Blueprints are
4. What Materials are

Honestly, as someone who works in Unreal Engine daily, and has done for the best part of 10 years now, this was a really good explanation on the best way to start up an Unreal Engine project. The standout parts of this talk for me were:

1. Demonstrating how to consume any third-party library that you find on github in Unreal Engine
2. How to enable Dynamic Deopt for Unreal Engine games
3. How the Blueprint Debugger works in Visual Studio

I really enjoyed this talk for its simplicity. It was really well constructed and I even learned a thing or two.

There is a danger when giving a talk like this though. Michael used a simple Go clone as the subject of this Unreal Engine starting tutorial. Some might be quick to question the use of Unreal Engine for this task. Some might have the opinion that using something like SFML or SDL or Raylib would be more appropriate for this type of task. This is certainly true. But that doesn’t matter because it misses the point of the talk. The point of the talk was simply to give an intro into how to use Visual Studio and Unreal Engine to start a game project, and get something working. The game itself wasn’t the focal point of the talk. The focal point was the processes and tech involved in setting up a game project. The game could have been anything.

You can find the code that was used for this talk at these links:

1. Go-Cpp
2. Go-Unreal

Graphics Programming with SDL 3

This was a great intro talk to SDL from Mike Shah for people that have not used SDL before (like me!).

He went through some of the history of SDL. I don’t think I knew that the main dev of SDL worked at Valve. That was a pretty cool titbit of history! Then Mike goes through some the major features of SDL 3, and how to use the library. The majority of the rest of this talk was talking about how to render basic graphics with SDL. Then moving on to talking about how SDL 3 supports modern graphics APIs like Vulkan and DirectX 12 with the new GPU API. This gives you more control over the GPU when compared with the old SDL_Renderer API, however it did feel like it takes away the simplicity of SDL… Though that is the joy of the modern Graphics APIs I guess! You are the driver implementor!

One thing that did not go without notice was this slide

I love seeing slides with Rare characters in them at talks. A pretty good example of this is this timestamp of Matt Godbolt’s closing keynote at ACCU 2025.