{"id":36892,"date":"2026-09-14T06:38:16","date_gmt":"2026-09-14T06:38:16","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/cppblog\/?p=36892"},"modified":"2026-09-14T06:38:16","modified_gmt":"2026-09-14T06:38:16","slug":"whats-new-for-c-developers-in-visual-studio-2026-18-7-18-10","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/cppblog\/whats-new-for-c-developers-in-visual-studio-2026-18-7-18-10\/","title":{"rendered":"What\u2019s New for C++ Developers in Visual Studio 2026 (18.7 \u2013 18.10)"},"content":{"rendered":"

Over the past few months, we have continued shipping monthly Visual Studio 2026 releases, delivering improvements across all stages of the development cycle. In this blog post, we’ll recap everything that changed from version 18.7 through 18.10 (released this month) that is relevant for C++ developers. This includes new tools for maintaining and navigating C++ projects, along with Git, GitHub Copilot, and debugging improvements that support the way large native codebases are built.<\/p>\n

Some headlines include the GitHub Copilot modernization experience (now generally available) to guide you through MSVC upgrades, a deeper semantic index to accelerate code navigation, discoverable MSVC Build Tools versions across installations, and support for Git worktrees and submodules directly in the IDE.<\/p>\n

For the previous set of updates, see What’s New for C++ Developers in Visual Studio 2026 versions 18.1 through 18.6<\/a>.<\/em><\/p>\n

C++ reliability improvements<\/h2>\n

Across Visual Studio 2026 versions 18.7 through 18.10, we fixed 272 C++ bugs reported through Developer Community and internal testing.<\/strong><\/p>\n

These fixes include C++ IntelliSense diagnostics and include resolution, compiler and code-generation issues, a std::regex regression<\/code>, debugger stability, and a C++ Solution Explorer context-menu issue.<\/p>\n

Modernize and manage C++ projects<\/h2>\n

Upgrade MSVC projects with GitHub Copilot<\/h3>\n

GitHub Copilot modernization for C++<\/a> is now generally available. This modernization agent helps upgrade MSBuild and CMake projects to a newer version of the Microsoft C++ (MSVC) Build Tools. It assesses the codebase, builds an upgrade plan, updates project settings and source code, and validates fixes for issues such as stricter conformance, deprecated standard library functions, new warnings, and linker errors.<\/p>\n

The agent has two flow modes. Automatic<\/strong> mode proceeds through assessment, planning, and execution with less intervention. Guided<\/strong> mode pauses between stages so you can review the scope and proposed approach before changes are applied. You can switch modes as the upgrade progresses.<\/p>\n

Before you start, use the Visual Studio Installer to select the GitHub Copilot modernization<\/strong> optional component. You also need a GitHub Copilot subscription and an MSBuild or CMake C++ project.<\/p>\n

Right-click a solution or project in Solution Explorer<\/strong> and select Modernize<\/strong> or enter @Modernize in GitHub Copilot Chat. For MSBuild projects that reference an unavailable MSVC version, the Setup Assistant can also offer to launch the modernization agent after retargeting the project. The agent focuses on issues caused by the MSVC upgrade and adapts its task list when one fix reveals another problem. You remain in control of the scope and can stop, redirect, or resume the work.<\/p>\n

\"modernize<\/a><\/p>\n

Use PackageReference in native C++ projects<\/h3>\n

Visual Studio 2026 introduced experimental support for NuGet PackageReference in native .vcxproj projects<\/strong>. Package references live directly in the project file, support transitive dependency resolution, use NuGet’s global package cache, and can be conditioned by configuration or platform with normal MSBuild syntax.<\/p>\n

Enable the experience in a project or Directory.Build.props:<\/p>\n

<Project> \r\n    <PropertyGroup> \r\n        <EnableNativePackageReferenceSupport>true<\/EnableNativePackageReferenceSupport> \r\n    <\/PropertyGroup> \r\n<\/Project><\/code><\/pre>\n
You can then edit the project file directly or use Manage NuGet Packages<\/strong> in Visual Studio:<\/p>\n
<ItemGroup>\r\n    <PackageReference\r\n        Include=\"Microsoft.Windows.CppWinRT\"\r\n        Version=\"2.0.240405.15\" \/>\r\n<\/ItemGroup><\/code><\/pre>\n
We continue to recommend vcpkg<\/a> for acquiring and managing C and C++ libraries. But NuGet PackageReference is useful for NuGet-distributed SDKs and binaries, internal NuGet feeds, and repositories that need a consistent distribution workflow across native C++ and .NET projects.<\/p>\n
The initial implementation is off by default and remains unsupported for C++\/CLI projects targeting .NET Framework versions and limited for some cross-language project references. Read NuGet PackageReference for C++ Projects in Visual Studio<\/a> for current limitations and workarounds.<\/p>\n
Discover pinned MSVC Build Tools versions across installations<\/h3>\n
Visual Studio 2026 can now locate an exact pinned MSVC Build Tools version (major.minor.patch) in another Visual Studio or standalone Build Tools installation. This helps teams update the IDE independently while retaining a known-good compiler version for reproducible local and continuous integration builds.<\/p>\n
Previously, Visual Studio only searched other installations for a matching toolset if your current install had no toolset installed at all for your target platform toolset version. This change removes this restriction.<\/p>\n
Opt in with EnableVCToolsVersionDiscovery<\/code>and specify the required VCToolsVersion<\/code>:<\/p>\n
<PropertyGroup>\r\n    <EnableVCToolsVersionDiscovery>true<\/EnableVCToolsVersionDiscovery>\r\n    <VCToolsVersion>14.43.34604<\/VCToolsVersion>\r\n<\/PropertyGroup><\/code><\/pre>\n
When the requested version is not available in the current installation, Visual Studio searches other installations instead of requiring a manually assigned VCToolsInstallDir<\/code>. This gives teams two complementary paths: use the modernization agent when it is time to upgrade or pin an exact MSVC Build Tools version when compatibility and repeatability are the priority. See the Visual Studio July update<\/a> post for more.<\/p>\n
Preview the next MSVC Build Tools updates<\/h3>\n
Work on MSVC Build Tools version 14.52 continued with monthly updates to the preview builds shipping in the Visual Studio Stable Channel (and even faster updates in the Insiders Channel).<\/p>\n
In the July and August previews, frontend and modules updates include support for default-initialized new[]<\/code> expressions in constant evaluation with modules, more robust argument-dependent lookup and module serialization, and clearer diagnostics for calling-convention mismatches, incompatible compiler options, and unusable compiled libraries.<\/p>\n
The backend added Armv9.2 LUTI2 support and improved ARM64 vectorization, load pairing, and instruction selection. x64 and x86 updates expanded APX instruction selection and improved conditional comparisons, vector constants, and tail calls. The optimizer gained additional loop, induction-variable, devirtualization, and expression-reassociation improvements. The linker and debugging tools also improved incremental linking, PDB growth and determinism, large debug-information streams, and module type merging.<\/p>\n
AddressSanitizer can now use the MSVC disassembler as a fallback instruction-length decoder, reducing unrecognized-instruction failures, and diagnoses incompatible use with \/clr<\/code>. These previews also include Code Analysis reliability improvements and fixes for compiler crashes, miscompilations, module regressions, and invalid AVX-512 code generation.<\/p>\n
For the detailed change lists, see the July 2026<\/a> and August 2026<\/a> MSVC Build Tools preview posts. You should also look at the STL Changelog<\/a> for a full list of standard library improvements.<\/p>\n
Navigate large C++ codebases faster<\/h2>\n
Whole Codebase Indexing is a preview feature that adds richer symbol-use information to the C++ browse database. Instead of repeatedly computing some relationships on demand, Visual Studio can reuse semantic data that has been indexed as you work.<\/p>\n
The deeper index improves features that use the IntelliSense engine, including semantic colorization, Go to Definition, and Find All References. It also gives Copilot’s find_symbol<\/code> tool faster access to these code navigation features and enables CodeLens references for C++. In Microsoft’s testing with Bullet3 and LLVM, many navigation and colorization scenarios improved by 2x or more, although results and indexing costs vary with the codebase.<\/p>\n
\"Graph,<\/a><\/p>\n
\"findallreferenceswci<\/a><\/p>\n
To enable the feature, open Tools > Options > Languages > C\/C++ > IntelliSense > Browsing & navigation > Whole codebase semantic index<\/strong>, then enable faster code navigation and colorization. Learn more in Faster Code Navigation and GitHub Copilot Tools with Whole Codebase Indexing<\/a>.<\/em><\/p>\n
Optimize the builds you run every day<\/h2>\n
GitHub Copilot build performance for Windows<\/a> now evaluates iterative builds as well as clean builds. That distinction matters because an optimization such as a precompiled header can make a full rebuild slightly slower while improving the edit-build-debug loop that developers repeat throughout the day.<\/p>\n
\"A<\/a><\/p>\n
Ask Copilot Chat to \u201cmake my build faster<\/em>\u201d. The agent captures a baseline, proposes an optimization, measures the result, and rolls back changes that do not help. If a change is not beneficial in a clean build, the agent can test a comparable iterative build before deciding whether to keep it.<\/p>\n
\"step<\/a><\/p>\n
Review changes with GitHub Copilot<\/h2>\n
Copilot review now scales from a selected block of code to working changes, commits, and pull requests. Select any block of code in the editor and choose Copilot Actions > Review Selection<\/strong> for a focused review. Findings appear as inline comments so you can inspect and address them in context.<\/p>\n
\"Context<\/p>\n
For a conversational review, switch to the Git agent in GitHub Copilot Chat. Ask it to review uncommitted work, select the Copilot review control in Git Changes<\/strong>, or attach a commit in chat. You can also start this review from the post-commit infobar or from a commit in the Git Repository<\/strong> window. Findings appear inline and in a navigable list, and you can continue the conversation to investigate a finding or request a suggested fix.<\/p>\n
Visual Studio also provides a local commit-review workflow. Enable Review Git changes locally and provide suggestions from comments<\/strong> under Tools > Options > GitHub > Copilot > Source Control Integration<\/strong>, then right-click a commit in the Git Repository<\/strong> window and select Review Commit<\/strong>. You can select two commits to review the range between them. These reviews remain local to the Visual Studio session. Both review workflows support GitHub and Azure DevOps repositories.<\/p>\n
Copilot review is another source of feedback, not a replacement for compiler diagnostics, Code Analysis, tests, or human review. It is most useful when you give it a clear scope, such as reviewing ownership changes, thread synchronization, error handling, or API usage before opening a pull request.<\/p>\n
The broader pull-request experience also lets you inspect changes without checking out the branch, comment and resolve threads, review commits, approve changes, and complete or merge the pull request from Visual Studio. For a walkthrough, see Review Pull Requests Without Leaving Visual Studio<\/a>.<\/em><\/p>\n
Work across large Git repositories<\/h2>\n
Keep multiple branches active with worktrees<\/h3>\n
Visual Studio 2026 added integrated Git worktree management. A worktree gives another branch its own working directory, so you can keep some half-finished C++ changes intact while investigating a bug or preparing a fix on another branch.<\/p>\n
In the Git Repository<\/strong> window, right-click a branch and select New Worktree From<\/strong>.<\/p>\n
\"Context<\/p>\n
You can create a worktree from an existing branch, a new branch, or a commit, then open it in the current window or a separate Visual Studio instance. Worktrees appear alongside branches and can be removed from the same window when they are no longer needed.<\/p>\n
\"The<\/strong><\/h2>\n
Manage submodules without leaving Visual Studio<\/h3>\n
Submodules are also first-class objects in Visual Studio 2026. The Git Repository<\/strong> window has a dedicated Submodules<\/strong> section, Git Changes<\/strong> shows their state, and the repository picker displays the relationship between the parent repository and its submodules.<\/p>\n
You can add, update, remove, discover, and navigate submodules in the IDE. They are read-only by default, which helps prevent accidental edits to a dependency. To work inside them, go to Tools > Options > Source Control > Git<\/strong>, find Automatically activate multiple repositories<\/strong>, and select Yes, include submodules<\/strong>.<\/p>\n
\"Repository<\/p>\n
Other Git improvements include a multi-file summary diff for working changes, commits, and pull requests, comparison of a historical file version with the working tree, pull-request activity timelines, and automatic completion after required approvals and policies pass. Read the Visual Studio August update<\/a> for the full set.<\/p>\n
Debug C++ applications<\/h2>\n
Attach to processes in Podman containers<\/h3>\n
Visual Studio 2026 extends Attach to Process<\/strong> to Podman containers. Start the container, open Debug > Attach to Process<\/strong>, choose Podman<\/strong> as the connection type, select Find<\/strong>, and then choose the process you want to debug. The experience supports both .NET and C++ containers without additional debugger configuration.<\/p>\n
Investigate bugs with focused tests<\/h3>\n
The Debugger Agent has also added a test-driven investigation workflow. Starting from an issue, stack trace, or intermittent failure, it can create or identify a focused test, debug through the failure using runtime state, propose a fix, and rerun relevant tests. This builds on the agentic issue-to-resolution experience covered in the previous roundup. See The Visual Studio Debugger Agentic Workflow Gets a Test-Driven Upgrade<\/a> for details.<\/p>\n
More control over Copilot<\/h2>\n
Share instructions and custom agents across an organization<\/h3>\n
Visual Studio 2026 added organization-level instructions and custom agents. GitHub organization and enterprise owners can publish shared agents for workflows such as build triage, dependency upgrades, portability checks, or code-review conventions. Visual Studio detects those agents and identifies their organization source in the agent picker. Organization-level instructions can express shared preferences, but they are not a policy-enforcement mechanism. If you\u2019re an administrator, see Preparing to use custom agents in your organization<\/a> or Preparing to use custom agents in your enterprise<\/a>.<\/em><\/p>\n
Choose the right model and thinking effort<\/h3>\n
Model controls also provide more information about capabilities, context-window size, and cost. For supported models, you can choose low, medium, or high thinking effort. Lower effort suits straightforward questions, while higher effort can help with architecture, difficult template diagnostics, algorithms, or hard-to-reproduce concurrency issues.<\/p>\n
Bring your own model<\/h3>\n
Bring Your Own Model (BYOM)<\/strong> lets you connect that agent to a Microsoft Foundry deployment or use your own key with another supported provider, whether or not you are signed in to GitHub. The release notes also refer to this capability as Bring Your Own Key (BYOK)<\/strong>.<\/p>\n
BYOM is available as a preview and supports Microsoft Foundry, OpenAI, Anthropic, and Ollama, including custom endpoints for OpenAI and Ollama. Model capabilities vary, and not every model supports every Agent Mode tool. Read Bring Your Own Model in Visual Studio<\/a> for setup, provider, and governance details.<\/p>\n
Next Edit Suggestions Improvements<\/h3>\n
Long-distance next edit suggestions<\/strong> are now available. Copilot can suggest related edits elsewhere in the active file when Extended range suggestions<\/strong> are enabled under Tools > Options > Text Editor > Inline Suggestions<\/strong>.<\/p>\n