In November, we introduced C++ code editing tools for GitHub Copilot as a Private Preview, focusing on partnering with customers to tackle one of the common, taxing challenges for C++ development: refactoring at scale. Since then, we’ve listened to feedback and refined our tooling to make wide-sweeping C++ edits easier.

“With C++ code editing tools for GitHub Copilot in Visual Studio, we’ve seen noticeably better overall results, with fewer errors and faster processing on large projects.” – Software engineer (from our Private Preview)

We’re excited to announce that C++ code editing tools for GitHub Copilot are now available to all C++ users in the latest version of Visual Studio 2026 Insiders.

C++ code editing tools for GitHub Copilot

Refactoring at scale is a time-consuming and error-prone process for C++ developers. Traditionally, developers relied on manual searches and incremental edits across multiple files to accomplish these tasks.

With these C++ code editing tools, Copilot goes beyond file searches and unlocks greater context-aware refactoring that enables changes across multiple files and sections.

The C++ code editing tools provide rich context for any symbol in your project, allowing Copilot agent mode to:

• View all references across your codebase
• Understand metadata such as type, declaration, and scope
• Visualize class inheritance hierarchies
• Trace function call chains

This helps Copilot accomplish complex editing tasks, reducing the traditionally manual effort required to perform refactoring tasks by improving the accuracy and speed of these operations.

Getting started

To get started with these tools

1. Open your C++ project and ensure you have IntelliSense enabled
2. Navigate to Tools > Options and turn on the visibility of the tools via GitHub > Copilot settings. You may need to close and re-open your solution for the tools to populate after this step.
3. Enable any or all tools via the “Tools” icon in Copilot Chat

Note: Tool names and UI may evolve during the Public Preview and are subject to change.

Example scenarios

All examples below were showcased using bullet3, an open-source C++ physics simulation engine.

1. Add additional functionality to existing functions

As applications evolve, you often need to enhance existing functions without breaking current behavior. This can include adding logging or performance metrics.

These tools help the agent quickly identify all relevant references, ensuring complete and accurate updates for feature additions.

2. Improve memory management

Inefficient memory handling leads to performance bottlenecks, excessive copies, and unclear ownership semantics. When making these updates, these tools can help identify all relevant references and ensure all type changes are updated to verify code compiles without errors.

3. Visualizing unfamiliar code

C++ code can often have intricate structures and dependency mapping. In a large, unfamiliar codebase, onboarding to a task can often be very time-consuming.

The C++ tools can help identify all relevant class structures and symbol information to produce a visualization of a given set of C++ symbols in a library or file, easing your onboarding process.

Best practices

1. Choose the right model for the job: Models that are optimized for tool-calling will perform best with our tools. To learn more about the models available, please visit these docs: AI model comparison – GitHub Docs
2. Be specific with prompts: Being specific with prompts and breaking vague tasks into clear intent and context will improve the tool calling and performance. Specify symbols explicitly when possible.

Share your feedback

We’d love to hear feedback on how we can improve the C++ tooling experience. Please report problems or suggest improvements through the Visual Studio feedback icon.

What’s next

We’re looking to evolve our integration with Visual Studio tools and expand this support to other Copilot surfaces, like Visual Studio Code, to further empower agent-driven edits for C++. Stay tuned for updates!

The post C++ code editing tools for GitHub Copilot: now in Public Preview appeared first on C++ Team Blog.

Starting with Visual Studio 2026, we are introducing a new support lifecycle for the Microsoft C++ (MSVC) Build Tools. We are also updating the MSVC release cadence.

As Visual Studio moves to a Modern Lifecycle with monthly feature updates and an annual new version, decoupling the compiler from the IDE offers you the best of both worlds – rapid iteration in the IDE and predictable, long-term stability for the build tools. This approach brings you the latest C++ advancements across both IDE and build tools while helping you maintain secure and compliant build environments, with enterprise-grade support, and flexible upgrades at your own pace.

In this post, we outline the key changes, what stays the same, and how we will help your organization with this transition.

Summary of the MSVC release and support lifecycle changes

Visual Studio 2026 version 18.0 released November 11 with MSVC version 14.50. This version of MSVC will be a long-term support release (LTS).

What’s changing?

• Starting with this release, we are separating the lifecycle of MSVC from Visual Studio and adopting the Modern Lifecycle Policy.
  • These changes are specific to the Microsoft C++ Build Tools, which is the collection of Windows C++ compiler tools (e.g., cl.exe, link.exe), C and C++ libraries (STL, ATL/MFC, OpenMP, etc.), and VC Runtime redistributable files. These components are usually installed under [VS Folder]\VC\Tools\MSVC\14.NN.NNNNN\.
