Visual Studio 2026 release notes

We're excited to announce the availability of the Visual Studio 2026 May update. This release marks the beginning of a new era for Visual Studio with deep platform integration of AI, stronger fundamentals, and improved performance.

Download Visual Studio 2026 to enjoy these new features and improvements.

May Update 18.6.0

Released on May 12, 2026.

IDE

System dark/light themes ^📣

Automatically switch Visual Studio themes when your system moves between Light and Dark mode, keeping your IDE in sync with your environment.

You might prefer a lighter, higher-contrast theme during the day and a darker theme at night. Visual Studio now automatically switches between your selected Light and Dark themes when your system setting changes, keeping your IDE in sync with your environment.

How to use it

1. Open Tools → Options → Environment → Visual Experience
2. Set Color theme to Use system setting
3. Select a System Light theme and a System Dark theme

Visual Studio automatically applies the matching theme when you change your Windows theme.

📣 See feature ticket to share your feedback and continue the conversation.

GitHub Copilot

View and manage Agent Skills

Browse, edit, and locate all your Copilot Agent Skills from the chat window.

You can now view all your Agent Skills in one place. By clicking the tools icon on the bottom right corner of your chat window, you can open a dedicated skills panel that lists every skill discovered from your workspace and user profile, making it easy to see what's available at a glance.

From the panel, you can manage skills directly without leaving Visual Studio:

• Edit a skill - click the three-dot menu (⋯) on any skill to open and edit it directly in VS.
• Open file location - use the same menu to jump straight to the skill file on disk.
• Search a skill - use the search bar at the top to quickly find a specific skill by name or keyword.

This builds on the Agent Skills support introduced earlier, giving you a more user-friendly way to browse and maintain your skills. Try it out and share your feedback!

Multi-file summary diff for Copilot changes

Review all Copilot changes across multiple files in a single summary view with granular accept and undo controls.

When Copilot edits multiple files, you don't need to review each one separately anymore. The new multi-file summary diff view shows all changes in one place.

Click the Open Changes Summary button in the Copilot Chat working set after Copilot finishes editing. You'll see a single tab with all changed files and their diffs together.

You can accept or undo changes at different levels:

• Across all files at once
• On a per-file basis
• Per individual diff chunk

You can also open any file separately to see its full context.

Use the controls in the top-left corner to:

• Collapse all file contents to see only file headers for a quick overview
• Navigate between diff chunks using the next and previous buttons to jump through changes quickly

This view makes it easier to understand what Copilot changed across your codebase and gives you precise control over which edits to keep.

Context window indicator

See how much context Copilot is using and optimize it with one-click summarization.

When you chat with Copilot, it tracks your conversation history, attached files, and other context to give you relevant responses. This is called the context window, and it has a limit. Once it fills up, Copilot may lose track of earlier parts of your conversation.

You can now see exactly how much of that context window you've used with the new context window indicator.

Look for the ring icon in the upper right corner of the Copilot Chat prompt box. This mini donut chart fills up as your conversation grows, showing you at a glance how much context you've consumed.

Click the indicator to see:

• Exact percentage of context used
• Detailed breakdown of what's contributing to the context
• Summarize conversation button to compact your conversation and free up space

When your context is running low, click Summarize to compress earlier parts of your conversation. This lets you keep chatting without losing important context or starting a new conversation.

Plan before you build with Planning mode

Create and iterate on implementation plans before making any code changes.

Sometimes you want to think through an approach before diving into code. The new Planning chat mode lets you collaborate with Copilot on an implementation plan - without making any changes to your codebase.

How it works

When you select Planning mode, Copilot follows a two-step process:

1. Explore and clarify - Copilot uses read-only tools to understand your codebase and asks clarifying questions. For straightforward tasks, it drafts a plan immediately.
2. Draft and refine - Copilot creates a detailed implementation plan that you can review, discuss, and refine together.

When you're ready, click Implement plan to hand it off to Agent mode for execution.

Plans are saved as markdown

Copilot saves every plan as a markdown file in your repo at .copilot/plans/plan-{title}.md. This file is the single source of truth. You can edit it directly in your editor or refine it through chat. Copilot detects your changes and keeps the plan in sync.

When to use Planning mode

• Big features - Break down complex work into clear steps before writing code.
• Unfamiliar codebases - Let Copilot explore and explain before proposing changes.
• Team collaboration - Share plans as markdown files for review before implementation
  

Git tooling

Add commit to Copilot Chat

Attach commit context to Copilot Chat directly from the IDE.

Reviewing a commit and want Copilot's help understanding it, spotting issues, or basing new edits off of it? Instead of hunting down the commit ID and pasting it into Chat, you can now right-click a commit and add it directly as context in Copilot Chat.

You can find this command in the following surfaces:

• Git History (Git > View Branch History)
• File History (Right-click a file in Solution Explorer, then Git > View History)
• Annotate (Blame) (Right-click in the editor, then Git > Annotate (Blame))

You can also multi-select commits to attach several to chat at once.

Copilot receives the commit as context, so you can ask things like explain this change, does this introduce any issues, or write a similar change for this other file.

Commit message instructions moved

Commit message custom instructions now use the Copilot instructions file instead of the Visual Studio setting.

If you've been using the Commit message custom instructions text input under the GitHub → Copilot → Source Control Integration setting to tailor Copilot-generated commit messages, that setting will no longer apply. Going forward, commit message instructions are managed through the Copilot custom instructions file.

This brings commit message instructions in line with how other Copilot custom instructions work across your repository, keeping everything in one place.

Set up custom instructions

Add your commit message instructions to your repository's Copilot instructions file. For full setup details, see Add repository instructions.

C++

Improved optimizations for iterative C++ builds

Improved optimization scenarios for C++ builds when GitHub Copilot build performance for Windows finds potential improvements that may only be visible in iterative builds.

When using GitHub Copilot build performance for Windows, Copilot may detect a regression in full rebuild analysis. In these cases, Copilot now reruns a comparable incremental build to better reflect real-world gains from optimizations such as precompiled headers and header refactoring, which can appear slower in rebuilds but improve your day-to-day workflows.

@BuildPerfCpp in GitHub Copilot chat to optimize your build time" />

GitHub Copilot build performance for Windows

GitHub Copilot build performance for Windows uses Build Insights to identify and fix build performance issues in C++ projects using MSVC. By analyzing your build process, this agent suggests optimizations and implements changes to reduce build times:

1. Reduce header parsing time by creating precompiled headers and optimizing include paths, such as removing unused includes.
2. Refactor functions to reduce and eliminate function parsing time.
3. Modernize C++ code to use newer language features that improve compilation speed.
4. Optimize build settings to leverage parallel builds and optimal linker settings.

Getting started

1. Make sure GitHub Copilot Agent Mode is enabled in your IDE.
2. Open a C++ project.
3. Ask @BuildPerfCpp in the GitHub Copilot Chat window to optimize your build time.

Note: Build Insights needs to run and collect build performance data. It also requires ETL trace collection permissions. Accept the UAC prompt once to enable Build Insights to collect ETW events from MSVC.

@BuildPerfCpp in GitHub Copilot chat to optimize your build time" />

Segment Heap support for C++

New MSBuild and CMake C++ projects now use Segment Heap by default, helping applications take advantage of modern Windows memory management and security features.

Visual Studio now enables Segment Heap by default for new C++ projects. Segment Heap is a modern Windows heap implementation that improves performance, scalability, and security compared to the legacy NT heap. This change helps applications adopt these benefits and prepares them for future platform capabilities.

You can configure this behavior in project properties under Manifest Tool → Input and Output. Existing projects are not modified automatically but can opt in using the same settings.

MSVC Build Tools v14.51

Improved C++23 support, performance, and many bug fixes.

Microsoft C++ (MSVC) Build Tools version 14.51 is now available and is installed by default with the C++ desktop and gaming workloads. To check if it's installed simply make sure one or both of these components are checked in the installer:

1. MSVC Build Tools for x64/x86 (Latest)
2. MSVC Build Tools for ARM64/ARM64EC (Latest)

You can also select one of the components labelled with the v14.51 version number to pin your installation to this version.

The version number printed by cl.exe and link.exe will be at least 14.51.36231.

The stable release of v14.51 will receive 9 months of servicing fixes, as described in New release cadence and support lifecycle for Microsoft C++ Build Tools .

See below for a complete list of what's new.

C++ Standards Conformance

The frontend team continued implementing CPP23 and CPP20 features and fixing conformance issues:

• C++23 Implementations: Please see the CPP23 Support in MSVC Build Tools 14.51 blog post for details.
• Consteval Improvements: Multiple fixes to consteval function handling, constexpr new/delete in modules, initializer list backing arrays, /experimental:constevalVfuncVtable behavior now enabled by default, and better error diagnostics for failed constant expressions.
• Coroutine Improvements: Coroutine-related globals refactoring, and deprecation of experimental coroutine headers.
• Parser Modernization: Recursive descent parser now handles [[attributes]], with continued improvements to error recovery and removal of legacy token accessors.
• C Language Improvements: Added _Atomic qualifier support, removed incorrect diagnostics for C99 flexible array members, and added __typeof__ support for function types.

Code Generation

The backend optimizer received significant investment across many areas:

• Sample-based profile guided optimizations: Support for sample-based profile guided optimizations with supporting tools. More details to follow in a future blog post.
• Static Single-Assignment (SSA) optimization improvements: Implemented dozens of new algebraic simplification patterns, including ternary operator patterns, arithmetic patterns, and min/max.
• Common Subexpression Elimination (CSE): Improve CSE of loads of [x + C] through if/else joins, redundant stores, and has improved multibyte aliasing checks.
• Scalar Replacement of Aggregates (SROA): More aggressive unpacking of structures.
• Loop Optimizations: Linear Function Test Replace (LFTR) signedness fixes and counted loop optimizations when the primary induction is used after the loop.
• Inlining: Extended limited call-site inlining, and improved propagation of parameter type information when inlining.
• Copy Propagation: Multiple improvements to copy propagation for integer constants and sequential copies.
• Strength Reduction: Implemented reduction of conversions as a strength-reduction optimization.
• Predicate and Jump Threading: Improvements to predicate-based optimizations for eliminating bound checks, including better use of predicates from min patterns.
• Stack Layout: The compiler now prefers pushing callee-saved registers onto the stack over using shadow slots, reducing function prologue/epilogue overhead.
• PGO: Improved per-function size/speed trade-offs to mitigate unrepresentative profiles and PGO trimming improvements.
• Restrict Pointers: Added support for restrict pointer semantics to enable additional aliasing optimizations.
• Pattern matching optimizations: New patterns for MSUB/MADD generation, ADC/SBB for conditional add/subtraction, and CMOVE/NE variants.
• Intel APX: Preview support of Intel APX (Advanced Performance Extensions) in the MSVC toolchain. This support is enabled via the /feature:APX compiler option to target various APX features like Extended General-Purpose Registers (EGPRs), New Data Destination (NDD), No-Flags Update (NF), new conditional ISA and optimized registers save/restore operations. These are documented at https://www.intel.com/content/www/us/en/developer/articles/technical/advanced-performance-extensions-apx.html.

Other code generation changes:

• The /volatileMetadata compiler option is no longer enabled by default for x64 and x86; use /volatileMetadata explicitly to emit volatile metadata.

ARM64 & SVE

• SVE (Scalable Vector Extension) Support: Major new feature bringing ARM SVE to MSVC, including frontend type support for SVE scalar and aggregated types, intrinsic lowering, callee-saved register unwinding, variadic function parameter passing, header file installation, and tryblock/funclet support. Multiple ICE and miscompilation fixes were addressed.
• Shrink Wrapping: Fixed multiple issues including epilog-only fragment unwind info, codegen bugs with chkstk killing X15, and multi-entry shrink wrap regions.
• Code Quality: New patterns for CSEL pow2, 0 + ORR → CSET + ORR_SHIFT, optimized NEON_DUPR, removed redundant NEON_INSR after NEON_DUPR, ARM NEON patterns for x264, instruction fusion improvements, register retyping after globregs, and function alignment tuning.
• DIA SDK: Full SVE support in the debug interface, including RtlpGetSveContextPointers and IDiaStackWalkHelper3.

SIMD & Vectorization

• SLP Vectorizer: Improvements to Superword Level Parallelism (SLP) vectorization:
  • Scalar reduction vectorization
  • Generic and oversized vector instruction support
  • Permute optimizations and oversized select support
• Vectorizer Improvements: Hoisting of vectorized inner loop pointer overlap checks to parent loops, character-count loop support, non-contiguous memory access support for 2-byte data types, and improved low trip count heuristics on ARM64.
• AVX/SSE: AVX512 memcpy/memset, AVX2 memcmp override, AVX10.2, and vectorized bitmasking patterns for x264.

Linker & PDB

• DIA: COM initialization thread safety, and SVE support.
• PDB Fuzzing: Triggered PDB fuzzing from nightly builds.
• SPGO: Sample-based profile guided optimizations available for use.

Standard Library (STL)

On GitHub, the microsoft/STL repo tracks its status with a high level of detail; see the Changelog for MSVC Build Tools 14.51. Notable library features that are newly available:

• P0429R9 - <flat_map>
• P1222R4 - <flat_set>
• P2255R2 - Type Traits To Detect References Binding To Temporaries
• P2590R2 - Explicit Lifetime Management
• P2674R1 - is_implicit_lifetime

Other notable changes:

• We've massively overhauled <regex> to fix long-standing correctness and performance problems that have been present since its initial implementation in VS 2008 SP1. After almost two decades, the stack overflows are finally fixed!
• We've continued to add and improve SIMD-vectorized STL algorithms, using SSE4.2 and AVX2 for x64/x86, and (newly shipping in MSVC Build Tools 14.51) using NEON for ARM64/ARM64EC.
• We've implemented 18 LWG issue resolutions.
• We've removed long-deprecated non-Standard features, such as TR1, <hash_map>, <hash_set>, <experimental/filesystem>, stdext::checked_array_iterator, and stdext::unchecked_array_iterator.

All of this has been possible thanks to our amazing GitHub contributors.

AddressSanitizer (ASan)

• ARM64 Support: Improved ASan for ARM64 support with comprehensive library packaging, interception fixes, and false-positive resolutions.
• SanitizerCoverage: Fixed blocklist handling, codegen issues, and forward declarations to ensure sancov initializers are invoked.
• Performance: Cached walked heaps for performance improvements during shadow memory operations.

Modules & IFC

• IFC Version Update: The MSVC frontend generates IFC files according to the 0.44 version of the IFC specification.
• Concurrency Fix: Fixed a use-after-free race in concurrent IFC debug record resolution.

Static Analysis

• EspX Consolidation: Merged EspX and its extensions like CppCoreCheck into a single DLL, simplifying deployment.
• Bug Fixes: Fixed false positives from inexact location dereference, and a number of internal compiler errors (ICE) under /analyze.

ARM64EC & ARM64X

• Coroutine Support: Fixed missing entry thunks for coroutine outlines and ramp functions.
• ICF: Improved identical COMDAT folding (ICF) optimization in ARM64X binaries.
• Volatile XMM: Fixed ARM64EC volatile XMM assignment.

Diagnostics

• Fixed C4319 not being emitted when compiling C code.
• Removed incorrect diagnostics for C99 flexible array members.
• Warning C4789 improved to reduce false positives.

Debug Info

• Enabled debug info pruning to reduce PDB sizes.

---

Tickets Fixed

The following customer-reported issues were fixed in this release:

