Visual Studio Insiders release notes

Reveal files from Solution Explorer's Solution Items in File Explorer, even when you haven't opened them in the editor.

You can now locate files under Solution Items in File Explorer directly from Solution Explorer. Right-click a file and choose Open in File Explorer to open its containing folder with the file selected.

The command works even if you haven't opened the file in the editor or the file links to a location outside the solution folder. It uses the file you selected in Solution Explorer, not the active editor document.

Select a single file to use the command. It doesn't appear for virtual folders or multiple selections; existing folder exploration remains unchanged.

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

Solution Explorer's File System view displays multiple configured workspace roots so you can browse and search files across repositories in one hierarchy.

Solution Explorer's File System view now supports multiple configured workspace roots. A solution spanning several repositories or source folders can display those roots in one hierarchy, with search across all configured locations.

The solution's WorkspaceFolder property accepts an ordered, pipe-separated list of roots. For example, ..|OtherRepo includes the parent folder and a folder named OtherRepo relative to the solution. Absolute paths are supported too.

Visual Studio resolves relative paths from the solution location, removes case-insensitive duplicates, and preserves the root order in saved workspace state. Each root has its own file-system watcher to keep the view current. Existing single-root solutions retain their behavior and the repository-or-solution-folder fallback.

This feature requires File System View in Preview Features in Preview channels. Restart Visual Studio after changing the option.

Edit grouped settings tables, navigate Extension Manager with assistive technology, and distinguish secondary text in Dark theme.

Visual Studio improves settings-table editing, Extension Manager accessibility, and text hierarchy in Dark theme.

Edit grouped settings tables

Updated Options pages that use settings tables let you edit or reset a selected row through a validated dialog with Save and Cancel. Non-Boolean values can now be editable too. Nested groups keep related controls together, customized rows appear in bold, and previews follow the selected row's native setting value.

Tables can use the available page height. Read-only and out-of-scope settings remain protected, and unsupported reset actions stay hidden. Existing setting names and storage don't change.

For example, Fonts and Colors displays item settings and previews in a table:

Navigate Extension Manager accessibly

Extension Manager exposes clearer accessible control names, roles, and filter-toggle states. Keyboard and screen-reader users can identify controls and active filters more easily. Pressing Ctrl+L to focus search now preserves the query you've entered.

Distinguish secondary text in Dark theme

Dark theme uses a more distinct secondary-text color on surfaces that use Visual Studio's shared text styling. Supporting labels and descriptions stand apart from primary content while retaining more than 4.5:1 contrast on the applicable backgrounds checked by this change. This doesn't recolor editor syntax or unrelated custom surfaces.

Paste images, format text with shortcuts, and navigate local links in Visual Studio's Markdown editor.

The Markdown editor now supports Go To Definition and Peek Definition for links to local files. You can move between related documents or view a linked file without leaving the document you're editing.

Open a linked file