• Cadence: MSVC will ship a new release every six months (in May and November), as part of the Visual Studio monthly feature update released on the Stable channel, with 9 months of support.
• Long-Term Support (LTS): Every two years, we will designate the November release as an MSVC LTS release, receiving 3 years of support with bug fixes, security updates, and compatibility improvements.
• Availability: All releases, including MSVC previews, will be available on the Stable Channel and the Insiders Channel for users to opt-in.

The following diagram depicts what our MSVC release schedule may look like for the upcoming years.

What stays the same?

• MSVC acquisition in Visual Studio: Visual Studio will continue to be the primary way to install MSVC using both the full Visual Studio IDE install or the Visual Studio Build Tools install.
• Access to multiple versions of MSVC: Visual Studio continues to offer multiple MSVC versions, including unsupported ones for a limited time, allowing you to update your IDE while independently installing the build tools versions your project require.
• C++ binary compatibility: MSVC 14.50 will continue to be ABI compatible with MSVC versions dating back to Visual Studio 2015, allowing your team to more easily migrate between MSVC versions, independently of your other C++ dependencies.
• C++ Redistributable (VCRedist) follows the lifecycle of the MSVC Build Tools they ship with and continues to be a binary-compatible in-place upgrade (meaning that newer versions of VCRedist will replace older ones without breaking existing applications that were originally built with older versions).
• Support for earlier MSVC releases: The MSVC versions that shipped with Visual Studio 2022 and earlier will continue to be supported according to the lifecycle of Visual Studio in which they first shipped. The new modern support lifecycle applies only to MSVC version 14.50 and up.
• Support for other VS components: No other components installed by Visual Studio e.g., other toolsets, libraries, SDKs, or frameworks are impacted by this change.

Drivers for change

Previously, MSVC followed Visual Studio’s support policy and release schedule. With Visual Studio 2026, MSVC’s lifecycle will prioritize stability, compliance, and modernization to better serve your needs. This shift allows us to deliver more predictable long-term support, help teams stay compliant with evolving regulations, and simplify upgrades with new tooling, all while reducing fragmentation and investing in secure, modern C++ practices:

• New Visual Studio 2026 release cadence: Visual Studio will now be released monthly rather than quarterly, introducing new productivity features and AI workflows more frequently. As the IDE moves faster, we recognize that most customers won’t benefit from MSVC releases on the same new cadence as the IDE. To reflect this preference for stability, MSVC build tools will have a decoupled, less frequent release schedule. And for anyone that wants to move faster between MSVC versions, you can take advantage of our MSVC Preview releases that will be available in Visual Studio on both Insiders and Stable channels.
• Align with .NET long-term support: .NET is already following a modern lifecycle policy. .NET 10 shipped this November, and it is an LTS release for .NET customers. For simplicity and convenience, we are aligning the MSVC build tools LTS schedule to the .NET LTS schedule by designating our November release (MSVC 14.50) as an LTS release.
• Getting current and compliant: Regulations like CyberEO (US) and CRA (EU) require up-to-date tools to secure the software supply chains. Meeting standards, such as NIST and CISA, means depending on outdated compilers is no longer acceptable. These standards are continually evolving to address new security challenges, making regular tool updates essential to maintain compliance. Updating to the latest tools also enables access to more secure and modern coding practices to tackle current threats.
• More value with less fragmentation: Supporting 10-year-old compilers has become increasingly complex. Focusing on fewer MSVC versions lets us maintain the service and security updates you’ve come to expect while investing more towards improving C++ standards conformance, code safety, and performance.

With these reasons in mind, our goal is to modernize the MSVC lifecycle in a way that encourages agility and innovation while providing the best possible support for your enterprise needs.

Helping your team upgrade

To keep your development environment up-to-date and secure, we recommend adopting a regular toolset upgrade rhythm aligned with our MSVC release cadence. We understand that upgrading can present challenges and comes with costs, especially for teams that haven’t prioritized frequent updates before. Based on your feedback, we’re investing in tools and workflows to make moving to the latest version easier, faster, and more predictable:

• Improved Upgrade Workflow in Visual Studio: Visual Studio 2026 introduces a more flexible upgrade experience called Setup Assistant that decouples toolset upgrades from the initial toolset acquisition experience, streamlining side-by-side installations of missing toolsets.
• The overlap of support windows makes migrations easier, whether you upgrade with every release or stick with LTS. You get a one-year overlap for LTS versions and a three-month overlap for regular releases, giving you time to upgrade while staying supported.
• C++ Binary Compatibility for MSVC 14.50: It’s also easy to incrementally upgrade your solutions, taking full advantage of our ABI compatibility guarantee for MSVC 14.50. You don’t need to rebuild all your projects and all your external dependencies at once. And for your third party open-source dependencies, you can count on the vcpkg package manager to rebuild them using the latest toolset.
• GitHub Copilot app modernization for C++: We’re also introducing a new AI-assisted toolset upgrade experience in Visual Studio as a Private Preview. This new functionality can, for example, adjust project settings, enable new recommended warnings or security flags, and even modify source code to eliminate classes of errors introduced by stricter compliance in our compiler. If you are interested, you can sign up for the Private Preview of our GitHub Copilot app modernization for C++ today.