• builtin_bit_cast Internal compiler error
• typeof not working with function types
• Must_inspect_result false positive
• statusfp scheduled before floating point operations
• LINK : error LNK2001: unresolved external symbol after upgrading to VS 17.14.5
• REX.B NOP is interpreted as ''XCHG EAX,R8d' by the CPU, but VS 2026 disassembles it as a NOP
• /permissive- and template implies error C3688: invalid literal suffix '_s'
• CPP dynamic debugging initialises static locals incorrectly
• ARM64 - Subtraction and comparison of ULONGLONG's uses W registers
• min/max ternary logic expression broken in combination with integer type promotions
• Error LNK2001 when importing a static class/struct member from a module from a DLL
• Pointer-to-member of base class as template argument
• Deleting of templated class-specific operator new is not detected by constraints
• One can modify a capture in non-mutable lambda via C++ deducing this
• No CopyElision performed when initializing via initializer list
• std::enable_if compile error after updating from 17.13 to 17.14
• Issue in specific conditions with modulo operator in variadic template with '/permissive-' after version 19.32.
• msvc error C1001: Internal compiler error (compiler file 'msc1.cpp', line 1589)
• No ADL in default member initializer due to local free function
• FUNCSIG is empty for an auto lambda assigned to a std::function
• 'warning C5287: operands are different enum types' even with an explicit cast
• C2106 '=': left operand must be l-value Visual Studio 2026 Insiders [11206.111]
• cl: internal compiler error on relatively simple, bit-manipulation code
• Empty compound literal array causes internal compiler error
• error C2593 caused by static operator[] in C++23 mode
• fatal error C1001: Internal compiler error
• Incorrect code generation for &= in 17.14
• Incorrect math result using boost::rational and google test
• Internal compiler error in VS2022 17.10+
• Internal compiler error when trying to compile simple C++ program
• lambda capture nonmovable by reference doesn't work since MSVC17.4
• msdia140.dll ver 14.50.35719.0 CDiaSymbol::get_virtual always returns false
• MSVC 19.44.35207.1 C2352 when calling base class method
• MSVC 19.51 miscompiles ffmpeg for arm64
• MSVC 2026 pointer subtraction of consecutive members of struct with same type leads to unexpected value
• MSVC crashes when there are at least 65536 template parameter in a parameter pack in CTAD
• problems with Visual Stdio 2022 17.14.15 update - LINK : fatal error LNK1000
• v.19.50 x64 optimizer generates incorrect code with /O2 and /EHs
• Visual Studio compiler falsely optimize branch in code under v143 and v145 toolsets
• VS2026 generates incorrect FP code
• Lambda with deducing this parameter of unrelated type is wrongly permitted
• InitAll in VS2026 in initializing a pointer in a vector
• Forward type declaration doesn't work during type specialization if the forward-declared type name is ambiguous
• ICE on CTAD for alias template with std::array
• Internal compiler error when using conditionally-copyable types
• Rejects valid qualified type name involving lambda in decltype
• Silent Bad CodeGen: Regression in Lambda Capture Constant Folding (v143, v145)
• INTERNAL COMPILER ERROR: MSVC V19.50.35615 for x64
• Arm64 optimization bug for expf
• Internal Compiler Error when defining C++17 static data member of template and its constructor takes certain arguments
• CL.exe exited with code -529706956.
• rejects valid operator call
• alias template deduction guide doesn't work in c++20
• An inline friend function template cannot access the template arguments of the class template (C2065)
• Binary left fold expression in return type leads to compilation error
• explicit variable template instantiation causes internal compiler error when using precompiled header
• CLI - inline namespace does not work
• CLI: ::typeid cannot be used on builtin types
• requires requires clause with non-type template parameter inconsistently generates strange compiler error
• consteval fails to compile
• C7602 false positive, constant template parameter constraint bug
• Can't allocate heap memory at compile time
• Cannot forward declare class in internal module partition (C++20)
• Cannot pass one consteval function as an argument to another consteval function
• Cannot use a pointer on immediate function within constant expression
• Class template argument deduction for alias template fails
• Compiler-generated code for certain C++ coroutines give unexpected warnings and refer to negative line numbers
• constant expression is not considered constant in immediate function
• Consteval code does not compile in MSVC
• Error C2100 is incorrect for non-generic lambda expressions
• Error C2514: class template cannot be constructed
• error C7535 due to rvalue reference when a constructor delegates to another constructor
• ICE when indexing into an NTTP multidimensional c-array on MSVC 14.44.35207
• If constexpr and require do not check for the existence of members correctly
• Including a header with #pragma system_header from an external include directory treats the whole translation unit as an external header
• Internal compiler error (ICE) on manipulating with pointer to immediate function
• Internal Compiler Error when specializing on floats
• Making a call on consteval lambda's returned function leads to error C7595
• MSVC fails to compile C++20 template lambda with consteval specifier
• MSVC incorrectly deduplicates two different member pointers (&Case01::a, &Case02::num) passed as auto non-type template parameters
• MSVC rejects valid program involving inheriting conversion function from a closure type with no capture
• No warning C4706 for assignment to std::unqiue_ptr used as a condition
• Removal of placemarker tokens incorrectly removes surrounding whitespace with /Zc:preprocessor
• requires requires constraint on a member function treats a base call like a static call
• Runtime stack corruption reported with std::visit
• source_location() returns wrong value.
• std::is_constructible gives incorrect answer for arrays in C++20
• std::source_information::current() outputs different location in consteval context
• std::source_location::current().function_name() produces empty string when used as default argument value
• Unable to call a consteval function from another one
• Using a dependent qualified name as a default argument for a constraint template type parameter breaks the MSVC compiler
• When ASSERTE is given an expression with '"', it results in internal compiler error
• Wrong error C3640 in getting a pointer on a pure virtual function
• Wrong overload called due to rvalue reference leading to a recursion
• Deduction of class template arguments picks up wrong constructor
• Regression, array access on result on ternary incorrectly returns a prvalue
• 20 modules C1001: Internal compiler error
• Array reference is incorrectly calculated leading to access violation or wrong memory address being accessed
• Cannot partially specialize template across C++20 module
• Failed to specialize function template for abstract type after SFINAE call on type
• Internal Compiler Error Found in MSVC 14.44.35207
• Internal compiler error when when using a bad return type in a template user defined conversion function
• Internal Compiler Error while compiling C++20 coroutine code
• Invalid Operation: FP optimization bug
• Spurious C2102 error initializing static inline constexpr member with partial designated initializer list
• STL hardening checks (_MSVC_STL_HARDENING) are not optimised away (2)
• template function specialization and decltype compiler discrepancies
• VS 17.12 regression, ICE with structured bindings and lambda in constexpr variable template instantiation
• When a throwing expression appears somewhere in a lambda capture list, noexcept(<lambda expression>) gives incorrect result
• VS2026 regression: lambda cannot access local constant
• Spurious compiler error C2872 when building with C++23preview
• CLI & C++23 - multidimensional managed arrays don't work
• #pragma warning(disable) not working in nested headers used with header units
• Anonymous unions in unnamed namespaces are incorrectly required to use static
• Buggy declspec(selectany) constant initialisation across C++ modules
• modules compile error when using a using declaration from a different module
• C2355 is wrongly triggered when local class is defined in a static member function
• C4389 is triggered when comparing a bitfield member of one bit with a bool
• Can not initialize array with consteval constructed elements
• Compiler crashes with C1001 error when using CTAD in a nested type with template dependent noexcept
• Compiler error with constexpr user-defined literals in a requires expression
• CTAD with designated initializer doesn't compile
• Deleted function disables ADL in immediate context
• Enum names publicly imported into class declaration with using-enum-declaration (using enum) are lost across module boundaries
• error C3535: you can't deduce the type for 'auto' from 'overloaded-function'
• error C7595: call to immediate function is not a constant expression
• Error parsing function declaration taking a function pointer and having an empty init list as a default argument
• Extra blank line output with /E and #warning
• False positive warning C4305 when using a defaulted non-type template parameter
• Fold expression fails to expand full pack in nested template after C7515 fix
• Function Specialisation and Concepts Causes an Ambiguous Call to Overloaded Function
• ICE using Boost.PFR with CPP modules (vs-17.14.0-preview1)
• ICE while compiling mp-units
• ICE with modules and if consteval
• ICE with template deduction guide
• ICE: writer.cpp:542 the impossible happened when using folly + modules
• identifier not found in nested fold expression
• In msvc V145, the BUG triggered when using intra-class members in constraints in templates within classes
• Interaction between no_unique_address and has_unique_object_representations is incorrect
• Internal compiler error when linking c++20 module
• Internal compiler error when using CPP modules
• Internal compiler error. (compiler file 'D:\a_work\1\s\src\vctools\Compiler\CxxFE\sl\p1\c\trees.c', line 19104)
• Mixins pack fold expressions error
• MSVC : Nested struct depending on outer class template parameters fails as NTTP within the class scope (C2993)
• MSVC fails to compile (working) code involving template metaprogramming
• Nested lambdas errors out in msvc with labeled structured binding
• Note that follows warning C4477 is inaccurate for size_t, redux
• Overload resolution fails for enum non-type template parameters
• Parameter pack with reference to C array issue
• Unable to deduce argument type to std::optional
• Unions are not layout-compatible despite containing layout-compatible data members
• Universal CL.exe Crash (Exit Code -1073741819) with Nested std::filesystem::path in C++17+
• The destructor is private, but compiler allows create an object on stack.
• Apparent C++ parser bug - emits C2143 + C2451 (+ optional C2530 + C3531) if range-for expression inside a template function contains a lambda
• C3520 when expanding template parameter pack in a member function template of a class template
• Can't use templated alias instance if the parser first sees the instantiation of the alias in a template class
• Internal Compiler Error in latest versions of MSVC when compiling specific fold expression
• Internal compiler error involving member function pointer, multiple inheritance and constexpr passthrough function.
• Internal Compiler Error with Lambda and Constexpr Reference in Visual Studio 2026 ( CL.exe Version 19.50.35722 for x64 )
• Lambda cannot access local constant
• MSVC 14.50.35503 Internal Compiler Error [Visual Studio 2026 Insiders]
• Overload resolution failing with a class template specialization
• Regression (Compile Error) when using modules and fmtlib
• Incorrect result when struct contains a [[no_unique_address]] member
• Using an initializer list as a template argument when an incompatible overload exists results in error C2440
• Warning C4864 incorrectly raised when calling overridden non-template member functions of the template base class
• IntelliSense and the compiler complain about the wrong variable being const
• Ternary operator does not propagate temporary operand to the resulting rvalue reference.
• Using an elaborated-type-specifier to refer to an enum whose underlying type is not int results in errors C3432 and C3433
• MSVC incorrectly warns that C99 flexible array members are a nonstandard extension (zero-sized arrays)
• ARM64 /EHa incorrect code motion
• ARM64 issue with static initializers and destructors and /OPT:ICF
• ARM64EC: Crash when calling C++ function in DLL containing OpenMP pragmas, from C# app through DllImport
• arm64x forwarding dll does not support DATA
• ASAN_VCASAN_DEBUGGING is broken in 17.14.3 Preview 1.0
• Bitfields with a bool type at the beginning are broken in C mode
• Compiler crash with fabsf in loop with optimization (/O2 /Ob /Ot) and /fp:precise
• constexpr pointer subtruction incorrect result
• Dynamic Debugging Null String Literals
• CLI C2668 Ambiguous Call in .NET 9 and later
• CLI rethrowing .NET exception crashes with .NET Framework 4.8 in x64
• C1001: Internal compiler error with 64-bit optimized builds of recent VIM using VS 17.14
• C1090: PDB API call failed, error code '3'
• C2034 (about overwide bit-fields) shouldn't be an error in C++ modes
• C4319 not emitted when compiling C code
• C4756 related issues in VS 2022
• colocated locals/parameters with overlapping lifetime 14.40.33814 and newer
• CTime throws error in timezones behind GMT. Changes in VS 15.8 produced a regression
• CTime::CTime fails with year 1900
• Dangling pointer in cpp file atlmfc Visual Studio occsite.cpp
• Default member initializers for bit-fields doesn't work when importing struct (or class) from a module
• Erroneous warning C5061: the use of a comma operator as a subscript expression has been deprecated
• EXE compiled with ASAN (and ASAN libs and DLLs sometimes hangs during exit
• Failure to optimize redundant DUP, SMOV sequence (ARM64)
• Fatal error C1001: Internal compiler error
• GC collects during method call on c++/cli ref class
• Guarded_by_ on a static local variable reports an annotation syntax error
• Illegal code is accepted due to rvalue reference leading to a recursion
• Improper concatenation of Unicode string literals
• Incorrect Code writing bitfield
• Incorrect initialization of nested aggregate member with unrelated member's value
• Incorrect instructions generated in AVX2
• Incorrect switch-case generation on arm64 target
• Incorrect template argument deduction for function called with argument this from out-of-line, ref qualified member function.
• Internal compiler error for ternary expression with non copyable type and throw
• internal compiler error in msvc 14.50.35717
• Internal compiler error in type_traits and operator bool in derived class
• Internal Compiler Error targeting ARM64 with VS 2026 18.0 Insiders
• Internal compiler error when enabling Code Analysis (/analyze) with variadic templates + SAL
• Internal compiler error when using OpenMP and try/catch in same function with /clr enabled
• Internal Compiler Error with C/C++ Optimizing Compiler Version 19.50.35710 for ARM64
• Internal Compiler Error with C/C++ Optimizing Compiler Version 19.50.35722 for ARM64
• Internal Compiler Error with C++ template template parameters and missing template keyword
• KASAN drivers fail to link referencing wide string functions (wcscat, wcscpy, wcsncpy)
• Keywords MUST NOT be translated in errors, warnings or suggestions.
• lambda-nested decltype of lambda triggers C2011
• Linker shouldn't warn for differing Arm64EC 'icall push thunks' that are equivalent
• Long octal formatted strings DoS the user's machine and cause C1060
• MFC static lib reports memory leak
• Microsoft.VCToolsVersion.v143.default.txt in 17.2 is not updated from 17.1
• Miscompilation of svset_neonq (arm_neon_sve_bridge.h) with 19.50.35722 for ARM64
• Miscompilation of AArch64 SVE loop (Version 19.50.35722 for ARM64)
• Missing destructor call when /Zc:nrvo is enabled (/O2 and /std:c++20)
• Misuse of _BitScanForward result can crash the compiler
• Modules: using-declarations leak from exported functions
• MSDIS is incorrectly decoding some xchg instructions as nop
• MSVC fails to bind a noexcept function to template instantiated with a noexcept signature
• MSVC fails to generate INCP (and friends) - Version 19.50.35722 for ARM64
• MSVC fails to generate MLA/MAD (Version 19.50.35722 for ARM64)
• MSVC fails to optimize LASTA idiom (Version 19.50.35722 for ARM64)
• MSVC generates an incorrect C6001 warning
• MSVC x64: _mm_shuffle_ps incorrectly optimized away after vcvtpd2ps at /O1 or /O2
• New CPP Dynamic Debugging feature occasionally causes link error 1136
• noexcept deduction is not working (CWG 2355)
• Not implemented mandatory copy elision in ternary operator
• Observing non-deterministic output when building UCRT for CHPE builds
• Optimisation is missed during UB-safe negation
• Performance regression on hash calculation with custom hash function when switching to msvc 17.14.7
• PGO instrumentation runtime crash on ARM64
• Placement operator new[] in <vcruntime.h> should be marked _MSVC_CONSTEXPR
• Poor x64 code generation for range for loop on member array
• Raw string literals have a limit of ~16380 characters
• SAL2 analyzer fails to handle shared_locks for Guarded_by annotation
• Sanitizer Coverage Blocklist Broken
• Sanitizer Coverage Produces Bad Codegen for C++ binaries
• SIMD Code optimization bug
• specialization of static template function requires static to be specified; clang warns it should not
• SSA CSE conflates different pointers
• Standard Library Modules: Random number machinery emits bogus error C2512
• Static local thread epoch has incorrect TLS offset when using /dynamicdeopt, resulting in crash
• std:c17 and unsized arrays != LOVE
• string literal concatenation with different encoding prefixes fails
• template function not found
• Ternary operator unnecessarily requires copy constructor
• Unexpected error C7595 reported
• Unexpected result while compiling consteval function
• Unused compile-time constant in x64 release build causes access violation in compiler during linking stage
• Using 17.14 toolset one of our projects generates a LNK1120 link error
• VCPP 17.6 preview 1 ARM64EC compiler ICEs when it encounters __vectorcall keyword
• VisualCppTools.14.50.35724 PdbCopy.Exe Arm64 Pdb Copy Crashes
• Volatile local variable is assumed to not change on x64
• Volatile variable not read after write
• VS 17.14.13 Bad codegen for x64 SIMD register not set up correctly
• VS18.0 Insiders MSVC ICE in MFC message map of a class with virtual base
• vs2022 optimization error
• VS2026 MSVC Warning C4865 lies about underlying type change with /Zc:enumTypes
• Windows SDK is missing #include <utility> in atlcom.h
• x64 compiler crash while compiling Mesa source file with optimizations
• x64 Emulator crash when an ARM64EC thread calls an x64 coroutine that calls another ARM64EC coroutine
  

Top bug fixes	From the community
ARM64 /EHa incorrect code motion	Feedback ticket
[Regression] arm64 specific crash in MSVC 19.50.35728 for ARM64	Feedback ticket
Fix decltype of a parenthesized, mutable member inside a const-qualified member function.
Correct an issue causing error C2106 when certain ternary expressions are used on the LHS of an assignment
Fix a false C2106 error in certain initializations involving array-type members.	Feedback ticket
Updating the installer to include the latest servicing release of the 10.0.26100 Windows SDK (10.0.26100.8249) and the 10.0.28000 Windows SDK (10.0.28000.1839)

Version 18.5.3

Released on May 12, 2026.

Security advisories addressed	CVE	Description
SQLite Memory Corruption Vulnerability	CVE-2025-6965	There exists a vulnerability in SQLite versions before 3.50.2 where the number of aggregate terms could exceed the number of columns available. This could lead to a memory corruption issue.
.NET Core Tampering Vulnerability	CVE-2026-32175	A tampering vulnerability exists when .NET Core improperly handles specially crafted files.
.NET Elevation of Privilege Vulnerability	CVE-2026-32177	Heap-based buffer overflow in .NET allows an unauthorized attacker to elevate privileges locally.
.NET Elevation of Privilege Vulnerability	CVE-2026-35433	Improper input validation in .NET allows an unauthorized attacker to elevate privileges locally.
ASP.NET Core Denial of Service Vulnerability	CVE-2026-42899	Loop with unreachable exit condition ('infinite loop') in ASP.NET Core allows an unauthorized attacker to deny service over a network.

Version 18.5.2

Released on April 28, 2026.

Top bug fixes	From the community
[After upgrading to 18.5] Keyboard input may stop responding after using Find in Files	Feedback ticket
Latest install of VS 2026 Insiders (11709.129) is removing 14.50 build tools	Feedback ticket
Claude Opus 4.7 stopped working after the last update	Feedback ticket
[C++] Bad codegen for switch(*optional) in 64 bit in Visual Studio 2026	Feedback ticket

Security advisories addressed	CVE	Description
ASP.NET Core Elevation of Privilege Vulnerability	CVE-2026-40372	Improper verification of cryptographic signature in ASP.NET Core allows an authorized attacker to elevate privileges over a network.

Version 18.5.1

Released on April 21, 2026.

Top bug fixes	From the community
F# Empty string matching in code quotations causes FS045	Feedback ticket
Adding UI to show model thinking process	Feedback ticket

April Update 18.5.0

Released on April 14, 2026.

IDE

JSON editor schema updates

JSON editor updated to support more JSON schema features.

The JSON editor now supports newer JSON Schema specifications, giving you access to modern schema features like $defs, $anchor, and improved vocabulary support.

Previously, the editor only supported JSON Schema Draft 4 and Draft 7. You can now use:

• JSON Schema Draft 2019-09
• JSON Schema Draft 2020-12

This means better IntelliSense and validation when working with schemas that use the latest specifications.

GitHub Copilot

Use agent skills ^📣

Copilot agents in Visual Studio now automatically discover and use skills defined in your repository or user profile.

Copilot agents in Visual Studio can now automatically discover skills. Agent skills are reusable instruction sets that teach agents how to handle specific tasks, like running a build pipeline, generating boilerplate, or following your team's coding standards. Define a skill once to save time and keep behavior consistent across your workflow. See awesome-copilot for community examples.

Skills are discovered from these locations:

• Workspace or project skills (stored in your repository): .github/skills/, .claude/skills/, .agents/skills/.
• Personal skills (stored in your user profile): ~/.copilot/skills/, ~/.claude/skills/, ~/.agents/skills/.

To create a skill:

1. Create a .github/skills/ directory for a workspace skill or a ~/.copilot/skills/ directory for a personal skill.
2. Create a subdirectory for your skill. Give each skill its own directory (for example, .github/skills/github-issues/).
3. Create a SKILL.md file in that directory. Follow the agentskills.io/specification format.
4. Optionally, add scripts, examples, or other resources to the skill directory.

After you create a skill in one of these directories, the agent decides when to use it. When a skill is active, it appears in chat so you know it's being applied.

More user-friendly flows for browsing and creating skills in Visual Studio are coming in upcoming releases. Try Agent Skills and share your feedback.

📣 See feature ticket to share your feedback and continue the conversation.

Cloud agent integration

Start new cloud agent sessions directly from Visual Studio.

Cloud agents, including Copilot coding agent, run on remote infrastructure for scalable, isolated execution. You can now start new cloud agent sessions directly from Visual Studio.

To try it, select Cloud from the agent picker in the Chat window, then share the work you want help with. The cloud agent first asks for permission to open an issue in your repository, then creates a pull request to address it. While it prepares the PR, you can keep working on other tasks in Visual Studio, or close Visual Studio and come back later. When the PR is ready, you'll get a notification and can review it in Visual Studio or in your browser.

Cloud agent in Visual Studio is currently powered by Copilot coding agent. To use it, make sure you're in a GitHub repository and that Copilot has permission to create issues in that repository. Try it out and let us know what you think.

Build your own custom agents ^📣

Define custom agents tailored to your team's workflow using .agent.md files in your repository or user profile.

Custom agents help you build specialized Copilot agents for your team's workflow. They can use workspace awareness, code understanding, tools, your selected model, and MCP connections to external knowledge sources such as internal documentation, design systems, APIs, and databases.

Custom agents are defined as .agent.md files in your repository or user profile. Workspace or project-specific agents are stored under .github/agents/ in your repository. For example:

your-repo/
└── .github/
    └── agents/
        └── code-reviewer.agent.md

User-level agents are stored in %USERPROFILE%/.github/agents/ by default. You can change this location in Tools → Options → Copilot Chat → Custom agents user directory.

To create a custom agent, either create a .agent.md file directly in one of the locations above, or click the + button in the agent picker and follow the prompts.

After you create a custom agent, it appears in the agent picker so you can use it anytime.

A few things to note:

• If you don't specify a model, the agent uses the model currently selected in the model picker.
• Tool names vary across GitHub Copilot platforms - check the tools available in Visual Studio to make sure your agent works as expected.
• The awesome-copilot repo has community-contributed agent configurations you can use as starting points. Verify tool names before you use them in Visual Studio.

📣 See feature ticket to share your feedback and continue the conversation.

Customizable Copilot keyboard shortcuts ^📣

Customize the keyboard shortcuts for accepting Copilot inline suggestions.

You can now customize the keyboard shortcuts for accepting Copilot inline suggestions. You can change the key for accepting a full suggestion, the next word, or the next line in standard keyboard settings.

To set your preferred shortcuts:

1. Go to Tools → Options → Environment → Keyboard.
2. Search for the command you want to customize:
   • Edit.AcceptSuggestion
   • Edit.AcceptNextWordInSuggestion
   • Edit.AcceptNextLineInSuggestion
3. Remove the existing key binding.
4. Assign a new shortcut under the Inline Suggestion Active scope.

For example, the image below changes the default accept shortcut from Tab to Ctrl+Tab. The new shortcut appears throughout the hint bar.

📣 See feature ticket to share your feedback and continue the conversation.

IntelliSense takes priority over Copilot ^📣

IntelliSense now takes priority over Copilot completions so you only see one suggestion at a time.

We heard your feedback: seeing IntelliSense and Copilot completions at the same time can be distracting. The editor now prioritizes the IntelliSense list and shows only one suggestion at a time.

When IntelliSense is active, Visual Studio temporarily suppresses Copilot completions so you can focus on your current selection. After you dismiss or commit the IntelliSense selection, Copilot completions resume. This behavior is now enabled by default. Update your VS to the latest version and code as you normally do. Please let us know any feedback you have!

📣 See feature ticket to share your feedback and continue the conversation.

New chat history panel ^📣

Browse and navigate your Copilot chat sessions with the new chat history panel.

The chat history experience has moved from a simple dropdown to a dedicated panel. You now see each chat title, a preview of the latest message, and when the session was last updated, so you can quickly find and reopen past conversations.

More chat history management capabilities are on the roadmap. We'd love your feedback, so please file a ticket on Developer Community and tell us what you want to see next.

📣 See feature ticket to share your feedback and continue the conversation.

Debugging & diagnostics

Auto-Decoding in Text Visualizer

Easily decode text with Copilot.

We are introducing the Auto-detect and format feature within the Text Visualizer. This enhancement is designed to streamline your debugging workflow by automatically identifying the encoding or compression format of a string and applying the necessary transformations in a single click.

Simply click the Auto-detect and format button in the top-right of the Text Visualizer. Powered by Copilot, this feature instantly identifies and converts complex data (like GZip-compressed Base64) into readable text removing the need for manual decoding or external tools.

Agentic Issue to Resolution

Agentic Bug Resolution helps you find and fix bugs with runtime-proofed, interactive AI guidance.

We are introducing a new Debugger Agent workflow in Visual Studio that validates bugs against real runtime behavior instead of relying on static analysis guesses. The experience walks you through a complete agentic loop from understanding and reproducing the issue, to instrumenting the application, isolating the root cause, and validating the fix through live execution.

You can start from an issue in GitHub or Azure DevOps, or simply describe the bug or code behavior in natural language. The Debugger Agent uses this input to map the problem directly to your local source and guide you through resolution. Unlike static approaches, you can interact with the agent during the debugging process to provide more input, discuss your theory, or refine the fix in real time.

How the agentic loop works:

• Context Injection – Provide an issue link or describe the bug in Debugger Mode in Copilot Chat (you can switch modes using the dropdown in the lower-left corner of the chat). The agent connects the report to your local code.
• Autonomous Reproducer – The agent analyzes the bug description and, if reproduction steps are missing, creates a minimal scenario to trigger the failure automatically.
• Hypothesis & Instrumentation – It generates failure hypotheses and instruments your app with tracepoints and conditional breakpoints to capture runtime state.
• Runtime Validation – The agent runs the debug session and analyzes live telemetry to isolate the root cause.
• Targeted Correction – It suggests a precise fix at the exact failure point rather than broad refactoring.
• Final Human Validation – You rerun the scenario and confirm the fix in the live environment alongside the agent.
  

C++

C++ code editing tools for agent mode

C++ Code Editing Tools for GitHub Copilot Agent Mode are now available by default.

We're excited to share that C++ Code Editing Tools for GitHub Copilot Agent Mode are now generally available by default. These tools help Copilot navigate your C++ codebase more effectively when refactoring or modifying code.

With these tools enabled, Copilot can:

• Map out class inheritance hierarchies
• Follow function call chains

To get started:

1. Open a C++ project and ensure IntelliSense is configured.
2. Enable specific tools using the Tools icon in Copilot Chat.

Once enabled, Copilot uses these tools automatically when answering questions or suggesting code changes.

For best results, use AI models that support tool-calling. Learn more at AI model comparison - GitHub Docs

Top bug fixes	From the community
VS 2026 hangs while unloading projects	Feedback ticket
Copilot terminal sometimes does not start queued commands until the terminal tab is brought to the foreground	Feedback ticket
ASan supression does not work
Improved ASan runtime performance in applications that heavily utilize COM, mixed language bindings, and Win32 allocator API's

Version 18.4.4

Released on April 14, 2026.

Security advisories addressed	CVE	Description
.NET Denial of Service Vulnerability	CVE-2026-26171	A vulnerability exists in EncryptedXml class where uncontrolled resource consumption can give an attacker to the ability to perform a Denial of Service attack.
.NET Spoofing Vulnerability	CVE-2026-32178	Improper neutralization of special elements in .NET allows an unauthorized attacker to perform spoofing over a network.
SQLite Memory Corruption Vulnerability	CVE-2025-6965	There exists a vulnerability in SQLite versions before 3.50.2 where the number of aggregate terms could exceed the number of columns available. This could lead to a memory corruption issue.
Visual Studio Information Disclosure Vulnerability	CVE-2026-32631	An information disclosure vulnerability exists in MinGit due to NTLM hash leak to untrusted server.

Version 18.4.3

Released on March 31, 2026.

Top bug fixes	From the community
Copilot chat fails with invalid_request_body: github_push_files schema requires additionalProperties=false	Feedback ticket
Fix to Visual Studio crash when VS project is loaded

Version 18.4.2

Released on March 24, 2026.

Top bug fixes	From the community
Fix proxy support page for Visual Studio 2026	Feedback ticket

Version 18.4.1

Released on March 17, 2026.

Top bug fixes	From the community
VS repeatedly need to refresh credentials when logging into a GitHub account with Copilot license	Feedback ticket
Devenv command-line switches /Run on /Runexit not working	Feedback ticket
Fix AddressSanitizer compatibility issue with Xbox Game OS	Feedback ticket
Add support for Agent Skills for Copilot's agent mode

March Update 18.4.0

Released on March 10, 2026.

IDE

JSON editor improvements

JSON editor now a part of the Core Editor.

Improvements in the JSON Editor

JSON Editor installed with the Core Editor

In previous releases in order to get the JSON editor you were required to install the Web Development workload. With this release, the JSON editor is now included in the Core Editor, so you can get JSON editing capabilities without needing to install the full Web Development workload. This change allows for a more streamlined installation experience for users who need JSON editing features but do not require the full set of web development tools.

Productivity

HTML rich copy/cut

Copy and cut code snippets with rich formatting.

Visual Studio now supports HTML clipboard format when cutting or copying code from the editor. You can paste colorized code into web versions of Office apps, Azure DevOps work items, or other HTML-based controls.

This feature maintains syntax highlighting and formatting when you paste code into HTML-based applications, making it easier to share and present code snippets. It's turned on by default. To customize it, go to Tools → Options → Text Editor → Advanced where you can check or uncheck Copy rich text on copy/cut and set the max length.

GitHub Copilot

Build your own custom agents ^📣

Define custom agents tailored to your team's workflow using .agent.md files.

Custom agents let you build specialized Copilot agents tailored to your team's workflow. They have full access to workspace awareness, code understanding, tools, your preferred model, and MCP connections to external knowledge sources like internal documentation, design systems, APIs, and databases.

Custom agents are defined as .agent.md files in your repository. For example,

your-repo/
└── .github/
    └── agents/
        └── code-reviewer.agent.md

Successfully created custom agents will appear in the agent picker for your use at any time.

A few things to note:

• If you don't specify a model, the agent uses whatever is selected in the model picker.
• Tool names vary across GitHub Copilot platforms - check the tools available in Visual Studio to make sure your agent works as expected.
• The awesome-copilot repo has community-contributed agent configurations you can use as starting points. Verify tool names before using them in VS.

📣 See feature ticket to share your feedback and continue the conversation.

Find_symbol tool for agent mode

New Find_symbol tool for GitHub Copilot Agent Mode helps you access symbol information across your codebase.

We're introducing the new find_symbol tool for GitHub Copilot agent mode, bringing language-aware symbol navigation directly to the agent. The find_symbol tool lets you:

• Find all references to symbols across your project
• Access metadata like type information, declarations, and scope

Once you enable the tools, Copilot uses them automatically when answering your questions or suggesting code changes.

Supported languages include C++, C#, Razor, and TypeScript, plus any other language for which you have a supported Language Server Protocol (LSP) extension installed.

For best results, write clear prompts and use AI models that support tool-calling. Learn more at AI model comparison - GitHub Docs

Enterprise level MCP governance

Easily safeguard your data with enhanced MCP governance features.

MCP server usage in Visual Studio now respects allowlist policies set through GitHub. Admins can specify which MCP servers are allowed within their organizations.

When an allowlist is configured, you can only connect to approved MCP servers. If you try to connect to an unauthorized server, you'll see an error message explaining the server isn't allowed.

This helps organizations control which MCP servers process sensitive data and maintain compliance with security policies.

Debugging & diagnostics

Smart Watch Suggestions

Copilot now suggests context-aware expressions in Watch window.

Copilot now offers context-aware suggestions directly in Watch windows. Just place your cursor in the text box, and Copilot suggests relevant expressions based on your current debugging context.

This speeds up watch creation, reduces guesswork, and helps you monitor the most meaningful runtime values - making your debugging workflow faster and more precise.

Profile Tests with Copilot

Easily profile a test with Copilot.

We've added a new Profile with Copilot command to the Test Explorer context menu, making it easy to profile a specific test with just a click.

When selected, the Profiling Agent automatically runs the chosen test and analyzes its performance, combining CPU usage and instrumentation data to deliver actionable insights.

By default, the command uses Instrumentation profiling and is currently supported in .NET. If deeper analysis is needed, you can launch the selected test directly from the Copilot chat window and choose additional profiling tools.

Perf tips powered by live profiling

Debug-Time Performance Tips with Profiler Agent.

Performance optimization now happens while you debug, not after. Debug-time Perf Tips and Profiler Agent let you analyze performance instantly as you step through code, giving you actionable insights right when you need them.

As you step through code, Visual Studio shows execution time and performance signals inline for each step. When you spot a slow line or method - like a sluggish LINQ query, a calculation-heavy helper, or any step that takes longer than expected - just click the Perf Tip and ask Copilot for optimization suggestions on the spot.

Profiler Agent automatically captures runtime data during debugging: elapsed time, CPU usage, and memory behavior. Copilot uses this data to pinpoint performance hot spots and suggest targeted fixes, keeping optimization part of your regular debugging workflow instead of something you tackle later.

.NET

Fix vulnerabilities with Copilot

Fix NuGet package vulnerabilities precisely and easily with Copilot.

Fix NuGet package vulnerabilities effortlessly with Copilot directly from Solution Explorer. When Copilot detects a vulnerability, you'll get an immediate notification. Click through, and Copilot automatically resolves it with the right dependency updates.

No more manual vulnerability research or hunting down the correct package versions. Copilot analyzes the vulnerability and recommends targeted fixes that keep your dependencies secure without disrupting your workflow. You address security issues right when they're discovered - not later.

This integrates security directly into your daily work. Spend less time on vulnerability triage and more time building with confidence.

C++

MSVC Build Tools version 14.51 Preview

Microsoft C++ (MSVC) Build Tools version 14.51 Preview is now available for C++ developers.

The first Microsoft C++ (MSVC) Build Tools version 14.51 Preview is now available for C++ developers. This release includes several new features and runtime performance improvements. We encourage you to explore MSVC previews to adapt to breaking changes and report issues early. MSVC previews do not receive servicing patches and thus should not be used in production environments.

Installing MSVC Build Tools v14.51 Preview

To install, select either MSVC Build Tools for x64/x86 (Preview) or MSVC Build Tools for ARM64/ARM64EC (Preview), depending on your target architecture, from the Visual Studio Installer. You will find these components under the Desktop development with C++ workload as well as the Individual components tab.

Under Individual components, you can additionally install Spectre-mitigated libraries, MFC, ATL, or C++/CLI support for MSVC v14.51 Preview.

Compiler front-end

MSVC is making progress with C++23 conformance and 133 Developer Community bugs have been fixed. More details will be shared in a future blog post and release notes.

Compiler back-end

MSVC Build Tools version 14.51 improved runtime performance compared to v14.50 on the SPEC CPU 2017 benchmark suite by the following amounts in different build scenarios:

• +6.5% Integer, Arm64, PGO
• +1.1% Floating Point, Arm64, PGO
• +4.4% Integer, Arm64, VS Defaults
• +1.4% Floating Point, Arm64, VS Defaults
• +5.0% Integer, X64, PGO
• +1.9% Floating Point, X64, PGO
• +4.3% Integer, X64, VS Defaults
• +1.8% Floating Point, X64, VS Defaults

Optimization improvements:

• Improved the SLP vectorizer to consider more alternatives, such as using partial vectors or using a vector size larger than the target width before mapping to the target vector width later.
• Improved SROA's handling of indirect accesses, larger structs, and typecasts.
• Allowed the loop vectorizer to hoist runtime checks.
• Added elimination of logical-OR short-circuiting when safe.
• Improved usage of conditional move instructions.
• Better optimization of AVX vector intrinsics.
• More aggressive inlining by default for functions with few uses.
• Better inline expansion of memset/memcpy for AVX.
• Improved copy propagation across block boundaries.
• Added unrolling of outer loops and loops with multiple exits.

Standard library updates

• A full list of MSVC Build Tools v14.51 standard library changes can be found in the STL Changelog. The changelog tracks everything merged to microsoft/STL main, though very recently merged changes may not yet be reflected in this particular preview. Those changes will still be reflected in future previews or the final 14.51 release.

AddressSanitizer

• Improved the quality of our experimental ASan ARM64 support by fixing several code generation and runtime issues.

Known issues

Issue #1: There is a bug configuring CMake targets using the Visual Studio (MSBuild) generator.

Workaround:

1. Open Developer Command Prompt for VS Insiders (or the prompt for the version of Visual Studio you are using) as an administrator
2. Run the following commands, which create a new folder and copy a file from another location to it:

pushd %VCINSTALLDIR%\Auxiliary\Build
mkdir 14.51
copy .\v145\Microsoft.VCToolsVersion.VC.14.51.props .\14.51\Microsoft.VCToolsVersion.14.51.props
copy .\v145\Microsoft.VCToolsVersion.VC.14.51.txt .\14.51\Microsoft.VCToolsVersion.14.51.txt

3. Run a build to make sure it works

Issue #2: Command line builds in PowerShell are not yet configured for the preview. A fix will be deployed in a future preview.

Top bug fixes

Top bug fixes	From the community
Severe IntelliSense Delay After Upgrading to Visual Studio 2026	Fedback Ticket
VS2026 generates incorrect FP code	Fedback Ticket
"Operation is not valid due to the current state of the object" when opening a file with an "unknown" extension	Fedback Ticket
NoWarn in PackageReference is ignored since Visual Studio 18.3.0	Fedback Ticket
In some instances, Visual Studio 2026 not showing variable values on hover during debugging	Feedback ticket
Bug fix in MSVC optimizer that causes bad assembly code generation
VisualCppTools. 4.50.35724 PdbCopy.Exe Arm64 Pdb Copy Crashes	Fedback Ticket
Update MinGit and Git for Windows to handle new allowNTLMAuth setting

Version 18.3.3

Released on March 10, 2026.

Top bug fixes	From the community
Bug fix in MSVC optimizer that causes bad assembly code generation

Security advisories addressed	CVE	Descritpion
.NET Denial of Service Vulnerability	CVE-2026-26130	A denial of service vulnerability exists in ASP.NET Core due to uncontrolled resource consumption.
.NET Elevation of Privilege Vulnerability	CVE-2026-26131	An elevation of privilege vulnerability exists in .NET due to improper authorization.
Visual Studio Information Disclosure Vulnerability	CVE-2025-66413	An information disclosure vulnerability exists in MinGit due to NTLM hash leak to untrusted server.

Version 18.3.2

Released on February 24, 2026.

Top bug fixes	From the community
Compiler optimization codegen causing access violation introduced with v145 toolset	Feedback ticket
Bug fix in MSVC optimizer that causes bad assembly code generation

Version 18.3.1

Released on February 18, 2026.

Top bug fixes	From the community
Fix for variable value on hover during debugging	Feedback ticket
Fix to show missing linked .xaml files in solution explorer	Feedback ticket
GitHub Copilot terminal steals the focus	Feedback ticket
Add support for building and analyzing with Build Performance Agent for specific projects
Fix bug in the MSVC optimizer that causes bad assembly code generation

February Update 18.3.0

Released on February 10, 2026.

IDE

Perform certificate revocation checks

Visual Studio now alerts you if it detects digital certificate problems during network calls.

Visual Studio now checks digital certificates for network calls and lets you know if there's a problem.

If it finds an issue, you'll see a dialog with details about the certificate error. You can choose to cancel or continue the connection.

We recommend keeping this feature on, but you can turn it off in Tools → Options → Environment → Security → Certificates.

Compact spacing in Solution Explorer

The spacing between items in Solution Explorer can now be adjusted to suit your preferences for improved readability.

Visual Studio 2026 introduced extra spacing between items in Solution Explorer to enhance accessibility. It proves helpful when using the mouse since it reduces the chance of misclicks. However, we understand that some users prefer a more compact view to see more items at once.

To accommodate different preferences, Visual Studio now allows you to adjust the spacing between items in Solution Explorer. You can choose between the default spacing and a more compact option.

In the picture below, you can see the difference between the default spacing (on the left) and the compact spacing (on the right):

Go to Tools → Options → Environment → Visual Experience and enable the Use compact spacing in Solution Explorer option to switch to the compact view. After enabling this option, the changes will take effect immediately.

M365 Agents Toolkit

2 new templates onboarded to M365 Agents Toolkit.

We added a new Teams Collaborator Agent template to help you build agents that enhance collaboration in Microsoft Teams. These agents use the Teams SDK and secure RSC patterns to assist with daily work across Teams chats, channels, and meetings. They can summarize conversations, automate workflows, extract tasks, answer questions, and boost productivity right where your team collaborates. The template includes ready-to-use scaffolding and best practices to help your team stay organized and productive.

We also added a Travel Agent template that demonstrates how to build an intelligent travel assistant. The agent answers travel-related questions, helps users understand company travel policies, and finds flights and hotels that comply with organizational guidelines. You can find these new samples in View Samples from the ATK menu.

The Travel Agent uses Azure OpenAI and the Microsoft 365 Retrieval API to access company travel documents and policies stored in SharePoint or OneDrive for Business, providing contextual and policy-compliant travel recommendations directly within Microsoft Teams.

Productivity

Fast scrolling ^📣

You can now scroll faster by holding the Alt key while scrolling the mouse wheel.

Scrolling through large files is now faster and easier. Hold down the Alt key while scrolling the mouse wheel to move quickly when reviewing code or reading documentation.

You can adjust the fast scrolling speed in Tools → Options → Text Editor → Advanced → Touchpad and mouse wheel scrolling sensitivity.

This feature helps you jump to the section you need without lots of scrolling. Try it out!

Thank you Aymen Hamadi for suggesting this feature and to everyone who voted for it!

📣 See feature ticket to share your feedback and continue the conversation.

Hide symbols under files ^📣

You can now disable the display of symbols under files in the Solution Explorer.

Solution Explorer used to show symbols - like classes, methods, and properties - under files to help you navigate your code. Some users found this cluttered the view, since every file had an expander icon like folders and projects. Now, you can turn this off for a cleaner look.

Here's how symbols appeared before:

To hide symbols under files, go to Tools → Options → Projects and Solutions → General and uncheck Show symbols under Solution Explorer files. Solution Explorer will then only show files, without extra symbols:

Thank you Escalante Adriano for suggesting this feature and to everyone who voted for it!

📣 See feature ticket to share your feedback and continue the conversation.

New markdown preview features ^📣

View preview-only and zoom in/out the preview content in the Visual Studio Markdown editor.

Visual Studio Markdown editor gives you more control over the preview.

• You can switch between preview modes: Split Preview shows the editor and preview side by side, Open Preview shows only the preview, and Edit Markdown shows just the editor. The preview-only mode helps you focus on rendered content, especially for large images or complex Mermaid diagrams.
• When previewing a Mermaid diagram, use the zoom controls in the top left corner to zoom in or out. This makes it easier to view large diagrams and see details.

Try out these new controls and let us know what you think!

📣 See feature ticket to share your feedback and continue the conversation.

Insignificant line compression

Enable syntactic line compression to make better use of your screen's vertical real estate.

Syntactic line compression gives you more vertical space in the editor. Lines without letters or numbers compress by 25%, letting you see more code at once without hurting readability. Regular lines stay the same height. In the image below, the right side shows compression enabled - notice how you can see more lines in the same space compared to the left side.

Enable this feature in Tools → Options → Text Editor → Advanced by checking Compress blank lines and Compress lines that do not have any alphanumeric characters. This popular feature from Productivity Power Tools is now built into Visual Studio.

Middle-click scroll ^📣

Press down on your scroll wheel and move the mouse to quickly scroll through your document.

You can now unlock the full potential of the middle mouse button for faster navigation. Press down on your scroll wheel and move the mouse to quickly scroll through your document. This makes it easier to explore large files without relying on traditional scroll bars or repeated wheel scrolling.

This feature is off by default in 18.3 Insiders 2 and needs to be enabled via Tools → Options → Text Editor → Advanced → Middle click to scroll. Give it a try and share your feedback with us!

Thank you to everyone who voted for this feature!

📣 See feature ticket to share your feedback and continue the conversation.

Slimmer left margin in editor ^📣

Reduce the space of left margin by cutting down the space occupied by Quick Actions icon.

The left margin in the code editor is now slimmer, giving you more horizontal space for your code. We've moved the Quick Actions icon (lightbulb or screwdriver) from the margin into the editor, where it appears inline with your code when fixes or refactorings are available.

Left: Slimmer left margin with inline Quick Actions icon, Right: Previous margin

To try out the experience now, go to Tools → Options → Text Editor → Advanced and check Show Quick Actions icon inside the editor.

📣 See feature ticket to share your feedback and continue the conversation.

GitHub Copilot

Enterprise level MCP governance

Easily safeguard your data with enhanced MCP governance features.

MCP server usage in Visual Studio now respects allowlist policies set through GitHub. Admins can specify which MCP servers are allowed within their organizations.

When an allowlist is configured, you can only connect to approved MCP servers. If you try to connect to an unauthorized server, you'll see an error message explaining the server isn't allowed.

This helps organizations control which MCP servers process sensitive data and maintain compliance with security policies.

NuGet MCP Server

Provides a way of updating packages with known vulnerabilities and can retrieve real-time information about packages for GitHub Copilot.

The NuGet MCP server is built-in but must be enabled once in order to use its functionality. For more information, see the documentation on NuGet MCP server.

Getting Started

To enable the NuGet MCP server, follow these steps within Visual Studio 2026:

1. Open the GitHub Copilot Chat window and make sure you are signed in.
2. Click the tools icon in the bottom toolbar to bring up the Tools menu.
3. Find the MCP server named "nuget" and check the box to enable it.

Fixing package vulnerabilities

The NuGet MCP server can help you identify and fix package vulnerabilities in your project. To use the MCP server to fix vulnerabilities, enter the following prompt in the GitHub Copilot Chat window:

Fix my package vulnerabilities

The MCP server will analyze your project's dependencies and suggest updates to packages that have known vulnerabilities.

Updating all packages

The NuGet MCP server can also update your packages to the latest compatible versions. To use the MCP server to update all packages, enter the following prompt in the GitHub Copilot Chat window:

Update all my packages to the latest compatible versions

The MCP server will analyze your project's target framework(s) and suggest updates to the latest version of packages that are compatible with your project.

Update a package to a specific version

The NuGet MCP server can update a specific package to a version you specify. To do so, enter the following prompt in the GitHub Copilot Chat window:

Update the package [PackageName] to version [VersionNumber]

Support

If you experience an issue with the NuGet MCP server or have any other feedback, please open an issue on the NuGet GitHub repository. Please provide the requested information in the issue template so that we can better understand and address your issue or suggestion.

Preview markdown from Copilot Chat

Preview any markdown content generated by Copilot Chat directly in the Visual Studio Markdown editor.

You can now preview any markdown content generated by Copilot Chat directly in the Visual Studio Markdown editor. Previously, this feature was only available for Mermaid diagrams.

When Copilot Chat generates markdown content, click the Preview button at the top right corner of the chat window to see a rendered preview. From there, you can edit and save the markdown content as needed. This lets you quickly visualize and work on markdown files without manually copying and pasting.

Click to accept code completions

Accept code completions up to your cursor position with a single click.

Have you ever wanted to accept a code completion partially with a single click? With the new Click to Accept feature, you can click into a code completion suggestion to accept it up to the cursor position. When you hover over a code completion, the segment will be highlighted as you move your mouse cursor over them to indicate it will be accepted.

This feature gives you more control over how much of a completion you want to accept, making it easier to integrate suggestions into your code. If you prefer using the keyboard, you can still press Ctrl+Right Arrow to accept one word at a time, or Ctrl+Down Arrow to accept one line at a time.

Try out the Click to Accept feature and share your feedback with us.

Colorized code completions

Code completions are now colorized with syntax highlighting to enhance readability.

Code completions from GitHub Copilot or IntelliCode are now colorized with syntax highlighting to help you quickly parse suggested code. Previously, completions appeared in a single color, making it harder to distinguish between variables, functions, and other code elements. To try out the colorization now, you can go to Tools → Options → Text Editor → Code Completions and check Use colorized text for code completions.

To differentiate suggestions from actual code, colorized completions use lower opacity and italic styling. You can further customize the styling by going to Tools → Options → Environment → Fonts and Colors and modifying the Code Completion item.

Let us know what you think about the colorization!

Copilot memories updates ^📣

Make Copilot custom to you by teaching it your coding standards and best practices - creating consistency that lasts across sessions!

Teach Copilot your coding standards and project best practices with memories. Once saved, Copilot consistently applies your preferences across all chat sessions, making it truly project-aware.

How Copilot memories work

Memories intelligently detect your preferences as you chat. When you correct Copilot's behavior, specify a standard, or ask it to remember something, you'll see a confirmation prompt. Choose to save the preference to your personal instructions (%USERPROFILE%/copilot-instructions.md) or your repo instructions (/.github/copilot-instructions.md).

Every time you chat, you're teaching Copilot to respond better and documenting best practices for yourself and your team.

Thank you Peter Matthews for suggesting this feature and to everyone who voted for it!

📣 See feature ticket to share your feedback and continue the conversation.

Access custom prompts via slash commands

Quickly invoke your favorite custom prompts using slash commands in Copilot Chat.

You can now invoke your favorite custom prompts faster using slash commands in Copilot Chat. Instead of typing # and searching through all available references, type / and your custom prompts appear at the top of the IntelliSense list. Custom prompts are marked with a bookmark icon, while default system prompts have no icon and appear below.

We also added two new slash commands to help you create custom instructions and prompts:

• /generateInstructions: Generate repo-level custom instructions for your project. Not sure how to write a custom instruction file for your repository? This command has you covered. It automatically generates a copilot-instructions.md file for your project using project context like coding style and preferences.
• /savePrompt: Extract a reusable prompt from the current thread and save it to a prompt file. Use this command when you've typed a prompt you'd like to reuse so you can easily reference it via / commands later.

Give the new slash commands a try today and let us know what you think!

Debugging & diagnostics

DataTips in the IEnumerable Visualizer

Deep Object Inspection, Right in the IEnumerable Visualizer.

You can now use DataTips in the IEnumerable Visualizer to inspect objects while debugging. Hover over any cell in the grid to see the full object behind that value, using the same DataTip experience you get in the editor and Watch window.

This makes debugging collections of complex or nested types much easier. Whether you're working with a List<T> of domain objects or a dictionary with structured values, a single hover reveals all the object's properties.

Analyze your call stack

One-click call stack analysis to understand your app's runtime state.

We're introducing Analyze Call Stack with Copilot to help answer a simple but critical debugging question: What is my thread or app doing right now? A new Analyze Call Stack button in the Call Stack window lets you send the current debug state to Copilot with one click, opening the chat window with an app state analysis. No guesswork.

Copilot understands both synchronous and asynchronous call stacks and annotates relevant frames. Whether your app is waiting on an async task or has broken during async execution, you can click the annotated frame to get a clear explanation of why execution is paused, what the thread is waiting on, and how it got there.

This turns the call stack from a static list of frames into an interactive debugging experience. Instead of manually reconstructing async flows, Copilot helps you quickly understand runtime behavior and get back to fixing the real problem.

Profiler agent with Unit Test support

Profiler Agent Expands to Unit Test Workflows.

We've expanded the Profiler Agent with unit test support. You can now validate performance improvements using your existing unit tests, making it easier to measure and optimize performance across more scenarios. The agent discovers relevant unit tests that exercise performance-critical code paths, in addition to BenchmarkDotNet benchmarks.

When no suitable tests or benchmarks exist, it automatically creates a lightweight measurement artifact to capture baseline metrics and compare results after optimization.

This unit test-first approach also enables Profiler Agent support for C++ scenarios, where benchmarks aren't always practical but unit tests already exist.

The Profiler Agent analyzes performance data, surfaces bottlenecks, generates or enhances unit tests or benchmarks, suggests targeted optimizations, and validates improvements in a guided loop. You get the full power of the Profiler Agent - now grounded in unit tests, applicable to more languages, and easier to adopt across your projects.

Desktop

WinForms Expert agent

The coding agent now includes special instructions for WinForms development, crafted by experts on the team.

The WinForms Expert agent is a comprehensive guide that helps you tackle the nuanced challenges of WinForms development. It covers several critical areas:

Designer code vs. regular code: WinForms projects have two distinct code contexts - designer-generated serialization code and modern business logic. The agent knows which C# features you can use in each context.

Modern .NET patterns: The agent is fully updated for .NET 8-10, including:

• MVVM data binding patterns with the Community Toolkit.
• Async/await patterns with the right InvokeAsync overloads.
• Dark mode support and high-DPI awareness.
• Nullable reference types (NRTs) in the right places.

Layout best practices: Get guidance on using TableLayoutPanel and FlowLayoutPanel for responsive, DPI-aware layouts that work across different screen sizes and scaling factors.

CodeDOM serialization management: Learn critical rules for property serialization in the WinForms designer, so you can avoid common pitfalls with [DefaultValue] attributes and ShouldSerialize*() methods.

Exception handling: Use proper patterns for async event handlers and application-level exception handling to prevent process crashes.

The agent's instructions are detailed, covering everything from control naming conventions to accessibility requirements. It's like having a senior WinForms architect review every line of your code.

.NET

NuGet audit sources

Visual Studio now supports audit sources for discovering package vulnerabilities with NuGet Audit.

Need to audit NuGet packages for vulnerabilities without using nuget.org as a package source? You can now configure separate audit sources.

Visual Studio now lets you configure audit sources for NuGet Audit. These sources discover package vulnerabilities independently from your package sources. For more information, see the documentation on audit sources.

NuGet Package Manager UI

The NuGet Package Manager UI displays vulnerabilities found from configured audit sources.

In this example, a private feed is used as the package source, but a known vulnerability is detected because an audit source is configured.

Configure audit sources

To configure audit sources, navigate to Tools → Options → NuGet Package Manager → Sources.

Audit sources provide vulnerability data during restore without acting as package sources. If you don't configure any audit sources, NuGet Audit uses your package sources instead.

To set up an audit source, select Use separate sources for vulnerability audit. This displays a table for managing audit sources, similar to the package sources table.

To use nuget.org as an audit source, use the standard index URL: https://api.nuget.org/v3/index.json

Web Live Preview deprecation

Web Live Preview has been deprecated and removed.

We've deprecated and removed Web Live Preview from Visual Studio 2026. If you need to edit ASP.NET Web Forms, use the built-in Web Forms Designer.

For more info, see ASP.NET Web Forms Designer documentation.

Hot Reload improvements

Faster, more reliable Razor Hot Reload with auto-restart support for rude edits.

We've made several improvements to the Hot Reload experience in Visual Studio.

Improved Hot Reload performance & reliability for Razor files

Thanks to co-hosting the Razor compiler inside the Roslyn process, editing a .razor file during Hot Reload is much faster and more efficient (addressing prior feedback where Blazor Hot Reload could take tens of seconds). This change also increases overall reliability when using Hot Reload.

Fewer blocked edits (reduced 'rude edits')

We've expanded what code changes are allowed during Hot Reload. Several edits that previously triggered a rude edit (changes that require a rebuild and restart) are now applied seamlessly. Some examples of edits that are no longer a rude edit include:

• Renaming a file
• Editing code that has lambdas with default parameter values
• Editing property accessors with the field keyword

Auto-restart on 'rude edits'

Hot Reload can now automatically restart the app's process when an unsupported change ('rude edit') is made, instead of ending the entire debug session.

To enable this, edit your project file to contain this property declaration.

<PropertyGroup>
    <HotReloadAutoRestart>true</HotReloadAutoRestart>
</PropertyGroup>

You can also set this in a Directory.Build.props file. This streamlined auto-restart kicks in for project types where a quick process restart is feasible (e.g. certain Aspire or web projects), so you can continue debugging with minimal interruption.

This is a process-based restart. If you are debugging 4 projects, only the changed project(s) (and any dependent project) will get rebuilt and restarted.

Razor editor improvements

Faster and smarter Razor editor in Visual Studio, cohosting boosts speed/reliability and much more.

Here's a list of notable improvements to the Razor editor:

Performance & Reliability (Cohosting)

The Razor compiler and tooling experience now runs cohosted inside Roslyn LSP server, greatly speeding up Razor file updates (e.g. Hot Reload changes apply much faster) and improving reliability during editing.

Simplify Tag Code Action (Community Contribution)

Added a new code fix to convert an empty component tag into a self-closing tag when no content or required child elements are present (contributed by Peter Juhasz). For example <Component Attribute="Value"> </Component> can be simplified to <Component Attribute="Value" />

Extract Style Block to .razor.css

You can now use a code action to extract an inline <style> section from a Razor component into a separate .razor.css file. This helps isolate component-specific styles Blazor's CSS Isolation by automatically creating or updating the matching .razor.css file for the component.

@bind:event IntelliSense

Improved Razor IntelliSense to provide completion suggestions for @bind:<event> values (contributed by Peter Juhasz). When using two-way data binding with custom events (for example, @bind="Value" @bind:event="oninput" in Blazor), the editor now autocompletes valid event names like oninput or onchange.

Formatting Improvements

The new Razor formatting engine received numerous bug fixes and enhancements. Razor editor now better honors C# formatting style options (e.g. spacing, indenting rules from Visual Studio configuration) inside Razor files and resolves various formatting quirks that existed in previous versions (especially around mixed HTML/C# content).

Debugging Tooltip Enhancements

Improved the debugger hover tooltips in Razor files. Visual Studio now more reliably displays variable values and object previews when you hover over variables or components in a Razor file during a debugging session, making it easier to inspect data at runtime.

Go To Definition for Tag Helpers

Leveraging new capabilities from cohosting, you can now navigate to the definitions of ASP.NET Core MVC Tag Helpers and their attributes directly from Razor files. Hitting F12 (or Ctrl+Click) on a Tag Helper (e.g. an <input asp-for=" "> or any MVC Tag Helper usage) will jump to its source definition. This long-requested feature makes it much easier to explore and understand Tag Helpers in your projects.

General IntelliSense Fixes

Addressed several Razor editor IntelliSense issues. HTML snippets (like typing div + Tab to expand a <div> block) now appear consistently in Razor files (previously they sometimes failed to show up). Autocomplete for hyphenated attributes and component parameters (e.g. data-* attributes or Blazor component parameters with dashes) is more robust, so suggestions and completions work as expected in these cases.

Razor Compiler Optimizations

Introduced significant compiler performance and memory usage improvements for Razor and Blazor projects. Solutions with many Razor components should see faster builds and less memory overhead. These optimizations make editing and building Razor pages snappier, addressing prior feedback about high memory usage and slow incremental builds in large Blazor apps.

Legacy Razor Editor for ASP.NET Core

The Legacy Razor Editor for ASP.NET Core has been fully replaced by the modern Razor editor running in cohosting mode. The legacy editor is no longer available.

The option in Tools > Options to enable the Legacy Razor Editor is no longer used and will be removed in a future version of Visual Studio.

Smarter .NET test generation

Create and refine unit tests faster with GitHub Copilot's intelligent test generation.

Visual Studio now includes smarter test generation with GitHub Copilot. You can quickly create and refine tests to boost coverage and confidence in your code. This purpose-built testing workflow works with C# and popular frameworks like xUnit, NUnit, and MSTest.

Whether you're starting a new project or improving an existing one, GitHub Copilot testing helps you write tests faster and keeps everything in your workflow. Just type @Test in GitHub Copilot Chat, describe what you want to test, and Copilot generates the test code for you.

C++

App modernization for C++

GitHub Copilot app modernization for C++ is now available in Public Preview.

We're excited to announce that GitHub Copilot app modernization for C++ is now available in Public Preview.

GitHub Copilot app modernization for C++ helps you update your C++ projects to use the latest versions of MSVC and to resolve upgrade-related issues.

You can find our user documentation on Microsoft Learn.

Getting started

1. Install Visual Studio 2026 version 18.3 or later, with any C++ workload selected.
2. Open an MSBuild (.sln) or CMake project that uses MSVC to build on Windows.
3. Ask @Modernize in the GitHub Copilot Chat window to update your project to use MSVC version 14.50, launch the Modernize agent via the right-click context menu on the solution in the Solution Explorer, or click Project → Retarget solution from the top level menu.

App modernization

GitHub Copilot app modernization for C++ is now available in Private Preview.

We're excited to share that GitHub Copilot app modernization for C++ is now in Private Preview. GitHub Copilot app modernization for C++ helps you migrate your C++ projects to the latest version of the Microsoft C++ (MSVC) Build Tools.

Want to try it? Sign up for the Private Preview at aka.ms/cppagents.

Code editing tools for agent mode

C++ Code Editing Tools for GitHub Copilot Agent Mode are now available in Private Preview.

We're excited to share that C++ Code Editing Tools for GitHub Copilot Agent Mode are now in Public Preview. These tools help Copilot navigate your C++ codebase more effectively, so you get better suggestions when refactoring or modifying code. Copilot can now:

• Find all references to symbols across your project
• Access metadata like type information, declarations, and scope
• Map out class inheritance hierarchies
• Follow function call chains

To get started:

1. Make sure GitHub Copilot Agent Mode is enabled in your IDE.
2. Open a C++ project.
3. Go to Tools → Options → GitHub → Copilot and enable Enable C++ tools to be used by Copilot.
4. Restart your IDE or solution.
5. Enable specific tools using the Tools icon in Copilot Chat.

Note: Tool names and UI may change during Public Preview.

Once you've enabled the tools, Copilot uses them automatically when answering your questions or suggesting code changes.

For best results, write clear prompts and use AI models that support tool-calling. Learn more at AI model comparison - GitHub Docs

Build performance for Windows

GitHub Copilot build performance for Windows is now available in Public Preview.

We're excited to announce that the GitHub Copilot build performance for Windows is now available in Public Preview.

GitHub Copilot build performance for Windows

GitHub Copilot build performance for Windows uses Build Insights to identify and fix build performance issues in C++ projects using MSVC. By analyzing your build process, this agent suggests optimizations and implements changes to reduce build times:

1. Reduce header parsing time by creating precompiled headers and optimizing include paths, such as removing unused includes.
2. Refactor functions to reduce and eliminate function parsing time.
3. Modernize C++ code to use newer language features that improve compilation speed.
4. Optimize build settings to leverage parallel builds and optimal linker settings.

Getting started

1. Make sure GitHub Copilot Agent Mode is enabled in your IDE.
2. Open a C++ project.
3. Ask @BuildPerfCpp in the GitHub Copilot Chat window to optimize your build time.

Note: Build Insights needs to run and collect build performance data. It also requires ETL trace collection permissions. Accept the UAC prompt once to enable Build Insights to collect ETW events from MSVC.

@BuildPerfCpp in GitHub Copilot chat to optimize your build time" />

Extensibility

Experimental Instance relocated

Added Start Experimental Instance and Reset Experimental Instance commands to the Extensions menu.

Start and reset experimental instance commands are now in the Extensions → Extension Development menu. You don't need to use Windows Start menu shortcuts to launch or reset the experimental Visual Studio instance anymore.

These commands are easier to find and help you avoid accidentally launching root-suffixed instances, which are only for Visual Studio extension development.

You can still use the old shortcuts at [installdir\vssdk] if you prefer.

Top bug fixes

Top bug fixes	From the community
Updated the Visual Studio installer to include the latest servicing release of the 10.0.26100 Windows SDK (10.0.26100.7705).	Feedback ticket
Table columns in Git Repository no more changeable	Feedback ticket
TFVC items in project folders are not regarded as under source control	Feedback ticket

---

Version 18.2.2

Released on February 10, 2026.

Top bug fixes	From the community
Fixed a bug in the MSVC optimizer that caused bad assembly code generation.

Security advisories addressed	CVE	Descritpion
Github Copilot and Visual Studio Remote Code Execution Vulnerability	CVE-2026-21256	This security update addresses a vulnerability where Improper neutralization of special elements used in a command ('command injection') in GitHub Copilot and Visual Studio allows an unauthorized attacker to execute code over a network.
Github Copilot and Visual Studio Security Feature Bypass Vulnerability	CVE-2026-21257	This security update addresses a vulnerability where improper neutralization of special elements used in a command ('command injection') in GitHub Copilot and Visual Studio allows an authorized attacker to elevate privileges over a network.
.NET Security Feature Bypass Vulnerability	CVE-2026-21218	This security update addresses a vulnerability where improper handling of missing special element in .NET and Visual Studio allows an authorized attacker to perform spoofing over a network.

---

Version 18.2.1

Released on January 20, 2026.

Top bug fixes	From the community
VS2026 missing Microsoft.VCRedistVersion.v143.default.props	Feedback ticket
Fatal error C1001: Internal compiler error	Feedback ticket

---

January Update 18.2.0

Released on January 13, 2026.

GitHub Copilot

NuGet MCP Server

Provides a way of updating packages with known vulnerabilities and can retrieve real-time information about packages for GitHub Copilot.

The NuGet MCP server is built-in but must be enabled once in order to use its functionality. For more information, see the documentation on NuGet MCP server.

Getting Started

To enable the NuGet MCP server, follow these steps within Visual Studio 2026:

1. Open the GitHub Copilot Chat window and make sure you are signed in.

2. Click the tools icon in the bottom toolbar to bring up the Tools menu.

1. Find the MCP server named "nuget" and check the box to enable it.

Fixing package vulnerabilities

The NuGet MCP server can help you identify and fix package vulnerabilities in your project. To use the MCP server to fix vulnerabilities, enter the following prompt in the GitHub Copilot Chat window:

Fix my package vulnerabilities

The MCP server will analyze your project's dependencies and suggest updates to packages that have known vulnerabilities.

Updating all packages

The NuGet MCP server can also update your packages to the latest compatible versions. To use the MCP server to update all packages, enter the following prompt in the GitHub Copilot Chat window:

Update all my packages to the latest compatible versions

The MCP server will analyze your project's target framework(s) and suggest updates to the latest version of packages that are compatible with your project.

Update a package to a specific version

The NuGet MCP server can update a specific package to a version you specify. To do so, enter the following prompt in the GitHub Copilot Chat window:

Update the package [PackageName] to version [VersionNumber]

Support

If you experience an issue with the NuGet MCP server or have any other feedback, please open an issue on the NuGet GitHub repository. Please provide the requested information in the issue template so that we can better understand and address your issue or suggestion.

.NET

GitHub Copilot app modernization

A dynamic three stage workflow for .NET upgrades.

We introduced a three stage approach to help you assess, plan, and execute your .NET upgrade with more insight and visibility. The Assessment file outlines outdated NuGet packages, target versions, project count, upgrade complexity, and API analysis.

The Plan file is now generated dynamically based on that assessment, giving you an upgrade plan that stays aligned with your project state. We also replaced the old progress document well with a Task Execution file that updates as tasks run.

All three files are fully dynamic, editable, and kept in sync throughout the process, giving you a more transparent and collaborative upgrade experience from start to finish.

C++

MSVC versions from Visual Studio 2022

MSVC Build Tools v14.30-v14.43 are now available in Visual Studio 2026.

To make it easier to bring your existing C++ projects to Visual Studio 2026, we are now including Microsoft C++ (MSVC) Build Tools versions 14.30-14.43 in the Visual Studio 2026 installer under the Individual components tab. These versions originally shipped in Visual Studio 2022.

As a result of this change, Visual Studio 2022 (v17.0-v17.14) users can continue to use their existing compiler version when they upgrade to Visual Studio 2026. Simply install the version you need and load your project in the latest IDE to get started.

Support for the new MSVC versions will also be added to the Visual Studio setup assistant in a future update.

Top bug fixes

Top bug fixes	From the community
Website Publishing is missing the FTP option.	Feedback ticket
Formatting Document for Printing Box Won't Go Away (VS2026)	Feedback ticket
Fixed an issue causing certain ternary expressions involving conversion functions to reference type to be considered rvalues instead of lvalues	Feedback ticket
Debugger and Visual Studio 18.1.1 crashes	Feedback ticket

---

Version 18.1.1

Released on December 16, 2025.

Top bug fixes	From the community
Internal compiler error in msvc 14.50.35717	Feedback ticket
VS2026 (18.0.0) is missing option to install LTSC C++ tools	Feedback ticket
After update extensions VS2026 is broken	Feedback ticket
Fixed an issue where ReSharper users experience longer startups on Visual Studio 2026 as compared to Visual Studio 2022.	Feedback ticket
Tool Windows don't have a Close Item in their context menu	Feedback ticket
Observing non-deterministic output when building UCRT for CHPE builds	Feedback ticket
Search is broken in the MCP Registries window	Feedback ticket
Fixed an issue where ARM64 Enclave VCRuntime would fail to link correctly.
Updated the Visual Studio Installer to include the latest servicing release of the 10.0.26100 Windows SDK (10.0.26100.7175).

---

December Update 18.1.0

Released on December 9, 2025.

IDE

MCP Authentication Management

You can now manage authentication credentials for MCP servers in a unified experience in Visual Studio.

You can now manage authentication credentials for MCP servers in one place in Visual Studio, including credentials from outside the Visual Studio Keychain like Microsoft and GitHub accounts. Access this through the new MCP server management experience.

MCP Server Instructions

You can now view instructions files that may be shipped with MCP servers directly in Visual Studio.

MCP server instructions are a quick system prompt that the server sends to the host, showing you how to use that server's tools. You can now view these instruction files directly in Visual Studio. Just open the new MCP server management experience to check them out.

MCP Elicitations and sampling

Support for MCP Elicitations, and new UX for elicitations and sampling in chat.

MCP in Visual Studio now supports elicitations. The Model Context Protocol (MCP) lets servers request extra information from you through the client during interactions. This flow helps you control user interactions and data sharing while servers gather the details they need.

You can now respond to MCP sampling and elicitation requests directly in the chat window for a simpler, more streamlined experience.

MCP Server Management

An easier, more unified UX for managing MCP servers in Visual Studio.

Managing MCP servers in Visual Studio is now easier with a unified experience. You can quickly configure, authenticate, and view server status in a simplified management UI.

Select Configure in the flyout for any server in the tool picker window to get started.

GitHub Copilot

GitHub Cloud Agent preview

Delegate tasks to the Cloud Agent and let Copilot handle the tedious work while you stay focused.

The GitHub Cloud Agent is now available in preview. You can offload repetitive or time-consuming tasks like UI cleanups, refactors, doc updates, and multi-file edits to the Cloud Agent and review the changes later.

Enable the Cloud Agent

To enable the Cloud Agent:

1. Click the Copilot badge dropdown.

2. Select Settings & Options → Coding Agent (Preview).

3. Restart Visual Studio.

Note: The Cloud Agent requires your solution to be connected to a GitHub repository.

How it works

Once enabled, you can delegate tasks directly from Visual Studio. The Cloud Agent drafts changes for you to review, so you can stay focused on building and debugging the core of your project instead of handling tedious edits.

We're actively improving this experience based on your feedback. Soon, you'll see direct pull request links inside Visual Studio, making it even easier to review agent-generated changes without breaking your flow.

Important

Activate GitHub Copilot Free and unlock this and other AI features. No trial. No credit card. Just your GitHub account.

Activate GitHub Copilot for free now.

Debugging & diagnostics

Smarter breakpoint troubleshooting

Copilot now auto-fixes unbound breakpoints to get you debugging faster.

Copilot support for unbound breakpoints has been available for a while, using the ability to click Ask Copilot from the hover tooltip, but in Dev18 it gets a major upgrade. Previously, Copilot would read the error message and suggest next steps.

Now it performs a deeper, automated analysis checking the file, inspecting loaded modules and symbols, identifying the correct module, and loading the right symbols for you.

This improvement also expands coverage beyond symbol issues. Copilot now helps resolve problems caused by the wrong debug engine, breakpoints disabled by JMC or managed optimizations, outdated binaries, and more. Most unbound breakpoint issues can now be fixed with a single click, making the entire experience faster and more reliable.

Debugger Copilot uses Output Window

Debugger Copilot assistance uses Output Window context for smarter debugging.

In Dev 18, Debugger Copilot assistance has been upgraded to leverage runtime details from the Output Window during debug mode. When analyzing an exception, Copilot will ask for permission to access the Output Window context as needed.

In the example below, the Exception Helper uses the Output Window context to provide more accurate and helpful responses.

This context is now available throughout debug mode, enabling richer insights for Exception Helper, variable analysis, code inspection, and other debugging scenarios. By combining code and runtime insights, this upgrade improves the quality of Exception Helper responses, helps you pinpoint root causes faster, recommends precise fixes, and highlights the relevant code. The result is a more reliable, efficient, and context-aware debugging experience across multiple debugging workflows.

.NET counters for profiler agent

Profiler Agent delivers deeper ASP.NET insights with new .NET counter support.

The Copilot Profiler Agent now uses .NET Counters for ASP.NET scenarios, giving you deeper insights into your app's performance. Alongside CPU and memory analysis, you now get:

• Project trait detection for smarter context-aware diagnostics

• Counters-driven analysis to surface ASP.NET-specific performance issues faster

• Enhanced end-to-end insights for pinpointing bottlenecks with greater accuracy

Example results using the counters tool:

This upgrade makes the Profiler Agent more powerful for ASP.NET apps, helping you spot issues early, understand root causes, and take action confidently.

Exception analysis with GitHub repo context

Exception Analysis now uses GitHub repository context to deliver smarter, context-aware debugging insights.

We've enhanced the Exception Helper with repository context, giving you richer insights for faster, more accurate debugging. Exception Helper now cross-references your open repository, including past bugs, issues, pull requests, and historical fixes, to deliver guidance that's directly relevant to your codebase.

This feature supports both GitHub and Azure DevOps repositories.

You now get a context-aware, high-precision debugging experience tailored to your repository.

Desktop

WinForms Expert agent

The coding agent now includes special instructions for WinForms development, crafted by experts on the team.

The WinForms Expert agent is a comprehensive guide that helps you tackle the nuanced challenges of WinForms development. It covers several critical areas:

Designer code vs. regular code: WinForms projects have two distinct code contexts - designer-generated serialization code and modern business logic. The agent knows which C# features you can use in each context.

Modern .NET patterns: The agent is fully updated for .NET 8-10, including:

• MVVM data binding patterns with the Community Toolkit.

• Async/await patterns with the right InvokeAsync overloads.

• Dark mode support and high-DPI awareness.
• Nullable reference types (NRTs) in the right places.

Layout best practices: Get guidance on using TableLayoutPanel and FlowLayoutPanel for responsive, DPI-aware layouts that work across different screen sizes and scaling factors.

CodeDOM serialization management: Learn critical rules for property serialization in the WinForms designer, so you can avoid common pitfalls with [DefaultValue] attributes and ShouldSerialize*() methods.

Exception handling: Use proper patterns for async event handlers and application-level exception handling to prevent process crashes.

The agent's instructions are detailed, covering everything from control naming conventions to accessibility requirements. It's like having a senior WinForms architect review every line of your code.

Top bug fixes

Top bug fixes	From the community
Solution Explorer does no longer show the Solution node	Feedback ticket
Fixed an issue blocking extension installation within an MSI custom action.	Feedback ticket
CompletionsPackage occasionally failed to load, showing an error dialog to the user.	Feedback ticket
Fixed generating Ad Hoc Android APKs using the Archive Manager.	Feedback ticket
AI Generated commit message crashes VS if window layout is changed	Feedback ticket
Fatal error C1001: Internal compiler error	Feedback ticket
Error window declaring "The 'GlobalHubClientPackage' package did not load correctly." was being shown in rare instances that resulted in various Visual Studio features not functioning properly.	Feedback ticket
Both VsixInstaller and VS installer get launched after shutdown	Feedback ticket
Fixed a scenario where NuGet Restore fails when using Central Package Management with floating versions and Solution Filters.
Creating a DesktopWindowXamlSource in a Win32 app breaks externally when the app is launched	Feedback ticket
Visual Studio 2026 Code Analysis not configurable	Feedback ticket
x64 Emulator crash when an ARM64EC thread calls an x64 coroutine that calls another ARM64EC coroutine	Feedback ticket
Fixed a bug seen in the auto-vectorizer where it may look like only part of the loop was faithfully executed.
VS2026 Unable to Find v143 Build Tools	Feedback ticket
Middle click to close tab doesn't work unless the tab has been loaded	Feedback ticket

---

Version 18.0.2

Released on November 24, 2025.

Top bug fixes	From the community
Fixed a crash that affected C++ programs using OpenMP.	Feedback ticket
Visual Studio 2026 Insiders DataTips unreadable	Feedback ticket
Source control plugin change gives pop-up	Feedback ticket
Computing rename information message gets stuck on screen	Feedback ticket

---

Version 18.0.1

Released on November 19, 2025.

Top bug fixes	From the community
problems with Visual Studio 2022 17.14.15 update - LINK : fatal error LNK1000	Feedback ticket
(2026) Word Wrap setting keeps getting unset after opening a diff view	Feedback ticket
Fixed an incorrect codegen issue with ternary expressions involving expressions with arrays of different types.	Feedback ticket
[VS18] Debugger is not closing std stream redirected to a file	Feedback ticket
Significant debugger hang on first break point in solution with many solution items	Feedback ticket
Sanitizer Coverage Blocklist Broken	Feedback ticket
Incorrect instructions generated in AVX2	Feedback ticket
C4319 not emitted when compiling C code	Feedback ticket
C++/CLI - inline namespace does not work	Feedback ticket
Performance Profiler does not load symbols correctly for unmanaged code in C++/CLI	Feedback ticket
Adds Xcode 26.1 support for the .NET for iOS / tvOS / macOS / MacCatalyst / MAUI workloads. See release notes for workload v26.1.10494.
Columnstore Index containing Vector column error	Feedback ticket

---

November Update 18.0.0

Released on November 11, 2025.

IDE

Did you mean? ^📣

Never lose track of files again! Copilot intelligently detects your intent and suggests better matches when you search in Visual Studio.

Ever forget the name of a file while coding? The new Did You Mean feature in Visual Studio is here to help! When you search using All-In-One Search and Copilot detects a better match than the top result - perhaps because of a typo or a fuzzy memory - it will suggest what you might have meant.

Did You Mean works seamlessly with All-In-One Search, which you can access by pressing Ctrl+Shift+P. When you type a search term, Copilot analyzes your input and suggests a more relevant term if it finds one that more closely matches your intent. This feature helps whether the search results are empty or when the top result isn't what you intended.

Did You Mean speeds up your search experience by reducing the time spent correcting typos or trying to remember the correct name - making your search experience easier and more intuitive!

Did You Mean (preview) is now available in Visual Studio and automatically enabled for all applicable users. Currently, this feature works with public GitHub repositories, and we're actively working to expand its reach in future updates. Give it a try today and let us know what you think! You can also change the option in Tools → Options → GitHub → Copilot → Search → Enable 'Did You Mean' code search support in All-In-One Search (preview).

📣 See feature ticket to share your feedback and continue the conversation.

Code coverage ^📣

Code coverage is now available in Visual Studio Community and Professional editions for the first time - ensuring your code is well-tested has never been easier!

You can now analyze which parts of your code are exercised by tests directly from within the IDE! This feature was previously only available in the Enterprise edition, but is now available in Community and Professional editions, making it easier than ever to ensure your code is well-tested.

What's new

• Built-in code coverage tools help you understand test effectiveness by showing how much of your code is covered by unit tests and other coded tests.

• CI/CD integration allows automated coverage tracking as part of your continuous integration workflows.

How to use it

1. From the Test menu, select Analyze Code Coverage for All Tests to run coverage on your test suite.

2. You can also right-click within the Test Explorer to run code coverage for selected tests.

3. Results will appear in the Code Coverage Results window, showing percentages for each assembly, class, and method.
4. Visual Studio highlights tested lines directly in the editor, so you can quickly spot what's covered and what's not.

This feature brings a crucial tool to more developers, helping you ship with greater confidence.

📣 See feature ticket to share your feedback and continue the conversation.

New look and feel ^📣

Visual Studio now features a refreshed interface aligned with the Fluent UI design system. This update introduces a modern, cohesive aesthetic across the IDE, improving usability, accessibility, and visual clarity.

The Visual Studio IDE has been updated to align with the Fluent UI design system, delivering a more modern and cohesive look and feel. These changes enhance usability and accessibility while preserving familiar workflows.

In addition to the updated design language, we've introduced 11 new tinted themes to give users more control over the appearance of their development environment.

We're also introducing a new Editor Appearance setting that focuses specifically on the editor's look and feel. This setting can be used to match the overall IDE theme, but it also works independently, allowing users to customize their coding environment without needing to align with the broader IDE.

Finally, we've redesigned the iconography to be more visually appealing and easier to recognize, improving navigation and overall user experience.

📣 See feature ticket to share your feedback and continue the conversation.

Modern settings experience ^📣

The new settings experience brings a streamlined, user-friendly interface to Visual Studio, replacing Tools > Options with a modern design, smarter organization, and enhanced reliability.

The modern settings experience is now the default, replacing the legacy Tools → Options dialog. This updated platform gives you a Fluent-aligned UI, centralized registration, and improved persistence, bringing clarity, consistency, and extensibility to your configuration workflow.

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

Most commonly used settings have already moved to the new platform. You can still access remaining settings through legacy links, ensuring continuity while you transition to the new experience.

📣 See feature ticket to share your feedback and continue the conversation.

M365 Agents Toolkit updates

You can now use GitHub Copilot and the Microsoft 365 Agents Toolkit to build, personalize, and debug your M365 apps and agents faster.

1. You can now use GitHub Copilot to elevate your Microsoft 365 app and Copilot agent development!

• GitHub Copilot Extension for Microsoft 365 Agents Toolkit: Get natural language prompts, recommended templates, intelligent guidance, and instant troubleshooting. Just @mention the extension in Copilot Ask Mode. For more details, check out the blog: Preview the GitHub Copilot extension for Teams Toolkit.

• MCP Server for Microsoft 365 Agents Toolkit: Unlock advanced AI-driven workflows in Copilot Agent Mode. Add new AI-powered features to your Microsoft 365 app and Copilot agent using the Teams AI library and Agents SDK. Learn more in the blog: Build Smarter with the Microsoft 365 Agents Toolkit MCP Server.

You can quickly build, personalize, and debug your M365 apps and agents with Copilot by your side.

2. Teams agents and app templates upgraded to Teams AI Library V2

All Teams agents and Teams app project templates now use the new Teams AI Library V2.

These updated templates let you:

• Connect to Large Language Models (LLMs) like OpenAI or Azure OpenAI without changing your core bot logic.

• Connect to external data sources so your apps stay current and responsive.

• Use adaptive cards, expressive emojis, and rich interactive elements that feel native in Teams.

You can now create fully functional Teams agents faster, enjoy a smoother development experience, and deliver user experiences that feel truly native.

3. This release added the .NET 10 support for M365 agents templates.

4. Important notes on Bot registration updates

This release contains changes switching from multi-tenant to single-tenant bot registrations to align with Azure Bot Service (ABS) security requirements. Microsoft is retiring support for multi-tenant bot registrations. All new bot registrations must now use single-tenant configuration. This change enhances security and compliance across Microsoft 365 services. Multi-tenant registration will be fully blocked. Existing multi-tenant bots will continue to function correctly but eventually migrate to single-tenant registration follow the migration guide to switch your Azure Bot Service registration to single-tenant.

Setup Assistant

Easily resolve missing dependencies and get to build faster with Setup Assistant.

Setup Assistant helps you get building faster after upgrading Visual Studio. It finds missing toolsets and SDKs, then lets you install or retarget them right from the IDE.

For C++ developers: Setup Assistant shows missing MSVC toolsets and Windows SDKs. You can install them with one click in the Visual Studio Installer.

For .NET developers: If your project uses a pinned global.json, Setup Assistant links you to the matching .NET SDK for quick installation in your browser.

Productivity

Adaptive paste

Copilot adapts pasted code to your file's context, so you spend less time fixing names, formatting, and minor errors.

Pasting code usually means cleanup - renaming symbols, fixing errors, adjusting formatting, or translating between languages.

Adaptive paste does that work for you. It analyzes where you paste and suggests code that fits your file. You can use it to:

• Fill in missing interface or abstract members.

• Fix small mistakes.

• Apply consistent styling and formatting.
• Translate between human or programming languages - for example, C++ to C#.
• Continue a pattern or fill in blanks.

For example, if you have a Math class that implements IMath and you paste a Ceiling method, adaptive paste can turn it into Floor if that's still unimplemented.

It also helps with language translation. Here Copilot adapts C++ code into equivalent C# during paste.

How to use it:

1. Paste code normally {KeyboardShortcut:Edit.Paste}.

2. Press Tab when the adaptive paste bar appears to request a suggestion.

3. Review the diff of original vs adjusted code and accept or dismiss.

You can also trigger it directly:

• Press Shift+Alt+V to paste and immediately show a suggestion.

• Use Edit → Paste Special → Paste with Copilot.

Adaptive paste is on by default. You can toggle it in Tools → Options → GitHub → Copilot → Editor → Enable Adaptive Paste.

Code actions at your fingertips ^📣

Get quick help from Copilot with a single right-click from your context menu in Visual Studio.

You can now interact with Copilot directly from your context menu in Visual Studio! This new feature lets you quickly get help from Copilot for common tasks with a single click, without needing to type any prompts.

Currently, there are five Copilot actions available in the context menu, each working differently depending on whether you have code selected:

Try out these Copilot actions and let us know what you think! We would love to hear your feedback and any suggestions for other actions you would like to see in the context menu.

📣 See feature ticket to share your feedback and continue the conversation.

Mermaid chart rendering ^📣

Rendering Mermaid charts in both the Markdown editor and Copilot Chat.

We are excited to announce that Visual Studio now supports rendering Mermaid charts in the Markdown editor, where you can provide your own Mermaid syntax or have Copilot generate it for you! This new feature lets you visualize complex data structures and workflows directly within your code editor. For example, you can create flowcharts and diagrams in a Markdown file using Mermaid syntax, and they will be automatically rendered in the preview.

If you have Mermaid syntax ready in a Markdown file, you can preview it by clicking the Preview button in the top left corner of the editor. The Mermaid chart will be rendered in the preview pane, allowing you to see the visual representation of your data.

You can also ask Copilot Chat to generate charts and diagrams to help explain complex codebases or logic with visual aids. Copilot will respond with the generated Mermaid syntax, which you can preview directly to view the rendered diagram.

Please give it a try and generate a Mermaid chart today! We would love to hear your feedback and any suggestions for improving this feature.

📣 See feature ticket to share your feedback and continue the conversation.

Enhanced editor controls ^📣

Discover advanced options for maximizing your editing experience with new margin capabilities.

Developers rely on subtle cues and quick context to stay in flow, and the editor's bottom margin is a key part of that. But until now, it offered limited insight and little flexibility - leaving useful information just out of reach.

We've upgraded the bottom margin to be more informative and customizable. Line, column, and character position are now unified into a single display - and 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 without leaving your flow.

📣 See feature ticket to share your feedback and continue the conversation.

File exclusions in search ^📣

Skip the noise by excluding files you never need to search.

Some files you just never need to look through. Whether it's build artifacts, minified scripts, or generated files, they clutter your search results and slow you down.

You can now exclude them from your searches in Find in Files and Quick Find to focus on what matters.

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.

These exclusions are automatically applied in Quick Find.

For Find in Files, these exclusions are applied in addition to your existing selection in the File types. You can choose to easily toggle the settings level exclusions on or off via the toggle button on the right of the File types.

📣 See feature ticket to share your feedback and continue the conversation.

Familiar keyboard shortcuts ^📣

Use Ctrl+W to close tabs and Ctrl+P for code search - shortcuts that match what you're used to from other editors.

We've added new shortcuts to match what you're used to from other editors and browsers, making Visual Studio feel more intuitive right out of the box.

What's new

• Ctrl+W now closes the current tab (in addition to Ctrl+F4)

• Ctrl+P now opens Code Search (in addition to Ctrl+T)

These additions align Visual Studio with popular editors like VS Code, making it easier to switch between tools without breaking your muscle memory. Your existing shortcuts still work exactly as before.

Note for C# developers

The Ctrl+W shortcut wasn't added to the C# developer profile due to existing conflicts. If you want to use Ctrl+W to close tabs in C#, you'll need to manually remap it in Tools → Options → Environment → More Settings → Keyboard.

Part of a broader effort

This continues our work to make Visual Studio shortcuts more consistent with industry standards. We previously added Ctrl+Shift+P to open feature search and Ctrl+/ to toggle line comments to match other editors. We've been gradually adding shortcuts to reduce friction when moving between different development environments, while keeping all the keyboard shortcuts that Visual Studio users rely on.

You can always view or customize shortcuts by going to Tools → Options → Environment → More Settings → Keyboard.

📣 See feature ticket to share your feedback and continue the conversation.

GitHub Copilot

Copilot URL context

Paste a URL in Copilot Chat to pull in page content for better answers.

Ever felt stuck when a topic doesn't seem to be covered in Copilot's training data? Now you can reference URLs in Copilot Chat to provide more context for your questions, helping Copilot give you better responses.

Reference URLs in your questions

Paste a URL in the prompt box and Copilot will pull information from the web. This helps fill in the blanks when Copilot's training data doesn't cover a topic or when you want to reference a specific resource.

For example, you can ask Copilot to help you write a readme.md file based on best practices on GitHub.

Keep in mind that Copilot can only reference the content of the public URL you provide. It won't access any other resources or links on that page or pages behind authentication. Additionally, it can only pull in static HTML content, so if you reference a dynamic page, Copilot won't be able to access the content.

Important

Activate GitHub Copilot Free and unlock this and other AI features. No trial. No credit card. Just your GitHub account.

Activate GitHub Copilot for free now.

Better Copilot responses ^📣

Experience dramatically improved Copilot responses with enhanced context for code search, external symbol understanding, and precise line number referencing!

Copilot Chat keeps getting smarter with improved context for your everyday tasks! You can expect better results when searching your codebase, understanding dependencies with external symbols, and referencing specific lines in your code.

Improved code search

Copilot Chat's code search capabilities have been enhanced to provide more relevant results. This means you get more accurate suggestions because Copilot is even better at retrieving the right code snippets related to behaviors, concepts, or functionality described in natural language. These improvements are thanks to leveraging remote indexes of your codebases.

Awareness of external symbols

Now Copilot Chat can extend beyond your project to help you with external symbols brought in by your dependencies in C#. With this broader scope of understanding, it can provide you with more effective solutions for your projects.

Better accuracy with line numbers

When you reference a specific line in your code, Copilot Chat will now provide more accurate responses. This means that when you ask Copilot to look at a certain section of the code in natural language, it will be able to give you more precise information.

📣 See feature ticket to share your feedback and continue the conversation.

Important

Activate GitHub Copilot Free and unlock this and other AI features. No trial. No credit card. Just your GitHub account.

Activate GitHub Copilot for free now.

Debugging & diagnostics

Debugger Agent for unit tests

Automating unit test fixes from failure to resolution.

The new Debugger Agent streamlines unit test debugging by combining the power of Test Explorer, Copilot Chat, and the Visual Studio debugger into a fully automated workflow.

Here's how it works: when a unit test fails, simply right-click the test and select Debug with Copilot. This invokes the Debugger Agent, which:

• Collects context from your workspace (test code, related source, recent edits).

• Forms a hypothesis about the root cause of the failure.

• Applies targeted code edits based on its analysis.
• Validates fixes by running the test under the debugger.
• Iterates intelligently if the issue persists, refining its hypothesis using debugger insights and repeating the cycle until the test passes.

Once the failure is resolved, the agent provides a detailed summary of its actions and edits, making it easy for you to review and understand the changes. By automating the heavy lifting, the Debugger Agent reduces trial-and-error, shortens feedback loops, and helps you deliver more reliable code faster - all while keeping you in control of the final review.

Enhanced exception analysis

Exception analysis now leverages your repository context.

Visual Studio's Exception Analysis with Copilot now uses your repository context for smarter, faster debugging. Copilot cross-references your open repo - including past bugs, issues, pull requests, and historical fixes - to deliver insights that matter to your codebase.

With this update, Copilot:

• Identifies likely root causes, impacted components, and potential fixes.

• Surfaces similar past issues so you can learn from existing resolutions.

• Analyzes exceptions in full context, connecting runtime behavior to repository history to explain unexpected values.
• Saves time by reducing manual investigation and trial-and-error during complex debugging.

You get a context-aware, high-precision debugging experience. This is currently available for Azure DevOps, with GitHub support coming soon.

Inline if-statement

Debug if-statements faster with inline values and Copilot Insights.

Debugging is all about quickly understanding your code's behavior, and now a new inline experience for if statements in .NET makes that easier than ever. With this update, you no longer need to hover over variables or step through multiple lines to figure out why and if the condition is evaluated to true or false. Instead, Visual Studio displays the evaluation result inline, right next to the condition itself.

And just like existing inline variable and return values, you can hover over the condition and select Analyze with Copilot. It doesn't just show the final outcome, it breaks down the condition into its sub-expressions.

Copilot explains how each part contributed to the overall result, giving you a clear step-by-step reasoning path.

Inline variables & parameters

Inline values now show method parameters and loops with copilot insights.

Visual Studio now shows method parameter values and loop variables inline while you debug. You get instant, in-context visibility right in the editor.

You don't need to hover or step through lines to see parameter and loop variable values. For complex variables or objects, you can still use DataTips, Visualizers, and other tools to explore deeper.

You can hover over any inline value and select Analyze with Copilot. Copilot explains the value in context and helps you investigate unexpected or incorrect results, giving insight into why the outcome might differ from what you expected.

Inline post-return values

Debug smarter with inline post-return values and Copilot insights.

Visual Studio debugger now displays inline post-return values, showing the actual return values of functions at the point where they're used. This gives you real-time visibility into function behavior without stepping into code or setting up watches, making it faster to catch logic issues or unexpected results.

You can customize what is shown via the right-click context menu, choosing to display returning, returned, or both types of inline values based on your preference.

With GitHub Copilot integration, you can hover over a value and use Ask Copilot to analyze unexpected results, uncover potential root causes, or get suggestions on how to fix issues - all without breaking your flow.

Performance improvements for F5

Debug faster with improved F5 performance.

Launching the debugger with F5 is one of the most common workflows in Visual Studio, and now it's faster than ever. We've made targeted performance improvements to reduce the time it takes to launch the debugger, so you can get into your debug session with less waiting and more coding.

In the demo shown below, you can see the difference firsthand: Visual Studio 2026 with .NET 10 achieves startup times up to 30% faster compared to Visual Studio 2022 with .NET 9 when using F5.

These gains come from optimizations in both the debugger and the .NET runtime, delivering a noticeably smoother experience.

Search in Text Visualizer ^📣

Quickly find text inside long strings while debugging.

You can now search within string values in the Text Visualizer using the new Quick Find feature! Simply press Ctrl+F while the visualizer is open to bring up the search box. Your search terms will be highlighted throughout the string, making it easier to spot important text, errors, or patterns.

Need to read content behind the search box? Hold Ctrl and the search UI becomes transparent, so you never lose sight of the data underneath.

This makes navigating long strings like logs, JSON blobs, or error messages faster and more intuitive during debugging.

📣 See feature ticket to share your feedback and continue the conversation.

Profiler Copilot Agent ^📣

An AI profiler agent that analyzes performance, suggests fixes, and helps you iterate fast.

We are excited to introduce the Profiler Agent in Visual Studio: an AI assistant that helps you understand and fix performance issues without needing to be a profiling expert.

The Profiler Agent works alongside GitHub Copilot to:

• Analyze CPU usage, memory allocations, and runtime behavior

• Surface performance bottlenecks

• Generate new BenchmarkDotNet benchmarks or optimize existing ones
• Suggest and help apply optimizations
• Validate improvements in a guided loop

Getting started is simple. Just ask your question in Copilot Chat (Agent Mode):

• Option 1: Tag @profiler Example: @profiler Why is my app slow?

• Option 2: Ask directly without tagging (enable the Profiler Agent in the Select Tools menu)

Example: Why is my frame rate dropping?

Whether you're new to profiling or a pro, this experience puts AI driven diagnostics at your fingertips. No deep knowledge required - just actionable insights.

Currently supports high CPU usage analysis and .NET object allocations, with more scenarios coming soon.

📣 See feature ticket to share your feedback and continue the conversation.

CodeLens with Optimize Allocations

One-Click Memory Allocation Optimization for your benchmarks.

Previously, you could trigger CPU optimizations for your Benchmark .NET benchmarks directly from the editor using CodeLens. Now you'll also have a one-click entry point to improve memory allocations for the benchmarks.

No need to manually prompt the Profiler agent; just click the CodeLens above your benchmark and you will see an option to Optimize Allocations with Copilot.

This update makes performance tuning more accessible and seamless, helping you spot and fix allocation issues right where you code.

Profiler Agent thread summarization

Profiler Agent's smart summarization with seamless thread continuation.

The latest Profiler Agent update introduces smart summarization with thread continuation, designed to keep your work flowing without hitting token limits. When a chat approaches its token cap, you will be prompted with the option to summarize and continue in a new thread.

The agent automatically generates a concise, context-rich summary of everything important so far and carries it forward into a fresh conversation. Nothing gets lost - critical details, steps, and decisions all come with you.

This update not only reduces token usage, making interactions lighter and faster, but also makes it easier to track progress through quick summaries of the agent's actions. Most importantly, it ensures seamless continuity so you can pick up exactly where you left off without retracing your steps.

BenchmarkDotNet project template

Accelerate performance tuning with the new Benchmark project template and built-in profiling support - get insights faster than ever!

Jump into performance benchmarking with a fully integrated BenchmarkDotNet project template that includes built-in support for CPU Usage profiling and Copilot insights.

Add a new project in Visual Studio and select BenchmarkDotNet Project from the Profiling category. Pick your target .NET version and the template aligns automatically.

Visual Studio scaffolds a fully configured project, complete with benchmark setup and CPU diagnosers.

Once you run your benchmarks, the profiler automatically launches a diagnostics session and you can instantly view CPU usage, call tree data, and performance hot paths - with optional Copilot insights - without leaving your IDE.

CMake diagnostics just leveled up

Profile CPU, analyze File IO, and trace events - now fully supported for CMake projects.

CMake projects now get native support for CPU Usage, Events Viewer, memory usage and File IO tools in Visual Studio - no workarounds, no extra setup. 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 CPU Usage Tool.

• Track runtime events like exceptions, logs, and HTTP requests with Events Viewer.

• Analyze file access patterns, durations, and throughput with File IO Tool.
  

New Profiler launch experience

A cleaner launch page with smarter tool combos and Copilot recommendations.

We've revamped the Profiler Launch Page to make it faster, clearer, and smarter to pick the right tool for your performance investigation.

The redesigned interface has a clean layout with a clear distinction between tools that can run together and those that must run alone - so you always know what's compatible.

Copilot integration provides context-aware recommendations right on the page, helping you choose the best profiler for your scenario. If the default suggestions don't fit, just describe your issue in plain English and Copilot will guide you.

Whether you're new to profiling or a seasoned developer, this upgrade makes it easier to improve your app's performance.

Optimize zero-length arrays

Turn zero-length array insights into action with intelligent Copilot assistance in the .NET Allocation Tool - optimize your memory usage like never before!

The .NET Allocation Tool now integrates Copilot assistance for zero-length array allocations, giving you intelligent, actionable guidance right where you need it most!

When you run the .NET Allocation Tool, the Insights tab will highlight zero-length array allocations - a subtle but often overlooked source of unnecessary memory churn.

Alongside the insight description, you'll see the Ask Copilot button. Click it and Copilot will deliver a detailed analysis of the allocation patterns and suggest concrete code fixes to optimize your memory usage - just like the Copilot auto-insights you already love in the CPU Usage tool!

Git tooling

Inline pull request comments

You can now view pull request comments directly in the diff view and see them rendered with Markdown formatting - making feedback easier to read and understand in context.

The pull request experience in Visual Studio just got better.

Inline comments in pull request diff view

By default, your pull request comments appear in the working file view. You can now also see them in the diff, which lets you view the full picture of the changes.

In the diff view, you can see comments alongside the original and updated code. This makes it easier to see exactly what was changed and why. You can also edit the working file directly in this view.

For example, if a comment suggests adding tests after refactoring, seeing the original code in the diff helps you understand which functionality was moved. Having the original code right there in the diff helps you make sense of the comment faster - no need to go hunting for where the method was moved.

Comments in the diff are supported across different file types, including .cs files. Support is expanding, so if you notice comments not appearing in the diff for a particular file type, please report the issue.

Markdown rendering support in pull request comments

Comments now render using Markdown formatting, making it easier to read and format your feedback.

Try it out

Enable this feature via Tools → Options → Preview Features → Pull Request Comments.

Better code reviews ^📣

Get better GitHub Copilot-powered suggestions for your code changes to help you catch potential issues early and improve your code quality.

Now, with the latest model updates, you can get even better code review comments on your local changes before you even commit!

Same UX with key improvements

1. Enhanced Comment Quality - newer reasoning models mean more insightful and precise code reviews, catching subtle bugs and performance issues that might be overlooked by traditional methods.

2. Optimized Comment Generation - by generating comments for the entire change set at once, rather than file-by-file, you get improved performance and a more comprehensive review.

3. Updated Prompting Techniques - clearer and more direct prompt ensures more accurate and relevant feedback.

Get started

With your Copilot subscription enabled in Visual Studio and the following feature flags enabled, you can see the new sparkle comment button in the Git Changes window. When clicked, Copilot will examine your sets of changes and propose some suggestions inline in your editor.

Ensure you have both of the following feature flags turned on:

• Tools → Options → Preview Features → Pull Request Comments.

• Tools → Options → GitHub → Copilot → Source Control Integration → Enable Git preview features.

📣 See feature ticket to share your feedback and continue the conversation. And take this survey to help make the feature even better.

Note

This feature must be enabled under Tools → Manage Preview Features

Git context in Copilot Chat

Reference your commits and changes in Copilot chat.

Copilot Chat now supports referencing your commits and changes in the Git Changes window. You can ask Copilot to summarize your changes, explain a specific commit, and more!

Reference your changes

#changes looks at your uncommitted changes. For example, you can ask Copilot to remind you of what you've done so far by referencing your #changes.

Reference your commits

When you start typing #commit:, Copilot will pull up a list of the most recent commits for you to select from. If there's an older commit you want to reference, you can also reference its specific commit id.

Then you can ask the chat to use the commit for tasks like write unit tests to cover changes in this commit or find potential issues in this commit.

Try this out

Ensure the following feature flag is turned on to be able to use these references: Tools → Options → GitHub → Copilot → Source Control Integration → Enable Git preview features.

Easier comment navigation in local code review

Code reviews are even easier now with the updated comment list view.

Reviewing your code before committing just got easier.

When you view the Copilot generated comments on your uncommitted changes, you will now see a list of comments in the Git Changes window. You can double click on any comment in the list to navigate to that line of code in your editor.

Stay tuned for the comment list coming to pull requests!

Get started

With your Copilot subscription enabled in Visual Studio and the following feature flags enabled, you can see the new sparkle comment button in the Git Changes window. When clicked, Copilot will examine your sets of changes and propose some suggestions inline in your editor.

To use the local code review, ensure you have both of the following feature flags turned on:

• Tools → Options → Preview Features → Pull Request Comments.

• Tools → Options → GitHub → Copilot → Source Control Integration → Enable Git preview features.

📣 Take this survey to help make the feature even better.

Note

This feature must be enabled under Tools → Manage Preview Features

Apply PR comment suggestions

Skip the copy-paste - apply human or AI-suggested code edits directly in your IDE.

Got a comment asking for a code change?

You can now apply suggested edits directly from the PR comment within the IDE, no need to copy and paste! View the original code, the proposed change, and surrounding context all in one place, so you can evaluate, tweak, and test the fix immediately.

Apply suggested change from a PR comment

Similar to browser PR experiences, you can now instantly apply comment suggestions to your code. Simply click on the sparkle icon at the top right of a comment to incorporate the suggestion to your code, which you can then modify and test as needed before committing.

Request a suggested change from Copilot

If there aren't any suggestions, then you can request Copilot to suggest a change based on the comment. It'll take into account the comment itself and the document context.

Get code suggestions before you commit

Copilot can also suggest code edits based on comments from the local code review experience, helping you resolve feedback and get it commit-ready faster.

Get started

To try out the full experience, ensure you have both of the following feature flags turned on:

• Tools → Options → Preview Features → Pull Request Comments.

• Tools → Options → GitHub → Copilot → Source Control Integration → Enable Git preview features.

Note

This feature must be enabled under Tools → Manage Preview Features

Team Explorer Work Items deprecation

The legacy work items experience in Team Explorer is being replaced with a new, more modern experience.

The legacy work items experience in Visual Studio's Team Explorer has been deprecated. Going forward, work items will no longer open inside Visual Studio but instead in the web portal, where you'll find a modern, more consistent experience. This change aligns with the updates introduced in Visual Studio 2019 and 2022 and ensures that all work item features are available through the web experience.

For more details, see the blog post on work items in Visual Studio.

Cloud

Cloud Services (extended support) deprecation

Important information about the upcoming Cloud Services (Extended Support) retirement and migration guidance to help you prepare.

The Cloud Services (Extended Support) deployment model will retire on March 31, 2027. Consequently, the supporting Cloud Services tooling will be unavailable in Visual Studio 2026.

Until March 31, 2027, Cloud Services (Extended Support) tooling will remain functional in Visual Studio 2022, with general maintenance provided. We strongly advise that you begin planning your migration now to guarantee a seamless transition.

For additional information and detailed instructions on migrating your apps to modern Azure services, please refer to the official announcement.

Service Fabric tools update

Service Fabric tools move out of the box - install them as a VS extension.

Service Fabric tools are no longer included in Visual Studio. You can install the Service Fabric Tools for Visual Studio extension from the Visual Studio Marketplace instead, which will be available soon.

Podman support in Container Tools ^📣

Container tools now support Podman, allowing you to run and manage containers using Podman CLI.

New in this version of Visual Studio, Container Tools now supports 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. All of your typical workflows remain, just with proper support of your currently running container runtime.

Get Started

To get started, simply startup Podman and open your solution in Visual Studio. Container Tools will automatically detect the Podman environment and you're good to go.

Optionally, you can manually select Podman as your container runtime by going to Tools → Options → Container Tools → General → Container Runtime and selecting Podman from the dropdown menu.

Notes

• As part of this change, some settings have been updated to avoid confusion and use more neutral language. For example, DockerfileContext to ContainerBuildContext.

• Compose support is not available for Podman in this release.

📣 See feature ticket to share your feedback and continue the conversation.

.NET

.NET 10 and C# 14

Support for .NET 10 and C# 14 is baked in so you can take advantage of the latest features and improvements in your projects.

We're excited to bring you full support for .NET 10 and C# 14 in this latest version of Visual Studio! This means you can immediately start taking advantage of all the newest language features, performance improvements, and framework enhancements without any additional setup or configuration.

The integration is seamless - simply create a new project targeting .NET 10 or update your existing projects, and you'll have access to all the latest C# 14 language features right in the editor. IntelliSense, debugging, and all your favorite productivity tools work perfectly with the new syntax and APIs. Whether you're building web applications, desktop apps, or cloud services, you can leverage the cutting-edge capabilities that .NET 10 brings to the table.

Visual Studio's compiler and tooling have been updated to provide full support for C# 14's new language constructs, ensuring you get accurate syntax highlighting, error detection, and code completion. This tight integration means you can be confident that your development experience will be smooth and productive as you explore what's possible with the latest version of the .NET platform.

Ready to get started? Create a new project and select .NET 10 as your target framework, or upgrade your existing projects to begin using these exciting new capabilities today!

C++

MSVC Build Tools Version 14.50

New C++ tooling with improved C++23/26 conformance and runtime performance

Microsoft C++ (MSVC) Build Tools version 14.50 is now available, featuring new C++23 and C++26 features, bugfixes, and runtime performance improvements.

New C++ features in the compiler (also see announcement blog post):

• P0849R8 - auto(x): decay-copy in the language

• P2437R1 - Implement C++23 #warning

• CWG Issue 2586 - Explicit object parameter for assignment and comparison
• P2280R4 - Allowing references to unknown values during constant evaluation
• CWG2635 � Constrained structured bindings
• CWG2465 - Coroutine parameters passed to a promise constructor
• P2360R0 - Extends the definition of an init-statement to allow an alias-declaration
• CWG2496 � ref-qualifiers and virtual overriding
• CWG2506 - Structured bindings and array cv-qualifiers
• CWG2507 - Default arguments for operator[]
• CWG2585 - No change required to behavior
• P2290R3 - C++23 Hex/oct delimited escape sequence support in string literals
• CWG2521 - Deprecates operator 'string-literal identifier'
• CWG2528 - Relaxes conversion rules for the spaceship operator
• P2797R0 - Proposed resolution for CWG2692 Static and explicit object member functions with the same parameter-type-lists
• P2266R3 - Simpler implicit move
• Many bugfixes

New features and bugfixes in the standard library: Changelog - microsoft/STL Wiki

Compiler Back-end Runtime Performance Improvements (compared to last release in Visual Studio 2022 version 17.14):

• Up to +6% improvements based on Unreal Engine's City Sample RenderThread benchmark

• Up to +3% improvements based on Unreal Engine's City Sample GameThread benchmark

MSVC Build Tools Windows support

The MSVC Build Tools now require Windows 10 or Windows Server 2016 as the minimum supported operating systems.

The MSVC Build Tools have updated their minimum supported operating systems. With this release, the Build Tools no longer support targeting:

• Windows 7 / Windows Server 2008 R2

• Windows 8 / Windows Server 2012

• Windows 8.1 / Windows Server 2012 R2

To build applications using the latest C++ tools, your target platform must be Windows 10 or Windows Server 2016 (or later).

These changes allow for better performance, enhanced security, and alignment with the most recent Windows platform capabilities.

C++ feature deprecations and removals

Notices of removals for C++AMP, ARM32 toolchain, and /DEBUG:FASTLINK and deprecation of /await.

The deprecations and removal of C++ feature support impact developers using C++AMP, ARM32-targeting MSVC build tools, and the /DEBUG:FASTLINK linker option. If you're utilizing /DEBUG:FASTLINK, it's recommended to switch to /DEBUG:FULL for improved debugging support. Developers needing to target ARM32 can continue using the Visual Studio 2022 v143 build tools as detailed in this Microsoft blog post.

Moreover, the /await switch is deprecated and will be removed in a future release. Developers are encouraged to use Standard C++ coroutines, available by default in C++20 or later. For projects in earlier language modes, consider using /await:strict to maintain compatibility until the switch is removed.

C++ STL updates

Fresh standard library improvements - especially around <regex>. See what's new.

We've made a large set of updates and improvements to our C++ standard library implementation, especially in the area of <regex>. See our STL Changelog for a complete list of changes.

Class View improvement ^📣

Substring search in the Class View.

The Class View window now supports substring searches.

📣 See feature ticket to share your feedback and continue the conversation.

Project template updates

Use C++20 by default in new C++ projects.

Many of the C++ project templates have been updated to build with the C++20 standard by default. This includes the Console App, Windows Desktop Application, Dynamic-Link Library, and Static Library.

Syntax highlighting for attributes ^📣

C++ attributes now shine in your editor with beautiful syntax highlighting that makes your code more readable and visually appealing!

C++ attributes are now beautifully 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, seamlessly integrating with your existing color scheme.

📣 See feature ticket to share your feedback and continue the conversation.

clang-tidy improvements ^📣

Supercharge your C++ code analysis with enhanced clang-tidy configuration options for faster builds and custom workflows.

clang-tidy code analysis has some exciting new configuration options! You can now 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 used to invoke clang-tidy, giving you complete control over your analysis setup.

Access these powerful new options from Project Properties → Code Analysis → Clang-Tidy.

📣 See feature ticket to share your feedback and continue the conversation.

C++ Linux workload rename

C++ Linux workload renamed to 'Linux, Mac, and embedded development with C++'.

The C++ Linux workload in the Visual Studio installer has been renamed to Linux, Mac, and embedded development with C++. This more accurately reflects its expanded capabilities.

The description of the workload has also been updated accordingly.

Debugger command line arguments

Easily set debugger command line arguments for any C++ project.

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 Pass command-line arguments documentation.

Generated Preprocessed output

Generate preprocessed output for any C++ file.

The Single File Preprocess menu in Visual Studio lets you right-click a C++ file 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.

IncrediBuild support

Added IncrediBuild support for Visual Studio 2026, including the latest IncrediBuild engine and updated extension.

This release contains an update to the IncrediBuild support that includes the latest version of the IncrediBuild engine and an updated extension that works with Visual Studio version 18.0.

CMake support for Visual Studio 2026 Generator

Visual Studio 2026 ships with the latest CMake versions to provide our latest build system capabilities for CMake projects.

Visual Studio 2026 now includes CMake 4.1.2 by default. You can now use CMake with the latest Visual Studio 2026 generator and SLNX projects. This update lets you build with the Visual Studio 2026 toolset and SDKs directly from CMake, making upgrades easier.

AddressSanitizer support for ARM64

Build with MSVC and /fsanitize=address for ARM64 targets.

For some time, the Microsoft C++ (MSVC) Build Tools have supported building projects targeting x64 and x86 with AddressSanitizer, which allows you to identify hard-to-find bugs with zero false positives at runtime and increase memory safety.

You can now use AddressSanitizer with MSVC to target ARM64. This feature is in preview, so you might run into some bugs. If you do, please report them using Help → Send Feedback → Report a Problem in Visual Studio.

---

From our entire team, thank you for choosing Visual Studio! For the latest updates, resources, and news, check out the Visual Studio Hub and stay in touch.

Happy coding!
The Visual Studio team

Note

This update may include new Microsoft or third-party software that is licensed separately, as set out in the 3rd Party Notices or in its accompanying license.