Another year and another CppCon is all wrapped up! Microsoft was pleased to once again be an exhibitor and to have several of our employees present sessions at the conference. Here are my major takeaways from the keynotes, sessions, conversations, and the general vibe.

• AI tooling is finding a footing with the C++ community. The next year is going to see the reliability and usefulness of those tools jump drastically.
• Visual Studio users consistently name the debugger as one of the best features of the product.
• Lots of folks are getting excited about the static reflection capabilities in C++26.

The week before CppCon, we announced Visual Studio 2026 and Microsoft C++ (MSVC) Build Tools v14.50, and the conference gave us a great opportunity to let you know what you can expect in the new release and for you to give us your feedback. We highly encourage you to try out the Insiders release and let us know what your experience is like.

This is a long post, so here’s a table of contents to help you navigate if you are only interested in specific parts:

1. The Microsoft Booth
2. Keynotes
3. Microsoft Sessions
4. Other Sessions of Interest
5. Wrapping It Up

Now, let’s get into some of the details from the conference.

The Microsoft Booth

Conference attendees often describe the “hallway track” as a hidden gem of in-person attendance, and as a tool vendor, the exhibition hall serves a similar function: providing a way to broadly understand what the community and our users are looking for from our products. We really do value your feedback, and we appreciate everyone who came by to talk to us or to fill out our feedback survey. We even managed to get in a couple of deeper, private, in-person conversations with users to really dig into what they want from their tools.

Survey

The survey we conducted ended up with over 170 unique entries, and from those entries, we randomly selected raffle winners for some great LEGO® prizes. Congratulations to the winner!

Keynotes

**Concept-Based Generic Programming – **Bjarne Stroustrup

Bjarne’s keynote on generic programming with C++ concepts was focused on showing how concepts, which were added in C++20, are one tool in the toolbox for writing code that can reinforce safety and encapsulate differences between types so that code can be written in a way that it doesn’t have to repeatedly handle all the special cases.

I was particularly fond of the idea of using values as concept parameters to encode into the type system certain expectations about a type, such as maximum object size, which is important in many serialization, caching, and performance optimization scenarios. It’s a much better solution than my existing preference of using static_assert to check object size directly after the type declaration.

**Crafting The Code You Don’t Write: Sculpting Software in an AI World – **Daisy Hollman

I didn’t get a chance to see Daisy’s talk live at the conference, but I caught it on the CppCon Video Archive afterwards. Daisy gives a great talk as usual, balancing sharp technical insight and examples that make them relevant to the viewers’ everyday problems. In this case, it was about understanding LLMs and how they work so that you might understand why they give the sorts of completions that they give based on your prompt. Ultimately, they respond to our prompts and the context we provide, and each model will respond differently.

One of my favorite things from the talk was the idea that you should think of LLM-based AI assistants “like junior engineers who have read the whole internet.” This is very similar to my description from my Meeting C++ 2023 talk AI Assistants for C++ Developers “as a very eager, over-confident beginner with access to an enormous library and the skills to quickly find and collate information.” Of course, Daisy puts it much more succinctly.

**Reflection: C++’s Decade-Defining Rocket Engine – **Herb Sutter

I haven’t gotten around to watching Herb’s talk, but I’m looking forward to it soon. Let us know in the comments what you think about it if you were there or after you’ve watched it on YouTube!

**More Speed & Simplicity: Practical Data-Oriented Design in C++ – **Vittorio Romeo

Like with Herb’s talk, I haven’t gotten a chance to watch Vittorio’s keynote. I’m a pretty big fan of data-oriented design so I’m interested in what Vittorio has to say about it. Let us know what you think of his talk in the comments!

**C++: Some Assembly Required – **Matt Godbolt

Matt’s closing keynote session was wide-ranging and quite good, as usual. He walked through the different dictionary definitions of assembly and how they applied to C++ and the C++ community, often in surprisingly meaningful ways. Of course, he’s most well known for Compiler Explorer, which lets you view the generated binary code for your C++ code in a variety of assembly language syntaxes. There was content on technical topics like that, but also some rather inspiring and thoughtful content on softer topics as well. Highly recommended viewing.

Microsoft Sessions

What’s New in Visual Studio for C++ Developers in 2025 – David Li and Augustin Popa

Check back later for the session video. We’ll post it here when it’s available.

In this talk, Augustin and David go into a lot more detail of the changes that are coming in the new versions of Visual Studio and the MSVC Build Tools. Here are some of the highlights:

• GitHub Copilot Agent Mode is now available in Visual Studio. Agents can better understand intent, plan actions, and carry out tasks with less user guidance. You can provide further context to GitHub Copilot by using a custom instructions file to let it know about the preferred conventions and rules for your repo or organization, like how to add unit tests, what style you prefer for comments, and what your priorities are in terms of the quality of your code.

• One of our biggest features this year is Dynamic Debugging, which allows you to deoptimize code on the fly while debugging, making the debugger more useful for projects that are performance sensitive. You will be able to see all your local variables, step reliably, and step into force inline functions. While this feature was inspired by our game dev partners, it is useful for all C++ applications that use debug and release configurations.