Looking ahead

Thank you for being a valued C++ customer. If you have any questions about how the new MSVC support lifecycle and release cadence may impact your team, you can reach out to us at [email protected].

With the latest MSVC release alongside Visual Studio 2026, we’re excited to bring you significant performance enhancements, improved standards conformance and enhanced security features. Upgrade to MSVC Build Tools version 14.50 today, try these improvements, and share any suggestions via the Help > Send Feedback experience in Visual Studio.

The post New release cadence and support lifecycle for Microsoft C++ Build Tools appeared first on C++ Team Blog.

We are pleased to announce AddressSanitizer (ASan) support for the Microsoft C++ (MSVC) Build Tools for ARM64 targets. ASan is a runtime memory error detector that identifies difficult-to-find bugs with zero false positives and improves memory safety. More technical information on ASan can be found at aka.ms/asan. 

ASan has long supported the x64 and x86 architectures. With the release of Visual Studio 2026 for production use, this support now extends to ARM64. The feature is currently in preview, so there may be build, runtime, or IDE integration issues. Cross-compiling for ARM64 targets from x86 or x64 hosts is supported. ARM64EC is not supported. 

To use ASan in Visual Studio 2026: 

• From the Visual Studio Installer: 
• • Select MSVC AddressSanitizer under Desktop development with C++ 

• • To support cross-compiling projects to ARM64, install MSVC Build Tools for ARM64/ARM64EC  

• To enable ASan in your C++ project after installation: 

• • Right click the solution  

• • Click Properties  
  • Click C/C++ 
  • Enable AddressSanitizer > Yes (/fsanitize=address)  

A preview message will display when targeting ARM64 with ASan: 

ARM64 support for MSVC AddressSanitizer is provided as a preview. 

We’re eager to hear about bugs and suggestions for improvements. 

However, note that this feature is provided as-is without support as we’re working towards the full implementation. 

See: https://aka.ms/asan 

By default, the VCASan library is also used to improve the debugging experience inside Visual Studio.

If you’ve built your application on a host architecture other than ARM64, it must be executed on an ARM64 target machine from an ARM64 Visual Studio 2026 Developer Command Prompt or alongside the ASan binary clang_rt.asan_dynamic-aarch64.dll. Otherwise, the ASan binary must be manually copied from %VSINSTALLDIR%\VC\Tools\MSVC\<version>\bin\Hostarm64\arm64 to the same directory of the executable under test. 

We’d love for you to try it out and provide any feedback you may have! Please report any issues you find via Help > Send Feedback > Report a Problem in Visual Studio.

The post Introducing MSVC AddressSanitizer for ARM64 targets appeared first on C++ Team Blog.

Refactoring a C++ codebase can often require tracking updates across various sections of multiple files to ensure accuracy and relevancy.  Historically, developers have relied on manual searches across a codebase and refactoring tools to perform these types of edits. However, with GitHub Copilot agents, developers can now delegate these complex editing tasks to the agent, which understands your intent and can carry out codebase-wide edits, reducing the manual effort required to perform these refactors.

To make this experience even more powerful for C++ developers, we’re introducing C++ Code Editing Tools for GitHub Copilot, now available in Private Preview in the latest version of Visual Studio 2026 Insiders.

These tools bring the power of C++ IntelliSense to Visual Studio agent mode, enabling faster and more accurate codebase-wide edits. With these tools, GitHub Copilot can now access rich context for any C++ symbol, including:

• Viewing all references across your codebase
• Understanding relevant metadata (e.g. type, declaration, and scope)
• Visualizing class inheritance hierarchies
• Tracing function call chains

By grounding edits in semantic understanding rather than syntactic-level text matching, these tools help reduce the manual effort required for refactors.

To see these tools in action, please watch our demo below

You can invoke these tools directly in Copilot Chat and use prompt files for more complex refactoring tasks. For best results, we recommend that you be clear and specific with your prompts and break larger ideas into smaller, fine-grained tasks for the agent to execute.

Want to try it out?

These tools are now available in Private Preview as we work to shape the user experience and gather feedback from our C++ developers. If you’re interested in signing up to try these out for yourself, please join our Private Preview waitlist.

The post Perform wide-sweeping refactors using C++ code editing tools for GitHub Copilot appeared first on C++ Team Blog.

Long build times are one of the top pain points for C++ projects. If you’ve ever waited too long for a C++ build to finish, you know how much it can slow down your productivity. In past years, we introduced C++ Build Insights to help you analyze traces and find bottlenecks. However, we know that embarking on these investigations manually can still take time and effort.