Place the caret on a link and press F12 to open its target. If the link points to a Markdown heading, such as [Installation](guide.md#installation), Visual Studio opens the file and moves to that heading. Links to headings in the same document, such as [Installation](#installation), work too.

Peek at a linked file

Press Alt+F12 to view the linked document inline with Peek Definition. Markdown files keep their syntax highlighting, and the Peek view doesn't include the split preview.

Both commands support inline and reference-style links. Links to other local file types open normally, without Markdown heading navigation. Web links and image links aren't part of this change.

Paste images

Paste a clipboard image or a PNG, JPEG, or GIF file copied from File Explorer into a saved Markdown document. Choose a destination and PNG, JPEG, or GIF format in the Save File dialog, and Visual Studio inserts a relative image link with escaped spaces. The dialog selects the source format by default when it can.

Save the document first so Visual Studio can calculate the relative path. Other clipboard content keeps the usual Paste behavior.

Format text and task lists

Select text and press Ctrl+B for bold or Ctrl+I for italics. Use Ctrl+1 to toggle task-list formatting on a list item. The commands also work across multiple selections.

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

The editor minimap shrinks in narrow views, and the scrollbar menu gives you direct control over minimap and annotation display.

The editor minimap now shrinks proportionally as a text view becomes narrow. This leaves more room for code when you work with side-by-side documents or other compact layouts.

Widening the editor restores the desired minimap width. Visual Studio respects your configured maximum width and the existing 25-DIP minimum, so you don't have to change the setting when rearranging documents. Classic scrollbar mode keeps its existing behavior.

Adjust display from the scrollbar

Right-click the vertical scrollbar to toggle Show Minimap, Show Caret Position, Show Changes, Show Errors, and Show Marks, or open Advanced Settings. Checkmarks reflect your current settings, and the five toggles keep the menu open so you can adjust several choices together.

The menu retains the standard scrollbar navigation commands and also works in supported multi-file diff views. These are ordinary editor display settings, not Preview-feature options.

The new Copilot Chat experience adds agent management in AI Customization and makes eligible custom agents available for delegation.

The new Copilot Chat experience lets you manage custom agents in AI Customization and make eligible agents available for delegated work.

Manage custom agents

Create and maintain custom agents without reopening Chat to refresh the picker. Open Agents in AI Customization to create, edit, or delete an agent. The page and picker use the same catalog for the active session, so your changes appear in both places.

New agents use the active session's Git workspace when one is available, or your user profile otherwise. An agent stored in a workspace appears while that workspace is open for the session. Keep that scope in mind when deciding whether an agent belongs with a particular repository or in your personal setup.

Delegate to custom agents

New Chat sessions include registered user, workspace, and organization agents that support inference when preparing delegated work. Another agent can use your eligible specialized agent as a subagent without requiring you to open it manually first.

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

The new Copilot Chat experience creates instruction files from AI Customization and opens them for editing.

In the new Copilot Chat experience, create a named instruction file or a default copilot-instructions.md from AI Customization. Visual Studio offers destinations from the current session, creates the file on disk, and opens it for editing.

Creation never overwrites an existing file or automatically adds the file to a project. Browsing existing instruction sources remains available on the same page.

The new Copilot Chat experience lets you choose a session's working directory without changing the open solution.

In the new Copilot Chat experience, point a session at a different folder without changing the solution you have open. In the main Chat window, choose Session actions → Change session working directory, then select the folder for that session. Visual Studio keeps the folder-trust approval workflow; cancelling the picker leaves the session unchanged.

To check which folder a session uses, hover over its title to see the full working directory. This also works on popped-out tabs, while the folder-picker action remains in the main Chat window. The main header exposes the directory context to screen readers too.

Copilot Chat model management adds a dedicated provider for OpenAI-compatible custom endpoints and migrates existing custom-URL connections.

Copilot Chat's model-management experience now includes a dedicated OpenAI-compatible provider for custom endpoints that implement the OpenAI API protocol. Use it to connect a compatible service without treating it as the hosted OpenAI provider.

The provider handles whether the endpoint requires an API key. Existing OpenAI configurations with a custom URL migrate automatically to the new provider, preserving their connection settings.

Your endpoint still determines which models, request formats, and capabilities are available. Choosing the provider doesn't add capabilities that the service doesn't support.

The new Copilot Chat experience adds structured MCP forms, code navigation links, more precise trust behavior, and support for Visual Studio's proxy settings.

The new Copilot Chat experience makes it easier to answer tool requests, follow references into your code, use trusted workspace tools, and connect through a configured proxy.

Answer MCP forms in Chat

MCP tools can pause a conversation to request structured input. Fill in the form in Chat and submit it to continue. Your answers keep their expected types instead of becoming a single text response.

Dismissing a form declines the request. Ending the turn or closing the session cancels a pending form. Unattended sessions, URL-based prompts, and unsupported form schemas decline without displaying a form.

Follow links into your code

Follow file and symbol links in Copilot responses to open the referenced code in Visual Studio. Enable navigation links starts enabled in the new Chat experience and controls both code and debugger navigation links. A link must identify a supported location that Visual Studio can resolve.

Use tools from trusted paths

MCP servers configured under persistently trusted paths, and their tools, are now enabled by default without a separate enabled-server entry. For example, a trusted repository's mcp.json can make its tools available when you open the workspace.

Explicitly disabling a server or tool still takes precedence, and other availability restrictions remain in effect. Trust changes update these defaults, including after you close and reopen the solution.

Keep new-solution trust scoped to the solution

Newly created, non-temporary solutions no longer require you to trust a broader parent folder for Copilot. Temporary sessions use the current solution's trust, then recheck persistent Copilot trust when they become persistent. This keeps unrelated repositories outside the solution's trust scope.

Use Visual Studio's proxy configuration

The new Chat experience now uses Visual Studio's resolved proxy configuration. To configure a proxy in the IDE, enable Proxy configuration as a setting in Preview Features, then restart Visual Studio. This Preview option starts disabled.

Existing HTTP_PROXY and HTTPS_PROXY environment variables take precedence. Manual proxy settings preserve their scheme and explicit credentials, but this path doesn't forward Windows default credentials for integrated proxy authentication.

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

Open Copilot sessions faster, start language servers independently, and reduce startup and .NET project-load work without changing your settings.

Visual Studio reduces upfront work when you open Copilot conversations, start language servers, use the Start Window, and load .NET projects.

• Open Copilot sessions faster. The new Chat experience precompiles more session code. Measurements of the changed paths showed the session list loading about 40% faster and a long session opening about 60% faster. These results describe the tested session-loading scenarios, not model response times.
• Delay collapsed Dependencies work. .NET projects don't construct a collapsed Dependencies subtree until you expand it. Dependency data and diagnostic icons stay current in the background, and expanding the node uses the retained snapshot.
• Reduce Start Window setup. The Start Window delays tooltip construction and avoids unnecessary visual and subscription work. Recent projects, pinning, actions, and tooltips keep their existing behavior.
• Avoid provisional target-framework loads. For ambiguous or expression-based .NET target-framework declarations, Visual Studio can use a trustworthy, matching project.assets.json to choose the initial framework. Direct declarations take precedence; missing or invalid assets fall back to the previous behavior. This doesn't perform restore or change declared frameworks.
• Start language servers independently. A slow language server no longer blocks unrelated clients from starting or stopping. Each client still waits for its own previous cleanup, and closing a solution cancels its pending startup work. This improves startup coordination, not a server's own initialization time.
  

Organize Watch expressions, inspect Copilot evaluations in Autos groups, and follow Chat links to debugger state.

The debugger adds expression organization in Watch and makes Copilot's successful evaluations visible in Autos.

Rearrange Watch expressions

Keep related expressions together in Watch without deleting and re-entering them. Select a top-level expression and press Alt+Shift+Up or Alt+Shift+Down to move it. You can also drag expressions, select several to move together, or hold Ctrl while dragging to copy instead of move.

Reordering applies to top-level Watch rows, not expanded child values or every debugger variables window.

Inspect Copilot evaluations in Autos

Inspect the values Copilot successfully evaluates through the debugger alongside other variables. Visual Studio adds those expressions to Autos, grouped by their stack frame, so you can see which stopped context produced each result.

Groups appear when the associated frames are visible rather than hidden under External Code. Visual Studio clears them when execution resumes, except for function evaluation, so old results don't stay mixed with the next stopped state.

Add Copilot evaluations to the Autos window controls this behavior and starts enabled by default.

Follow Copilot links to debugger state

In the new Copilot Chat experience, follow links in debugger responses to inspect the values behind an explanation. Evaluation links open results in Autos; local-variable links open the appropriate debugger window and switch frames when needed. Call-stack links can select frames on the current thread or another thread.

Enable navigation links controls both code and debugger links and starts enabled in the new Chat experience. Evaluation links apply to the current debugging state and expire when execution resumes, except during function evaluation.

After you follow an evaluation link, inspect the returned values in Autos:

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

Copilot's built-in Profiler subagent investigates performance with representative workloads and captured measurements.

Copilot's built-in Profiler subagent can investigate performance in the new Chat experience without requiring you to select a custom agent first. Ask Copilot to investigate a slow scenario or excessive allocations, and it can delegate measurement work to the Profiler.

The discovery workflow identifies useful application scenarios, reuses or creates representative workloads, and returns ranked optimization targets backed by captured evidence. It uses CPU profiling by default and routes explicit allocation-only requests to allocation analysis. Discovery itself doesn't modify production code.

For managed Instrumentation collection, the Profiler can generate a validated plan for one assembly or selected classes and methods. Those plans apply only to the Instrumentation profiler. Saved traces and replayable evidence support follow-up optimization work.

Copilot's Debugger Agent can inspect and interact with running desktop and web app interfaces.

Copilot can now interact with your running app as part of the Debugger Agent experience. It can capture screenshots, inspect the UI tree, and interact with controls to gather context beyond code and debugger state. The agent uses UI Automation for desktop apps and Playwright for web apps.

These capabilities help Debugger agent to investigate issues that depend on user interactions or application state. It can reproduce workflows, connect visible behavior to runtime evidence, and help identify the underlying cause.

After a correction, it can replay the affected workflow to help verify the fix - reducing repetitive manual steps and keeping the investigation grounded in how the app actually behaves.

Visual Studio's Linux nettrace analysis recovers matching native symbols that weren't available during collection.

Visual Studio's Linux nettrace analysis can now resolve native CoreCLR and application frames when matching symbols weren't available during trace collection. This helps you identify native work instead of interpreting raw addresses.

During analysis, Visual Studio uses ELF build IDs and module mapping information to locate matching binaries or debug files, validates their identity, and resolves native address ranges. It also demangles supported Itanium and Rust symbol names.

Symbols already included during collection continue to work as before. Recovery still requires matching binaries or debug files; Visual Studio won't accept an unmatched file or guarantee that a symbol server contains every module.

Adjust reviewer requirements, see file comments in the pull-request overview, distinguish worktrees, and show line annotations in multi-file diffs.

Visual Studio improves Git and pull-request workflows, including multi-file diff review.

Change reviewer requirements

Adjust an Azure DevOps reviewer's requirement without leaving Visual Studio. In the pull-request experience, adding a reviewer will set them as optional by default. Right-click and choose Make required to change the requirement.

See file comments in Overview

The pull-request Overview now brings file comments and general discussion together, so you can find review feedback in one place. Select a file link to open the corresponding diff and view the comment in context.

Distinguish worktree names

Worktrees in different parent folders can end in the same name, making them hard to tell apart in a picker. Visual Studio now shows the shortest unique trailing path in worktree UI and dialogs, adding only enough parent-folder context to distinguish each one.

The labels handle case-insensitive name collisions without renaming your folders or branches. This uses Git: Worktrees Support, which starts enabled by default in Preview Features.

Show line annotations in multi-file diffs

Use Show Line Annotations while reviewing a multi-file diff. Focus an inline or side-by-side comparison and press Ctrl+K, Ctrl+M to invoke the existing command for that file, without opening a separate comparison. This adds command support to multi-file diffs, not a new annotation provider.

The local code review experience brings your changes and feedback together in Visual Studio so you can refine code before committing.

Review and iterate on your local changes in Visual Studio similar to a pull request. Explore diffs, leave comments, and ask Copilot to turn your feedback into code changes.

1. Open local review. Go to View → Git Repository, select a commit in the history, and choose Review changes since this commit.
2. Review and iterate with Copilot. Leave comments just like you would for a PR. Then use chat to get Copilot to address local comments and it will address each of them and reply in the comment thread with how they were addressed.
3. Generate change groups to explore related changes together.
4. Validate and commit. When you're happy with the changes and validated your code, use Git Changes to stage, commit, and push as usual.
   

Save a finished piece of work for later without putting your other changes on hold.

You now have more flexibility to choose which changes to set aside in Git Changes. Alongside Stash All and Keep Staged for your unstaged changes, Stash Staged Only does the reverse by saving your staged changes for later.

Stage the changes you want to stash in Git Changes. Optionally enter a stash message in the message box, then open the commit dropdown and choose Stash Staged Only.

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

Keep the PR overview, files, and comments visible alongside your code as you work.

Check out a PR to move between its overview, files, and comments without losing sight of your code.

To check out a PR, open it in Git Repository and select Checkout. If its branch is already checked out, Show in Working Tree appears instead. You can also open the PR for your current branch with Show Pull Request from the PR dropdown in Git Changes.

Browse the PR's overview, files, and comments in the docked window. Open a file or compare it with the previous version in the editor. Since you're working on the checked-out branch, you can also use editor features like Go To Definition and Find All References to explore the code.

The checked-out PR details experience is now enabled by default. It remains controlled by Checked-Out Pull Request Tool Window under Tools → Options → Environment → Preview Features. If you previously disabled the option, enable it to see Checkout.

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

Test Explorer shows when a test result was last generated, helping you identify stale results.

Test Explorer now shows when a selected test result last ran, helping you determine whether a passing or failing result is still current.

Select an individual test to see Last run with the local date and time in Test Detail Summary. After a test run finishes or is aborted, the Test Explorer status bar also displays its completion time.

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

Test Explorer runs eligible tests while another app is debugging and preserves message severity from supporting Microsoft.Testing.Platform servers.

Run ordinary Test Explorer tests from existing binaries while an unrelated application remains attached to the debugger. Eligible coverage runs and runs without Hot Reload can use the same no-build path.

Visual Studio asks for consent by default. You can remember your answer for future runs during debugging without changing the separate global Skip Build preference. Debug, Profile, and commands that require a build keep their restrictions. Missing outputs or invalid test sources still prevent execution. Cancelling a test operation doesn't stop an unrelated application's debugger.

The On Run, when the debugger is attached setting offers Launch old version, Do not launch, and Prompt to launch.

Preserve MTP message severity

Test Explorer now displays user-facing output from supporting Microsoft.Testing.Platform (MTP) servers at its intended severity, including informational and formatted session messages. These messages appear in test output, not popup dialogs.

The client and server negotiate this capability. Older servers keep their existing logging fallback, including its informational downgrade. Application stdout and stderr remain captured separately; duplicate console and protocol messages are still possible depending on the server's behavior.

Code Coverage Results keeps hierarchical rows and column headers aligned in one grid with keyboard and screen-reader support.

Code Coverage Results now uses an integrated hierarchical grid, keeping column headers and rows aligned. It preserves lazy loading, sorting, saved column layouts, copying, context menus, and source navigation.

Double-click an expandable row to open or close it; double-click a method row to navigate to source. Keyboard and screen-reader support expose table headers, hierarchical rows, contextual cells, and sort-state changes.

Test Explorer honors launch-profile environment variables for Microsoft.Testing.Platform tests without duplicating them in runsettings.

Microsoft.Testing.Platform tests run from Test Explorer now honor environment variables from the project's launch profile. Visual Studio uses the first profile whose commandName is exactly Project, in file order. launchSettings.json under AppDesignerFolder takes precedence over <project-name>.run.json.

Profile values override inherited environment variables, and explicit runsettings override profile values. C#, Visual Basic, and F# MTP projects share this behavior; legacy VSTest doesn't change. This support covers environment variables, not launch arguments, working directories, or browser settings. Explicitly rediscover tests if discovery depends on variables you've changed.

For example, a test can read a profile-defined environment value without duplicating it in runsettings.

Visual Studio's HTML editor completes modern markup and element ID references to help you write valid attributes and values.

Visual Studio's HTML editor now recognizes more modern markup in IntelliSense. Its updated schema adds completion for the <camera>, <install>, <microphone>, <model>, and <usermedia> elements, along with new global and element-specific attributes.

When editing scripts and links, you can also get value suggestions for <script type="importmap">, <script type="speculationrules">, and <link rel="modulepreload">. These additions help you write newer HTML without having to remember every element, attribute, or value. Browser support for individual features varies.

Complete element ID references

When an attribute references another element's id, IntelliSense suggests matching targets from the current document. For example, a label's for attribute suggests compatible controls, while list suggests datalists.

Suggestions also cover form, headers, popovertarget, and ARIA ID references. For attributes accepting several IDs, completion replaces only the ID you're editing. Suggestions stay current as you add, change, or remove elements and IDs.

Visual Studio's HTML editor navigates from class and ID references to their CSS, SCSS, and LESS definitions.

Visual Studio's HTML editor now lets you navigate from a class name or ID in an HTML class or id attribute to its stylesheet definition. Place the caret on the name and press F12 for Go To Definition, or press Alt+F12 to view the definition inline with Peek Definition.

Navigation searches CSS, SCSS, and LESS stylesheets. If a name has multiple definitions, you can choose among the matches. It also works in Open Folder workspaces, including when a stylesheet is outside the HTML file's directory.

This change covers class and ID references in HTML, not variable references within SCSS files.

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

Visual Studio's HTTP file editor improves URLs, variable resolution, template escaping, and refreshed local secrets.

Visual Studio's built-in HTTP file editor now makes it easier to send requests with readable URLs, dependent variables, literal template placeholders, and up-to-date local secrets. Endpoints Explorer also generates valid host variables for project names containing spaces or hyphens.

Send readable URLs

You can leave spaces and Unicode characters in a request URL instead of manually encoding them. Visual Studio keeps the readable URL in the file, sends an encoded URL, and treats the complete URL as one clickable link without including an optional HTTP version.

Resolve nested variables when sending

Variables defined using other variables, including dynamic expressions, now resolve when you send a request that uses them. For example, a request using {{email}} can resolve @email={{user}}{{postfix}}@example.com when postfix is dynamically evaluated. A response-dependent variable for a later request no longer blocks an earlier request. Requests that reference unresolved variables still report an error.

Inspect variables on hover

Hover over a variable to inspect its available value, including aliases and file-defined variables. Named-request values come from the last successful request in the current editor session. Dynamic variables explain when Visual Studio generates their values, and known secrets stay masked.

Hovering doesn't send a request, generate a new dynamic value, or refresh a secret or external value provider.

Chain JSON array values

Named request and response bodies now support root-array indexes and [*] projections. For a response such as [{"ID":11},{"ID":22}], {{prepareData.response.body.$[0].ID}} resolves to 11.

Use a projection such as {{allBatches.response.body.$.batches[*].batch_id}} to insert an array of matching values into a later request. Projections preserve JSON value types and always return arrays, even with zero or one result. Existing property, header, raw-body, and XML chaining still work; filters and quoted-property selectors remain unsupported.

Send literal template placeholders

In .http and .rest files, write \{{name}} to send {{name}} literally while other variables in the same request still resolve normally. This lets you send template content without an undefined-variable error or an unwanted substitution:

@subject = Welcome

POST https://localhost:5001/templates
Content-Type: application/json

{
  "Subject": "{{subject}}",
  "Text": "Hello, \{{name}}!"
}

The outgoing body contains "Subject": "Welcome" and "Text": "Hello, {{name}}!". The editor removes the escape backslash before sending, even if an HTTP variable named name exists. The escape also works in URLs, header values, and declared variable values. Unescaped placeholders keep their normal lookup and error behavior.

Use updated local secrets on the next send

After updating and saving an ASP.NET user secret in Manage User Secrets, select Send Request again to use the new value without editing or reopening the HTTP file. This also works for values referenced through aliases and .env references such as {{$dotenv API_TOKEN}}.

Only the selected request's external dependencies are refreshed. Missing or unreadable referenced values fail the request instead of reusing an old value. Hover previews remain masked for secrets and don't trigger a refresh; remote providers keep their cache intervals.

Generate valid host variables

In Endpoints Explorer, Generate request now replaces unsupported project-name characters with underscores in both the host variable declaration and its reference. For example, Example-project produces @Example_project_HostAddress, so the generated request is ready to send. Supported letters, digits, underscores, and periods remain unchanged, and dotted names no longer match unrelated declarations when updating an existing file.

📣 See feature ticket 1, feature ticket 2, feature ticket 3, feature ticket 4, feature ticket 5, feature ticket 6, feature ticket 7, feature ticket 8, feature ticket 9 to share your feedback and continue the conversation.

Visual Studio's HTTP file editor decodes gzip and deflate responses so you can read their bodies in the response panel.

Visual Studio's HTTP file editor automatically negotiates and decodes gzip and deflate responses while preserving explicitly authored Accept-Encoding headers. The response panel retains the original status and headers and displays the decoded body.

Brotli and other unsupported encodings produce an explicit diagnostic instead of unreadable text. Invalid compressed bodies fail without retrying the request or supplying a body for named-request chaining. Decoded bodies have a 100-MiB limit.

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

Fill custom-snippet fields, preserve complex-block indentation, and navigate to literal file paths in Razor.

The Razor editor improves custom-snippet expansion and formatting in mixed-language blocks.

Fill custom-snippet fields

Custom HTML snippets now keep their editable fields and tab stops when you expand them in Razor. Instead of leaving plain default text to find and replace, Visual Studio selects the snippet's fields and lets you move between them with Tab.

Repeated references to the same field share a tab stop, so you don't have to step through each occurrence as a separate field. Existing snippets with editable literal declarations work without a rewrite.

Preserve indentation in complex blocks

Formatting no longer repeatedly shifts indentation in script and style blocks that contain complex Razor expressions. Visual Studio safeguards these blocks by skipping formatting that can't reliably interpret the mix of Razor and JavaScript or CSS.

The option starts enabled in advanced Razor settings and covers document, selection, and on-type formatting paths that use it. This preserves affected blocks instead of trying to reindent them on every pass; it doesn't replace the JavaScript or CSS formatter or address every Razor formatting issue.

Navigate to literal file paths

Use Go To Definition (F12) on a literal file path in an HTML or Tag Helper attribute, or in a C# string literal, to open the referenced local file. Navigation now covers existing stylesheets, scripts, images, and other files rather than only Razor targets.

Paths beginning with ~/ look in the project's wwwroot first, then fall back to the project root. Ordinary relative paths resolve from the current Razor file, and literal percent sequences remain part of the filename. External URLs and dynamic expressions keep their normal definition behavior. No new option is required.

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

Razor's Preview @documentation directive lets you document a component or view alongside its markup.

Razor's Preview @documentation directive lets you document the generated class for a component or view in its markup file. You no longer need a separate code-behind file solely to add class documentation.

The editor supports XML and cref completion, a summary snippet, semantic coloring, folding, and documentation-aware formatting and typing. Code actions can escape unsafe comment terminators, make legacy expressions explicit, or wrap plain text in a summary.

This feature requires Razor language version 12 or later. Razor 12 is currently the Preview language version; the default latest version remains 11. Select the Preview Razor language version in your project to use the directive.

Visual Studio's HTTP file editor sends inline GraphQL queries and JSON variables without a manually constructed envelope.

Visual Studio's HTTP file editor now sends inline GraphQL requests. Add X-Request-Type: graphql to a request and put the query in its body:

POST https://localhost:5001/graphql
Content-Type: application/json
X-Request-Type: graphql

query {
  books {
  title
  }
}

To supply JSON variables, place them after a blank line following the query. HTTP-file variables resolve before Visual Studio serializes the GraphQL payload:

@bookId=42

POST https://localhost:5001/graphql
Content-Type: application/json
X-Request-Type: graphql

query Book($id: ID!) {
  book(id: $id) {
  title
  }
}

{
  "id": "{{bookId}}"
}

Visual Studio supplies the operation name for a leading named query and removes the marker header before sending. Missing queries and malformed variables produce diagnostics. This support covers inline request execution, not schema-aware GraphQL IntelliSense, external-file query bodies, or streaming subscriptions.

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

Visual Studio's HTTP file editor supports Windows authentication and testing HTTPS endpoints with untrusted certificates.

Visual Studio's HTTP file editor now supports Windows authentication using the identity running Visual Studio and accepts untrusted server certificates for HTTPS testing. Opt in to Windows authentication for an individual request with a bare Authorization: Negotiate or Authorization: NTLM header:

GET https://intranet.example.com/api/me
Authorization: Negotiate

The endpoint must support the selected scheme and authorize your Windows identity. Requests without the opt-in header keep their existing authentication behavior.

Windows-authenticated requests require HTTPS outside loopback; local development can use an address such as http://localhost:5000. Visual Studio restricts credentials to the resolved origin and selected scheme, doesn't follow redirects, and bypasses proxies for these requests.

URLs containing user information and explicit Host overrides are rejected. These restrictions keep an opted-in request from forwarding your Windows credentials to another destination.

Test HTTPS endpoints with untrusted certificates

Select Send Request in a .http or .rest file to test an HTTPS endpoint with a self-signed, expired, or hostname-mismatched server certificate. The editor accepts these certificates automatically, without a setting or changes to certificate trust. This applies to ordinary requests as well as Windows-authenticated requests and doesn't change certificate validation in other Visual Studio features or applications.

HTTPS traffic remains encrypted, but the HTTP editor no longer verifies the server's identity. Send sensitive data or Windows credentials only to endpoints you trust. Server authentication requirements, required client certificates, and other TLS protocol failures can still prevent a request from completing.

📣 See feature ticket 1, feature ticket 2, feature ticket 3, feature ticket 4, feature ticket 5 to share your feedback and continue the conversation.

NuGet tries credential providers before asking for a username and password and initializes providers only when needed.

If your NuGet feed uses a credential-provider plugin, Visual Studio now gives the provider a chance to sign you in before asking for a username and password. Previously, you could see a manual credential prompt first and have to dismiss it before the provider ran.

When the provider authenticates you, you can continue without that unnecessary prompt. If it can't, Visual Studio still offers the normal credential dialog. This ordering applies automatically; you don't need to enable a new setting. Proxy authentication keeps its separate workflow.

NuGet also initializes credential providers only when it needs authentication, rather than loading their credential assemblies early in the session.

This addresses the reported credential-provider ordering issue.

Large C# compilations spend less time looking up namespaces, with no source or settings changes.

Very large C# compilations can spend less time resolving namespaces when many files contain using directives. The compiler no longer repeatedly scans every namespace declaration for those lookups, avoiding work that grew disproportionately as the file count increased.

You don't need to change your source, replace per-file using directives with global usings, or enable a setting.

In the fix's synthetic benchmark, a local Release build produced these declaration-diagnostics timings with concurrent compilation disabled:

Source files	Before	After
32,000	3.88 seconds	0.86 seconds
64,000	14.48 seconds	1.57 seconds

These measurements cover declaration diagnostics for this benchmark, not the entire build. Your improvement depends on the size and structure of your compilation.

Paste generic C# names into cref attributes without manually replacing angle brackets with braces.

Copy a generic type or method name from C# code and paste it into a cref attribute in an XML documentation comment. Visual Studio now converts angle brackets to the braces that documentation references expect, so you don't have to fix them by hand.

For example, pasting Dictionary<string, List<int>> produces Dictionary{string, List{int}}. The conversion handles nested generic names and works when you replace a selection within the attribute value.

Press Ctrl+Z once to undo just the conversion and keep the original pasted text. Visual Studio records the conversion separately from the paste.

This applies to a single cref value in C#. Other XML attributes and comment text stay unchanged, and Visual Studio skips conversion if the pasted text contains quotes or line breaks. Visual Basic isn't affected.

Read reduced-scale Windows MAUI previews more clearly and manage XAML preferences in the updated Options experience.

Visual Studio improves reduced-scale Windows MAUI previews and brings existing XAML preferences into the updated Options experience.

Read reduced-scale MAUI previews

Windows MAUI XAML Live Preview now uses linear downscaling below 100% zoom, keeping text and fine details clearer when you fit a large app surface beside your editor. Keep using the existing zoom controls; no XAML or project-setting changes are required.

At 100% zoom and above, rendering keeps its previous interpolation. Android and other image-stream previews don't change, and preview scaling doesn't alter your application's layout or runtime scale.

Manage XAML miscellaneous options

The eight visible XAML miscellaneous editor options now appear in the updated Options experience. Existing defaults and profile synchronization remain intact, so you don't need to recreate your preferences after the move.

Keep your folder open as CMake presets files appear or disappear and Visual Studio switches configuration experiences.

Keep your CMake folder open when you switch branches that use different configuration formats or introduce presets into an existing project. Visual Studio now updates the active configuration experience as presets files appear or disappear, without a close-and-reopen step.

When you configure Visual Studio to use CMake presets when available:

• Adding CMakePresets.json switches to the presets-based experience.
• Removing it lets Visual Studio return to the settings-based experience when appropriate.
• Visual Studio also watches CMakeUserPresets.json for changes.

If you've explicitly disabled presets, Visual Studio preserves that choice instead of switching modes just because a presets file appears.

Inspect the header dependencies represented by a C++ include and navigate to them from CodeLens.

Explore the headers represented by an include without leaving the editor to search for each file. C++ include diagnostics now show a CodeLens indicator above an include directive, with a count of the files in its graph.

Expand the indicator to browse the header list. Hover over an entry to check its full path, then double-click it to navigate to that file. The full-path tooltip helps distinguish headers that share a filename.

The list represents the graph used by include diagnostics, not a separate dependency analysis or a guaranteed complete list for every project.

You need to enable C++ include diagnostics to provide the graph data. Include diagnostics starts disabled by default.

Build larger native PDBs, detect unused libraries, and use more compatible C and sanitizer options.

The C++ toolchain adds capacity for large native builds and more control over compatibility and diagnostics.

Build larger PDB type and ID streams

PDBs with the existing 4-GB stream capability now support type (TPI) and ID (IPI) streams up to just under 4 GB. This extends the earlier symbol-record support rather than adding another opt-in switch. PDBs without the capability keep the 2-GB limit.

When either stream crosses 2 GB, saving raises the PDB version so older tools reject the file cleanly instead of misreading it.

Warn about unused libraries

Enable /WARNUNUSEDLIBS to receive LNK4324 for each input library from which the linker loads no members. Unlike /VERBOSE:UNUSEDLIBS, this produces a normal warning that can participate in your build policy, including on successful incremental links.

Use /IGNORE:4324 to suppress the warning, or /WX or /WX:4324 to treat it as an error. Builds that don't enable the new switch keep their previous warning behavior.

Use C array-parameter qualifiers

The C compiler now accepts type qualifiers and static inside the brackets of array parameter declarations. Qualifiers apply to the adjusted pointer type. A static bound expresses the minimum accessible-element requirement; it doesn't insert runtime bounds checks or add general variable-length-array support.

For example, this declaration qualifies the adjusted pointer as const:

void func(int array[const 10][20]);

It is equivalent to:

void func(int (*const array)[20]);

Use a static bound to require access to at least ten elements:

void func(int array[static 10]);

Reduce RTTI and exception-data padding

The compiler avoids unnecessary padding in applicable PE32+ RTTI and exception-handling records that use image-relative offsets. This can reduce native binary size without changing header type definitions. The size difference depends on the records your application uses.

Use the sanitizer ignorelist spelling

Sanitizer coverage accepts -fsanitize-coverage-ignorelist as an alias for -fsanitize-coverage-blocklist, making shared Clang and MSVC settings easier to maintain. The older spelling remains supported, and existing lists keep the same exclusions.

📣 See feature ticket 1, feature ticket 2, feature ticket 3, feature ticket 4, feature ticket 5 to share your feedback and continue the conversation.

Use Visual Studio or browser sign-in to publish Marketplace extensions with VsixPublisher without supplying a PAT.

You can now publish and manage Visual Studio Marketplace extensions with VsixPublisher without supplying a personal access token (PAT). When you haven't supplied a token and don't have one stored, the tool uses Visual Studio or browser sign-in instead.

This avoids putting a PAT on the command line for interactive publishing. The sign-in flow uses short-lived identity access tokens, and the publisher database doesn't persist them.

Choose the authentication path that fits your publishing workflow:

• Production Marketplace, no explicit or stored PAT: use Visual Studio or browser sign-in.
• Existing PAT workflow: continue using your explicit or stored PAT as before.
• Custom Marketplace URLs: keep using PAT authentication; identity-based sign-in doesn't apply to these endpoints.

GitHub Actions trusted publishing remains available for automation.