• For the MSVC Build Tools, we continue our progress towards C++23 conformance with support for formatting ranges, std::generator, lambda attributes, and more. We also continued to improve the runtime performance of code built with the latest build tools.
• We fixed 387 C++ issues and implemented 29 C++ feature requests in the past year.
• There are many UI improvements in Visual Studio 2026, including 11 colorful themes to choose from, an updated Settings experience, and a dockable all-in-one search window.
• Other productivity improvements include automatic word wrap indentation, enhanced line and column navigation, a better Change Signature experience, and the ability to save files with your preferred encoding format.

**What’s New for Visual Studio Code: CMake Improvements and GitHub Copilot Agents – **Alexandra Kemper

Check back later for the session video. We’ll post it here when it’s available.

This session highlighted several important improvements and new features, covering extensions like the C/C++ extension, the CMake Tools extension, and GitHub Copilot extension.

Performance is one of the major areas of feedback received for the C/C++ extension, and the latest versions have changes that significantly speed up project startup times and reduce the time for source to be parsed and colorized in the editor. Benchmarks show up to 4x faster colorization for large codebases.

The CMake Tools extension now supports version 10 of CMake Presets which adds features like adding comments in the JSON presets files via the “$comment” field and additional support for generating a project dependency graph with Graphviz. By popular demand, the CMake Tools extension now has full language service protocol (LSP) support for CMake, as well as the option to exclude specific CMake folders from the project view for easier code navigation.

GitHub Copilot support in Visual Studio Code is also improving rapidly, with various AI agents available to users today. Visual Studio Code also has great support for the Model Context Protocol (MCP) that enables the creation of tools to perform specific actions and exposes those tools to agents. Beyond the agent improvements, Visual Studio Code has also been making GitHub Copilot completions more context-aware and tailored to common C++ coding patterns, and next edit suggestions (NES) can predict the next expected change based on your previous changes and the coding patterns, making changes that span many lines in your codebase much easier.

All features covered in the talk are already publicly available; try them out today and let us know what you think!

**MSVC C++ Dynamic Debugger: How We Enabled Full Debuggability of Optimized Code – **Eric Brumer

Check back later for the session video. We’ll post it here when it’s available.

Eric’s talk covered the use of C++ Dynamic Debugging to effectively debug your optimized code. You don’t have to worry about any more ‘variable was optimized away’ messages, and taking normal debugger actions like step-over and step-into behaves exactly as you would expect it to. It also covered the underlying technical details which make the feature powerful, easy to use, and fast to build.

Learn more at https://aka.ms/vcdd and https://aka.ms/dynamicdebugging.

**Welcome to v1.0 of the meta::[[verse]]! – Inbal Levi

Check back later for the session video. We’ll post it here when it’s available.

The talk introduces the static reflection feature that was voted into the Library Evolution Working Group (LEWG) in the C++ standard committee, which reviewed the design of the library side of the reflection feature. The session introduced reflection and its transformative potential within our codebases. After a brief history and introduction of utilities from the latest reflection proposal, Inbal explored the possibilities for “Reflection Libraries” and demonstrated potential directions for future improvements.

**Connecting C++ Tools to AI Agents Using the Model Context Protocol (MCP) – **Ben McMorran

Check back later for the session video. We’ll post it here when it’s available.

Ben’s talk was all about why the Model Context Protocol (MCP) is needed to address a variety of problems that AI assistants encounter when they want to evolve beyond a simple chat interface. The MCP solves these problems by providing an open and standard way for tools to provide context and actions to AI agents. For me, the most interesting part of the talk was seeing an MCP agent get implemented and seeing just how simple, yet powerful, they can be. They really form a major backbone of a successful agentic AI system.

**LLMs in the Trenches: Boosting System Programming with AI – **Ion Todirel

Check back later for the session video. We’ll post it here when it’s available.

Ion’s talk was about practical advice for using AI tools, specifically for embedded and systems programming tasks. The advice offered was based on real-world problems and attempts to solve them using the AI tools that exist today. I’d say that a lot of the points made are relevant to tasks outside of that domain as well, and a key takeaway I had was that if at first your prompt doesn’t succeed, prompt again. Eventually, with enough experience (and advice) you’ll improve your prompts to get the most effective results and save you time when using an AI assistant.

**It’s Dangerous to Go Alone: A Game Developer Tutorial – **Michael Price

Check back later for the session video. We’ll post it here when it’s available.

This was my talk and I had a lot of fun preparing and presenting it. I walk through some of the key things that a C++ developer needs to know to get started with game development, focusing on Blender, Unreal Engine, and Visual Studio 2026. The key takeaway for this talk is that while getting into game development can be intimidating due to unfamiliar tools and techniques, modern tools really lower the barrier. You can make simple 3D game assets in just a few minutes and easily import them into your project, and making your existing C++ code available to Unreal Engine is actually not that hard.

**Duck-Tape Chronicles: Rust/C++ Interop – **Victor Ciura

Check back later for the session video. We’ll post it here when it’s available.