To make this experience easier for C++ developers, we’re excited to announce that GitHub Copilot build performance for Windows is now available in Private Preview with the latest version of Visual Studio 2026 Insiders.

New GitHub Copilot Capabilities

When you use this new capability in Visual Studio, GitHub Copilot will use an agent to:

1. Kick off a build and capture a trace for you
2. Identify expensive headers and other bottlenecks
3. Suggest and apply optimizations like precompiled headers
4. Validate changes through rebuilds so your code stays correct
5. Show you measurable improvements and recommend next steps

Instead of spending time manually optimizing your build, you can let the new GitHub Copilot build performance capability handle the heavy lifting while you focus on writing code.

To see how it works in action, please watch our demo below.

Try it now in Private Preview

GitHub Copilot build performance for Windows is available today in Private Preview for Visual Studio 2026 Insiders. To try it out, join the Private Preview waitlist today. We’re looking forward to your feedback to make this experience even better.

The post Optimize Your C++ Build Times with GitHub Copilot appeared first on C++ Team Blog.

A few problems have reared their heads at every company where I’ve worked on C++ as a Software Engineer over the past 20 years. For the most part, those problems have nothing to do with the language and how it is used, but instead all the “other” stuff, like dealing with long build times, getting consistent build environments, and managing the technical debt of an evolving tooling landscape.

When the tools we use to build our applications and systems have new releases, we must make hard decisions. Do we adopt the latest and greatest and turn potential technical debt into realized technical debt, or do we err on the side of the stability of our systems, perhaps at the cost of critical performance or security improvements? A reasonable approach is to weigh the benefits we will gain against the costs of dealing with different codegen, stricter language conformance, and deprecated or removed features.

GitHub Copilot app modernization for C++, available in Private Preview in the latest version of Visual Studio 2026 Insiders, tips the scale, greatly reducing the toil incurred when adopting newer versions of MSVC. Let GitHub Copilot churn through that technical debt while you focus on adding that great new feature or finding and resolving the root cause of that bug found by your most important customer.

GitHub Copilot app modernization for C++ can launch the upgrade process, analyze the project for any warnings or errors, create a detailed plan on how to fix those issues, and then implement those changes. Along the way, you’ll have the opportunity to direct Copilot to focus on specific issues and to adjust the plan to fit your exact situation and coding practices. You won’t need to spend hours or days tracking down all the places where that deprecated API is used and manually applying the same pattern to adopt its replacement. And you won’t need to stare at your screen trying to decide which of the hundreds of new warnings should be the first that you should tackle; Copilot may even resolve them all before you’ve had time to understand the work and decide where to start.

Want to try it out?

GitHub Copilot app modernization for C++ is now available in Private Preview so that we can gather feedback from users with real world C++ codebases. If you want to help others, including your future self, by helping us make the experience as awesome as possible, please join our Private Preview waitlist. And in the meantime, go ahead and get started with the latest Visual Studio 2026 Insiders build!

The post Fix build issues using GitHub Copilot after upgrading MSVC Build Tools appeared first on C++ Team Blog.

Get ready to level up your C++ productivity, because Visual Studio 2026 version 18.0 is now generally available! You can take advantage of the new features, bug fixes, and performance improvements in your production environment. This post describes what’s new for C++ developers, including new features or improvements in these areas:

• A refreshed IDE UI
• Support for Visual Studio 2022 extensions out of the box
• Seamless upgrade experience from an older version of Visual Studio
• Microsoft C++ (MSVC) Build Tools v14.50: Greater C++23 conformance and runtime performance improvements
• AddressSanitizer support for ARM64 targets (Preview)
• IDE productivity improvements:
  • New keyboard shortcuts
  • Syntax highlighting for C++ attributes
  • Class View substring searches and performance improvements
  • Generate preprocessed output
  • Enhanced controls in the bottom margin, including viewing and setting file encoding
  • File exclusion options in Quick Find and Find in Files
• GitHub Copilot Chat: improved chat experience and new context menu options
• C++ project system changes (MSBuild and CMake)
• New clang-tidy configuration options
• Set command line arguments for the debugger from the toolbar
• Mermaid chart rendering
• Podman support in Container Tools
• Git tools improvements

You can also read the broader announcement on the Visual Studio Blog for more details on changes that are non-C++-specific. Let’s dive in!

Your feedback matters to us

You can always give us feedback about your Visual Studio experience on Visual Studio Developer Community or from the Help > Send Feedback menu in the IDE.

Over the past 12 months, we fixed 387 C++ related issues and implemented 29 C++ related feature requests in Visual Studio. Many of the new features described in this blog post were suggested by you!

Refreshed UI with 11 themes to choose from

User Feedback: Update UI of Visual Studio 2022 like the new Windows 11 UI – Developer Community

The new IDE includes a UI refresh, from icon and spacing changes to 11 new themes.

Improved settings UI

User Feedback: Unified Settings feedback – Developer Community

The Visual Studio settings (Tools > Options) UI is now integrated into the editor. You can also configure the settings from a JSON file accessible from the new UI.

Your settings will carry forward from older Visual Studio versions with roaming support. However, settings will no longer sync back to older products to ensure a cleaner migration path and forward compatibility.

Bring your Visual Studio 2022 extensions

Visual Studio 2026 works out of the box with your existing Visual Studio 2022 extensions.

Upgrading existing projects to Visual Studio 2026

Check out our blog post, Upgrading C++ Projects to Visual Studio 2026, for an overview of what’s available to you to help you manage your transition to Visual Studio 2026, including continued binary compatibility for the C++ build tools and redistributable and the new Visual Studio setup assistant. Then, take a look at our updated porting and upgrading guide in our documentation.

Microsoft C++ (MSVC) Build Tools v14.50

Version 18.0 of the IDE ships with Microsoft C++ (MSVC) Build Tools version 14.50, offering our best conformance, build performance, and runtime performance story yet, along with a multitude of bug fixes. To get access to all the new language features, be sure to build with /std:c++latest or go with /std:c++23preview if you only need features up to and including C++23.

C++ language improvements in the compiler

C++23 language updates in the compiler are summarized in the C++ Language Updates in MSVC Build Tools v14.50 blog post. They include, but are not limited to:

• P0849R8: auto(x): decay-copy in the language, for casting x into a prvalue as if passing it as a function argument by value.
• P2437R1: Implemented C++23 preprocessing directive #warning to allow code authors to generate a diagnostic message without stopping translation the way #error does.
• CWG Issue 2586: Explicit object parameter for assignment and comparison.
• P2280R4: Using unknown pointers and references in constant expressions.

C++ language features and performance improvements in the standard library

Microsoft C++ standard library (STL) changes are summarized at: Changelog · microsoft/STL Wiki. As this is an open-source project, we welcome community contributions. With the help of the community, we implemented many improvements, including, but not limited to:

• P0472R3: Put monostate in <utility>.
• P3223R2: Making std::istream::ignore(n, delim) less surprising. This had surprising behavior if delim is a char with a negative value. This change removes the surprise to make code more robust.
• Partial support for P3697R1: minor additions to standard library hardening to improve memory safety.
• LWG-2503: multiline option should be added to syntax_option_type.
• LWG-4186: regex_traits::transform_primary mistakenly detects typeid of a function.
• LWG-4222: expected constructor from a single value missing a constraint.
• LWG-4242: ranges::distance does not work with volatile iterators.
• A multitude of performance improvements (see changelog for more):
  • Improved performance for regex matching.
  • Started using [[msvc::no_unique_address]] as a space optimization in several C++23 components.
  • Added and improved vectorized implementations of many types and functions.
  • Used Clang’s builtin __is_trivially_equality_comparable to improve the performance of equal(), ranges::equal, and many vectorized algorithms for more types.
  • Implemented an exponential speedup for minstd_rand and minstd_rand0's discard() member function
  • Improved std::includes() to have the same performance as ranges::includes
  • Improved the performance of count() for vector<bool>

Compiler runtime performance improvements

Working closely with our game developer partners, we invested in runtime performance improvements for code built with MSVC. We measured these improvements using benchmarks from Unreal Engine City Sample (RenderThread and GameThread):

• Up to +6% faster runtime, as measured on Unreal Engine’s City Sample RenderThread

• Up to +3% faster runtime, as measured on Unreal Engine’s City Sample GameThread

AddressSanitizer support for ARM64 builds (Preview)

In Visual Studio 2019 we added AddressSanitizer support for code built with MSVC to help developers identify memory safety issues with zero false positives using the /fsanitize=address flag. At the time, the support applied to code built for x86 and x64 architectures. This support is now extended to projects targeting ARM64. This ARM64 support is in preview, and we will continue to refine it and fix any incoming bugs in future updates.

IDE productivity improvements

We worked on several developer productivity improvements in 18.0, many in response to feedback from you!

More keyboard shortcut consistency with other editors

User Feedback: Adding a shortcut Ctrl+W to close the file in VS – Developer Community

Several keyboard shortcuts have been added from VS Code and other editors to give you a more consistent experience as you switch between these environments. In the past, this included Ctrl + / to toggle line comments and Ctrl + Shift + P to open Feature Search. But the following shortcuts are new in 18.0:

• Ctrl + W now closes the current tab (in addition to Ctrl + F4)
• Ctrl + P now opens Code Search (in addition to Ctrl + T and Ctrl + ,)

Syntax highlighting for C++ attributes

User Feedback: Syntax highlighting: use a unique color for C++ attributes – Developer Community