Hybrid C++/Rust codebases are quickly becoming more common – at Microsoft and everywhere in the industry. Having seamless interop between the C++ and Rust components is essential for the success of this symbiosis. There are many challenges in this process, but people found various ways to make things work – from dealing with ABI compatibility and platform/toolchain guarantees, to going down to C and FFI, to various techniques and tools for generating glue-code between the two languages. Many of the explored solutions so far by the community fail to deliver on all the needed requirements, swinging the wide range between performant and ergonomic. Victor highlighted all the interop challenges, some of the good solutions out there, and teased out the avenues at the forefront of this pursuit.

**Building Secure C++ Applications: A Practical End-to-End Approach – **Chandranath Bhattacharyya and Bharat Kumar

C++ remains a foundational language for high-performance applications, but its lack of inherent memory safety and prevalence of undefined behaviors pose serious challenges. Rewriting the vast corpus of existing C++ code into a memory-safe language isn’t feasible in the short term, especially for large-scale projects like Microsoft Edge, which is built atop Chromium’s predominantly C++ codebase. Fortunately, meaningful safety improvements are possible without a full rewrite. Chandranath and Bharat explore how the Edge team systematically addresses safety across four core dimensions: bounds checking, lifetime management, initialization correctness, and type safety. These efforts are grounded in real-world engineering constraints and aim to reduce exploitable vulnerabilities while preserving performance. They also delve into complementary initiatives targeting thread safety, definition safety, and the mitigation of other undefined behaviors. By combining targeted refactoring, static analysis, and safer abstractions, the Microsoft Edge team is charting a pragmatic path toward more resilient C++ code. The session offers insights into scalable safety strategies that can be adopted across large legacy codebases.

**Back to Basics: Code Review – **Chandranath Bhattacharyya and Kathleen Baker

Check back later for the session video. We’ll post it here when it’s available.

In this talk Chandranath and Kathleen examined examples of common C++ coding mistakes the Microsoft Edge team has come across when reviewing code and shared practical strategies to avoid them. They explored best practices for variable scoping, iteration, function and class design, and useful STL functions and algorithms. The talk also provided clang-tidy checks and warnings to use to catch these common issues.

**C++ Performance Tips: Cutting Down on Unnecessary Objects – P**rithvi Okade and Kathleen Baker

Check back later for the session video. We’ll post it here when it’s available.

Prithvi and Kathleen’s session focused on techniques to prevent copying or moving objects in favor of in-place construction. It included many code examples with clang-tidy checks and warnings you can use to point out the potential areas of improvement in your own code. They highlighted guidelines such as passing non-trivial objects by reference, using view types, leveraging in-place constructors, best practices for containers like using emplace and transparent comparators, and finally eliminating runtime cost by moving computation to compile time.

**Reflection-based JSON in C++ at Gigabytes per Second – **Daniel Lemire (Université du Québec) and Francisco Geiman Thiesen (Microsoft)

Check back later for the session video. We’ll post it here when it’s available.

It is fair to say that reflection was one of the latest additions to the library that has attracted the most attention and it was a subject discussed in many of the talks in this edition of CppCon.

In this talk Daniel and Francisco discussed their experience integrating the latest C++26 reflection proposal into the open source simdjson library. A few interesting takeaways from the talk:

• Reflection allows the user to deserialize/serialize their types without having to write any boilerplate code; something that previously took a LOT of boilerplate.
• You can get best-in-class performance by using reflection together with several optimizations, even when extending a library that was designed only with deserialization in mind.
• For now this is an experimental feature already available in the library. It should gain more traction whenever the latest reflection proposal is added to MSVC, GCC, and
• Handling JSON is a poster-child use case for reflection and they went above and beyond to integrate that into the simdjson library, while still following its design principles and guaranteeing the absolute best performance.

Slides are publicly available in: C++26 Reflection for JSON Serialization – A Practical Journey

Other Sessions of Interest

In addition to the keynotes and our own Microsoft sessions, here are some sessions I managed to catch during my very busy week that I thought were interesting.

**Panel: What We Learned About AI Tools For C++ Engineers – **Guy Davidson, Daisy Hollman, Inbal Levi, Jason Turner, Matt Godbolt, Michael Wong

The conference hosted a panel on the topic of AI for C++ Engineers, on which senior members of the C++ training, tooling, and authoring community offered their experience of using these tools, how they have improved their workflow, where the shortcomings are, and what the ideal future will hold. They are also keen to hear the experiences of other engineers who have experimented with AI tools.

**Committee Fireside Chat – **Herb Sutter, Jeff Garland, Andrei Alexandrescu, Bjarne Stroustrup, Gabriel Dos Reis, Inbal Levi, Guy Davidson, Timur Doumler, Barry Revzin, Nina Ranns, Khalil Estell, Vittorio Romeo, Ruslan Arutyunyan, Daisy Hollman

If you’d like to learn more about C++26’s additions of static reflection, async model (std::execution), contracts, and significant safety improvements, this is the session for you.

Wrapping It Up

Congrats, you made it to the end! Thanks for reading through all the way. Be sure to come back and check out the Microsoft C++ blog (this one!) over the coming weeks as we make new announcements for Visual Studio 2026 and all of our other C++ products, and we hope to see you all next September in Aurora!

Category

Author

Senior Product Manager