C++ attributes are now colored in the editor, making your code more visually distinctive and easier to read. By default, they use the same theme color as user-defined types.

Class View substring searches and performance improvements

User Feedback: Search in Class View does not work, if search term is not the beginning of the class but part of it – Developer Community

The Class View window now supports substring searches, so you can have an easier time examining the architecture of your code.

In addition, Class View’s performance has been improved for Unreal Engine projects.

Generate preprocessed output

User Feedback: Make it possible to see preprocessed C++ source code (easily in IDE) – Developer Community

You can right-click a C++ file in Solution Explorer and select Preprocess to instantly generate its preprocessed output, making it easy to debug macros and includes, see errors immediately, and avoid manual changes to project settings or interruptions to full project builds.

Enhanced controls in the bottom margin

User Feedback: I wish Visual Studio 2022 able to show file encoding in the editor. – Developer Community

The bottom margin in the editor has been upgraded to be more informative and customizable. Line, column, and character position are now unified into a single display. Clicking it opens the Go To Line dialog for faster navigation. When working with multiple selections, you’ll see total counts for selections, characters, and lines. Hovering over the selection margin reveals detailed info per selection.

File encoding is now displayed in the margin for quick reference. You can also save or reopen a file using a specific encoding, which helps ensure proper display of special characters, supports multiple languages, and maintains consistent readability across systems.

Clicking the encoding margin opens a context menu where you can choose to save or reopen the file. Selecting an option will launch an encoding dialog with a dropdown list of available encodings to choose from.

A new context menu has been added to the margin, giving you full control over what information is shown. This menu includes all the bottom margins in the editor, from the zoom control all the way to the new encoding margin.

You can manage these settings through Tools > Options > Text Editor > General > Display > Show editing context in the editor. For quicker adjustments, right-click the bottom margin to open the new context menu and change what’s shown.

File exclusions in Find in Files / Quick Find

User Feedback: Find and Replace — option to exclude folders – Developer Community

You can now exclude files you never need to look at from Find in Files (Ctrl + Shift + F) and Quick Find (Ctrl + F). To set it up, go to Tools > Options > Environment > Search, and look for the new Exclude files from search results section. There, you can add, edit, or remove glob patterns to control exactly which files are left out of your search results.

GitHub Copilot Chat

GitHub Copilot Chat allows you to use natural language to get answers to questions (Ask mode) or even implement changes for you automatically (Agent Mode). We made several improvements to this feature (listed below), and we also have 3 new features available in Private Preview: New GitHub Copilot capabilities for C++ developers: Upgrade MSVC, improve build performance, and refactor C++ code.

Better responses in Copilot Chat

User Feedback: Visual Studio GitHub Copilot line number difference – Developer Community

Copilot Chat is getting smarter with improved context for your everyday tasks. You can expect better results when searching your codebase and referencing specific lines in your code.

Copilot Actions in context menu

User Feedback: Quickly Get Copilot Assistance from Your Context Menu – Developer Community

A Copilot Actions option was added to the right-click context menu in the Visual Studio editor.

You can use this to interact with a specific file or lines of code in Copilot Chat. You can ask Copilot to explain what the code does, make optimizations, generate comments or unit tests, or just reference it in the chat for you to add your own custom prompt.

Reference commits and changes in the Git Changes window

You can now ask Copilot to summarize uncommitted code changes, explain a specific commit, and more.

You can reference uncommitted changes by adding #changes to your prompt or type #commit: to pull up a list of the most recent commits for you to select. You can also reference a specific commit id.

With the context of your changes or commits, you can then ask Copilot to answer questions in Ask Mode or perform tasks in Agent Mode like writing unit tests or finding bugs.

Reference URLs in your questions

You can paste a URL in the prompt box and Copilot will pull information from the web to prepare its response. For example, you can ask Copilot to write a readme file based on best practices from GitHub or to look at reference material while preparing an answer to a question.

This only works for public URLs and static HTML content.

C++ Project Systems

Visual Studio 2026 continues to maintain native support for MSBuild, CMake, and Unreal Engine projects.

C++20 default for new MSBuild projects

Many MSBuild projects generated using new project templates now target C++20 by default. This includes the Console App, Windows Desktop Application, Dynamic-Link Library, and Static Library.

CMake projects in Visual Studio 2026

Visual Studio 2026 now includes CMake 4.1.1 by default. CMake also includes a Visual Studio 2026 generator and modern SLNX projects, allowing you to build Visual Studio C++ projects directly from CMake.

Diagnostic Tools now support CMake projects

CMake projects now have native support for profiling tools including CPU Usage, Events Viewer, memory usage, and File IO tools in Visual Studio. The CPU Usage tool also includes Copilot-powered performance insights, helping you detect and resolve bottlenecks even faster.

Tailored for game developers and performance-critical workflows, this update lets you:

• Identify performance bottlenecks and optimize compute-heavy code with the CPU Usage Tool.
• Track runtime events like exceptions, logs, and HTTP requests with the Events Viewer.
• Analyze file access patterns, durations, and throughput with the File IO Tool.

Clang-tidy updates

User Feedback:

• clang-tidy needs to use all cores available. – Developer Community
• Support extra args for clang-tidy – Developer Community

The clang-tidy code analysis tools in Visual Studio have new configuration options. You can allocate more processors to run code analysis as part of your build, speeding up your development workflow. Plus, you can add custom arguments to the command line to invoke clang-tidy, giving you complete control over your analysis setup.

You can access these powerful new options from Project Properties > Code Analysis > Clang-Tidy.

Debugging: Set command line arguments for any C++ projects

The ability to set command line arguments for the debugger from the toolbar has been expanded to include all .vcxproj, CMake, and Unreal Engine projects. The feature has also received the following improvements:

• Go directly to the underlying debugger command line argument setting for your project type.

• A clear indication of an empty command line argument setting that retains your ability to easily identify and locate the toolbar dropdown.

This feature is no longer tied to the Game Development with C++ workload and is available to all C++ developers without needing to install any additional workloads or components.

To learn more, take a look at the Pass command-line arguments documentation.

Mermaid chart rendering

User Feedback: Mermaid support and code highlighting in markdown previews – Developer Community

You can now render Mermaid charts in the markdown editor preview window, where you can provide your own Mermaid syntax or generate it with Copilot. This lets you visualize complex data structures and workflows in the IDE.

Podman support in Container Tools

Visual Studio Container Tools now support Podman, a popular container management tool that provides a daemonless container engine. This allows you to run and manage containers using the Podman CLI directly from Visual Studio.

To get started, simply start Podman and open your solution in Visual Studio.

Git tools

The Visual Studio Git tools also received some updates:

• Copilot-generated code reviews now use updated reasoning models to provide more insightful and precise comments.
• Code review comments are now generated for the entire change set at once rather than file-by-file, resulting in improved performance and a more comprehensive review.
• When you view Copilot generated comments on your uncommitted changes, you will now see a list of comments in the Git Changes window. You can double click a comment to navigate to that line of code in the editor.
• You can apply suggested code changes from a PR comment by clicking the sparkle button at the top right of the comment. If there aren’t any suggestions, you can request Copilot to suggest a change based on the comment.

Download Visual Studio 2026

Ready to get started? Try out Visual Studio 2026 version 18.0 today and feel free to share your feedback below! Also check out the release notes for a full list of what’s changed!

The post What’s New for C++ Developers in Visual Studio 2026 version 18.0 appeared first on C++ Team Blog.

vcpkg, an open-source C/C++ package manager maintained by Microsoft, is increasingly recognized as a leading dependency management solution. As an enterprise-grade tool, it enables organizations to streamline library imports, reduce duplication, and support flexible, reproducible builds across a wide array of environments.

This need for streamlined dependency management is especially relevant in the build system for the Visual Studio repository. This system not only supports the development of Visual Studio itself but also integrates decades of legacy infrastructure, specialized tools, and complex architecture. The primary goal of integrating vcpkg is to simplify the acquisition and management of open-source native libraries by providing a unified solution that not only replaces manual compilation and custom integration for each project but also ensures security compliance throughout the process.

To achieve our objectives, we divided the execution into two distinct phases: an initial phase focused on prototyping and experimentation, followed by a second phase dedicated to productization and integration into the build process.

Prototype

This investigation started by adopting vcpkg from scratch, aiming to make it easier to use existing package libraries in the build environment. We started with a practical experiment: integrating vcpkg into our environment with the SQLite library.

We chose SQLite because it’s widely used and handled differently across various build components, making it an excellent test case for streamlining and standardizing library management. This investigation also demonstrates that we can adapt the cereal and libuv libraries for local vcpkg use.

Why vcpkg?

• Supports secure, reproducible builds in isolated environments.
• Private registry: lets our organization keep an internal catalog of approved libraries and library versions, simplifying compliance, standardization and security screening.
• Asset caching: allows build machines to get source files and tools from internal servers, without the need for public internet access.

As part of our previous workflow, our build environment used MSBuild and relied on NuGet packages to manage tools and libraries. Each build component compiles libraries such as SQLite and applies its own preprocessor flags and build logic for integration. As a result, separate projects repeatedly build the same library sources instead of compiling them once and reusing them as a static library across the solution.

This approach presents several challenges: there is no unified solution for dependency management, each build configuration requires manual upkeep, and library usage is inconsistent across components.

Microsoft’s sandboxed build environment automates software compilation, packaging, and deployment in local and cloud environments. Projects build independently on isolated cloud machines, supporting continuous integration workflows and simplifying build tracking, diagnostics, and artifact distribution. The lack of internet access and Visual Studio in this sandboxed build environment presents additional challenges for acquiring and maintaining open-source native libraries.

Build Integration

After the prototype is successfully completed, the project was scaled up across the entire build environment.

To avoid high maintenance costs, the team generates custom vcpkg triplets during the build process. Custom triplets allow developers to define specific build configurations (e.g., platform, architecture, compiler settings) tailored to the project. This flexibility is essential for our heterogeneous build environments and helps ensure compatibility across legacy and modern components.

Triplet Generator Projects:

• Dynamically create custom vcpkg triplets during the build process.

• Eliminate the need for checked-in triplets, reducing maintenance overhead.

• Automatically configure toolset paths and compiler settings (PATH, INCLUDE, LIB).

• Ensure consistent library configurations and IntelliSense support across all projects.

Internal Asset Caching Tool:

• Securely retrieves Open-Source Software (OSS) dependencies from internal registries.

• Resolves challenges related to restricted or offline build environments.

• Ensures compliance and traceability for third-party libraries.

Library Integration:

• Libraries such as SQLite, libuv, and cereal are built in a consistent and reproducible way.

• Provides seamless integration with MSBuild.

• Minimizes manual configuration and improves build reliability.

Sandboxed Build Environment Integration

Challenges Addressed:

• Introduced dedicated build nodes to handle vcpkg installation tasks efficiently.

• Leveraged triplet generator projects to override and improve CloudBuild’s native vcpkg integration.

• Ensured libraries are built once and reliably reused across dependent projects, reducing redundant builds and improving consistency.

Conclusion

vcpkg has emerged as Microsoft’s preferred solution for C++ dependency management, with many teams using it to address their needs. By adopting vcpkg, we were able to drive increased productivity, security compliance and consistency across our engineering processes.

Interested in learning more? Check out the stories below for additional insights and experiences from teams adopting vcpkg in their workflows.

• Siemens Healthineers manages C++ libraries with vcpkg in an offline build environment
• Askia, an Ipsos company, achieved faster, reproducible builds with vcpkg

The post Inside Visual Studio: Improving Open-Source Workflows with vcpkg appeared first on C++ Team Blog.

This blog post summarizes changes to the vcpkg package manager as part of the 2025.10.17 registry release, the 2025-10-10 and 2025-10-16 tool releases, as well as changes to vcpkg documentation throughout October. This month’s updates includes partial support for Visual Studio 2026 and platform toolset v145, NetBSD platform support, and minor improvements and bug fixes.

Some stats for this period:

• There are now 2,691 total ports available in the vcpkg curated registry. A port is a versioned recipe for building a package from source, such as a C or C++ library.
• 38 new ports were added to the curated registry.
• 395 ports were updated. As always, we validate each change to a port by building all other ports that depend on or are depended by the library that is being updated for our 15 main triplets.
• 81 community contributors made commits.
• The main vcpkg repo has over 7,100 forks and 26,000 stars on GitHub.

vcpkg changelog (2025.10.17 release)

• Support for v145 platform toolset (PR: Microsoft/vcpkg-tool#1787, thanks @huangqinjin!).
• Added support for NetBSD platform (PRs: Microsoft/vcpkg-tool#1789, Microsoft/vcpkg-tool#1785, thanks @cqundefine!).
• Other minor improvements and bug fixes.

Documentation changes

Over the past month we had minor documentation improvements. If you have any suggestions for our documentation, please submit an issue in our GitHub repo or see the box at the bottom of a particular article.

Total ports available for tested triplets

While vcpkg supports a much larger variety of target platforms and architectures (as community triplets), the list above is validated exhaustively to ensure updated ports don’t break other ports in the catalog.

Thank you to our contributors

vcpkg couldn’t be where it is today without contributions from our open-source community. Thank you for your continued support! The following people contributed to the vcpkg, vcpkg-tool, or vcpkg-docs repos in this release (listed by commit author or GitHub username):

Learn more

You can find the main release notes on GitHub. Recent updates to the vcpkg tool can be viewed on the vcpkg-tool Releases page. To contribute to vcpkg documentation, visit the vcpkg-docs repo. If you’re new to vcpkg or curious about how a package manager can make your life easier as a C/C++ developer, check out the vcpkg website – vcpkg.io.

If you would like to contribute to vcpkg and its library catalog, or want to give us feedback on anything, check out our GitHub repo. Please report bugs or request updates to ports in our issue tracker or join more general discussion in our discussion forum.

The post What’s New in vcpkg (October 2025) appeared first on C++ Team Blog.

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

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

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

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

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

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

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

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

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

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 – Prithvi Okade and Kathleen Baker

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)

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!

The post Microsoft C++ Team at CppCon 2025: Trip Report appeared first on C++ Team Blog.