SDK-Style Support for Extension Projects


Starting in Visual Studio 18.5, you can create and build Visual Studio extensions (VSIX) using an officially supported SDK-style project. This brings VSIX projects into the modern build and deployment pipeline, improving incremental build performance and making the build → deploy → debug workflow more reliable. Install the Visual Studio extension development workload to get the templates and tooling and try it out for yourself!

Note: Extensions written using the modern VisualStudio.Extensibility framework already supports SDK-style projects today. This update extends the same SDK-style experience to VSSDK-based Visual Studio extensions.

 What We Are Adding:

  • Official SDK-style support for projects that produce VSSDK-based extensions.
  • Build time reductions of up to 75%! We’ve added end-to-end incremental build support including Fast Up To Date Check and up to date deployment logic. Through internal adoption, we see a reduction of up to 75% in build time in large solutions for small changes or changes confined to a single sub project.
  • Updated in-box templates: SDK-style by default, with the familiar project items (tool windows, classifiers, commands, etc.).

Project Usage

Creating a project is done the same way you are used to, using the “VSIX Project” or “Empty VSIX Project” template:

new vsix project template image

This will yield a much more compact csproj than before: only 20 lines:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net472</TargetFramework>
    <Nullable>enable</Nullable>
    <LangVersion>14</LangVersion>

    <!-- VSIX settings -->
    <VSSDKBuildToolsAutoSetup>true</VSSDKBuildToolsAutoSetup>
    <VsixDeployOnDebug>true</VsixDeployOnDebug>
    <GeneratePkgDefFile>true</GeneratePkgDefFile>
  </PropertyGroup>
  <ItemGroup>
    <ProjectCapability Include="CreateVsixContainer" />
  </ItemGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.VisualStudio.SDK" Version="17.14.40265" ExcludeAssets="runtime" />
    <PackageReference Include="Microsoft.VSSDK.BuildTools" Version="18.5.38461" />
  </ItemGroup>
</Project>

Does it impact my extension?

  • If you create a new extension, you will automatically get full SDK-Style support.
  • Your existing MPF style extension will continue to work should you choose not to migrate. This update adds an official SDK-style option; it doesn’t force a conversion.
  • You can update your project to an SDK-style project file to take advantage of these features.
  • Vsixmanifest files included in SDK-style projects now open by default in the XML editor. The old designer is still available through the ‘Open With’ menu.

Migration In Brief

  • When available, you can do this in the project configuration:
    configuration manager image
  • <VSSDKBuildToolsAutoSetup>true</VSSDKBuildToolsAutoSetup> will setup most sensible defaults for you and reduce the size of your csproj. This will setup options like CreateVsixContainer as true, and the legacy DeployExtension to false.
  • <VsixDeployOnDebug>true</VsixDeployOnDebug> Should be added to your csproj if you will add it to other solution files to ensure the deploy checkbox is set automatically.

Agentic conversion

We’re experimenting with ways of making this as easy as possible for you. To that end, we’ve added an agent skill to the vs-agent-plugins repository you can use in conjunction with the Modernize agent. Let us know whether this workflow is helpful, or if you have a different agentic workflow in mind for extension development.

modernize agent image

Reference projects

Here are a few extensions that are already converted, so you can use them as references.

We want to hear from you!

Please send us feedback and issues you encounter in Developer Community. Thank you, and happy extending!

Visual Studio Code 1.118


Follow us on LinkedIn, X, Bluesky |


Last updated: April 24, 2026

Welcome to the 1.118 release of Visual Studio Code.

Happy Coding!



April 23, 2026

  • Adopt the Copilot CLI SDK session-title APIs as the source of truth for session names. #311535

  • Add keybindings such as Ctrl+1 and Ctrl+2 to quickly switch between sessions in the Agents app. #310992

  • Add auto model support to the Copilot CLI agent. #311299

April 22, 2026

  • Add descriptions to the chat customization creator menu, helping users understand which skill location to use for each type of customization. #295151

  • Let users opt in to testing the TypeScript 7.0 nightlies. #311966

  • Copilot CLI responses in the chat panel show a model badge indicating which model handled the request. #303960

  • Add support for auto model selection in Copilot CLI. #311779

April 21, 2026

  • The Copilot CLI SDK resolves node-pty from VS Code via hostRequire, eliminating the need to copy node-pty binaries into the SDK’s prebuilds folder at build time or runtime. #307746

We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what’s new.

Stop Hunting Bugs: Meet the New Visual Studio Debugger Agent Workflow


We’ve all been there: a bug report lands in your inbox with a title like “App crashes sometimes” and zero reproduction steps. Your morning, which was supposed to be spent building new features, is now a forensic investigation. You’re setting scattershot breakpoints, staring at the call stack, and trying to guess what the original reporter was thinking. 

Debugging isn’t just about fixing code; it’s about reducing uncertainty. Today, we’re taking a massive leap toward solving that problem by introducing a new, upgraded, guided workflow within our exiting Debugger Agent in Visual Studio.

debugger agent image

Ending the “Guessing Game” with a Guided Debugger Loop 

Let’s be honest: traditional debugging is full of friction. You manually parse a vague report, hunt for the right file, and spend twenty minutes just trying to see if you’re in the right ballpark. This new workflow flips the script, transforming the Debugger Agent from a chatbot into an interactive partner plugged directly into your live runtime. 

To get started, simply open your solution in Visual Studio, switch to Debugger mode in Copilot Chat, and point it to the problem with a GitHub/ADO URL or a quick sentence like: 

 “The app crashes when saving a file.”

debugger agent1 image
 

The workflow is interactive and powered by runtime debugging, meaning the Agent doesn’t just read your code; it feels how it’s running. It immediately builds a mental model of the failure and walks you through a structured, real-time process: 

  • Hypothesis & Preparation: The Agent analyzes the issue and proposes a root cause. If the reasoning looks solid, it sets intelligent breakpoints and prepares to launch your project. 

Note: If your project can’t be started automatically, just manually start your code, attach the debugger, and tell the Agent you’re ready. 

  • Active Reproduction: The Agent stays “on the line” while you trigger the bug, watching the runtime state as you move through the repro steps. 
  • Real-Time Validation: As breakpoints hit, the Agent evaluates variables and the call stack to systematically confirm its hypothesis or eliminate potential causes. 
  • The Final Fix: Once the root cause is isolated, the Agent proposes a solution. If you approve, it applies the fix and reruns the session to validate the resolution. 

This iterative flow is designed to keep you “in the zone.” By handling the manual setup and state analysis, the Agent lets you move from a bug report to a verified fix with significantly less mental context switching.
 

Our Vision: Foundational Quality and Beyond 

18.5 GA releases deliver the foundational experience of the guided workflow, specifically optimized for high-value, reproducible scenarios like exceptions, logic inconsistencies, and state corruption.  

As we look forward, we are already evolving this foundation to be even more robust. Our goal is to progressively automate the end-to-end workflow, maturing the Debugger Agent into a comprehensive, seamless debugging companion that anticipates your needs. 

Debug Smarter, Not Harder 

The new workflow in the Debugger Agent represents a fundamental shift in how we think about IDEs. We’re excited to see how you use this in your own workflows whether you’re untangling a complex race condition in a multi-threaded service or simply trying to figure out why a UI element isn’t updating as expected. 

Stay connected with the Visual Studio team by following us on Twitter @VS_Debugger, Twitter @VisualStudio, YouTube, and LinkedIn. 

 

 

 



From AI to .NET: 20 VS Live! Las Vegas Sessions You Can Watch Now


In March 2026, developers came together at VS Live! Las Vegas for a full week of technical learning, hands-on exploration, and a lot of great conversations about where software development is headed next. From AI-assisted development to modern .NET, cloud-native apps, and developer productivity, one thing was clear: the pace of change is not slowing down.

If you were not able to attend, or if you want to revisit some of the strongest content from the event, we are now publishing 20 sessions from VS Live! Las Vegas on the Visual Studio YouTube channel.

We are releasing about two sessions per day, so you can watch them at your own pace and jump into the topics that matter most to you.

What you’ll find in this series

These sessions reflect the topics developers are focused on right now, including:

  • AI and Copilot-powered development
  • Modern .NET and C#
  • Cloud-native apps and Azure
  • Developer productivity and tooling
  • Real-world architecture and engineering

You’ll hear directly from Microsoft engineers helping build these tools, along with industry experts who are using them to solve real problems and ship real applications.

A few sessions to check out

This lineup includes a strong mix of practical guidance, technical depth, and forward-looking keynotes.

Keynotes

  • The Road to Visual Studio 2027: Building a Faster, Smarter IDE – Mads Kristensen
  • Knowledge is the Key: The Path for AI Applications – Jerry Nixon and Drew Skwiers-Koballa

Featured sessions

  • AI’s Not Magic: A Developer’s Guide to Using AI Tools Without the Hype – Brian A. Randell
  • Building an AI Agent to Work with Your Own Data – Jerry Nixon
  • Building Intelligent .NET Applications: From AI to Implementation – Jon Galloway
  • What’s New in C# – Jason Bock
  • Building RESTful Services with ASP.NET Core – Philip Japikse
  • GitHub Actions in Action – Marcel de Vries
  • The Forgotten Features of Visual Studio You NEED In Your Life! – Mads Kristensen
  • Fast Focus: Caching Options in .NET – Jason Bock
  • VS Code and Visual Studio, Better Together – Brian A. Randell
  • Modernizing .NET Applications Faster with Visual Studio – Jon Galloway

What I like about this set of sessions is that it is not just theory. These talks focus on real-world scenarios, whether you are exploring AI in existing apps, modernizing older .NET solutions, improving performance, or just looking for better ways to work day to day.

Start watching

Whether you are catching up on what you missed or diving in for the first time, this is an easy way to experience some of the best content from VS Live! Las Vegas on your own schedule.

We will continue publishing sessions daily, so check back often and subscribe to the Visual Studio YouTube channel to stay up to date.

Want the full VS Live! experience? Attend in person

Watching online is a great way to learn, but there is still nothing like attending a VS Live! event in person. You get the sessions, the hands-on labs, the hallway conversations, and direct access to speakers, product experts, and fellow developers.

If you are a Visual Studio subscriber, you may already have access to exclusive event pricing through my.visualstudio.com. Just sign in, head to the Benefits page, and look for the Visual Studio Live! Events tile to get your priority code. Depending on the event, that can save you up to $900 on registration.

If you are not a subscriber, you can still save. As a Visual Studio Blog reader, use priority code VSLMS at checkout to save up to $600.

Each event includes a full week of expert-led sessions and hands-on labs, plus the chance to connect directly with the people behind Visual Studio, .NET, Azure, and GitHub Copilot.

Upcoming VS Live! events

  • Microsoft HQ (Redmond) | July 27 to 31, 2026
  • San Diego | September 14 to 18, 2026
  • Live! 360 Orlando | November 15 to 20, 2026
  • Las Vegas | March 22 to 26, 2027

Visual Studio Code 1.117


Follow us on LinkedIn, X, Bluesky |


Last updated: April 16, 2026

Welcome to the 1.117 release of Visual Studio Code.

Happy Coding!



April 15, 2026

  • Add support for self-updating the Agents app on macOS. #308646

  • Copilot CLI sessions indicate whether they were created by VS Code or externally. #308543

  • In package.json files, the dependency hover now shows the currently installed version alongside the latest published version of a package. #307648

  • Images in JSDoc comments, including <img> HTML tags, now render correctly in hovers, completion details, and signature help for JavaScript and TypeScript files. #231792

April 14, 2026

  • The Autopilot permission mode now persists across sessions. You can configure the default permission level with the


    chat.permissions.default

    setting. #309562

  • When an agent sends input to a terminal, the terminal output is now automatically included in the result after a brief delay, saving an extra agent turn. #309509

  • Agent Host now supports auto-approve session configuration with three modes: Default Approvals, Bypass Approvals, and Autopilot (Preview). #309337

  • You can now switch back to the main window from auxiliary (floating) windows. #306571

  • Agent Host Protocol now supports subagents and agent teams. #305755

April 13, 2026

  • Agent Host sessions now support worktree and git isolation. #305325

  • Copilot CLI, Claude Code, and Gemini CLI are now recognized as shell types in the terminal. #290830

April 12, 2026

  • Copilot CLI now generates meaningful branch names based on the user’s prompt when creating worktrees for background agent sessions. #306191

We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what’s new.

Visual Studio Code 1.116


Follow us on LinkedIn, X, Bluesky |


Last updated: April 8, 2026

Welcome to the 1.116 release of Visual Studio Code.

Happy Coding!



April 8, 2026

  • Add dedicated commands and keybindings to the Agents app to focus the Changes view (), the files tree within the Changes view, and the Chat Customizations view, enabling full keyboard navigation. #308327, #308322, #308265

  • Add an accessibility help dialog (⌥F1 (Windows Alt+F1, Linux Shift+Alt+F1)) to the Agents app chat input box that displays available commands and keybindings for screen reader users, with an option to control announcement verbosity. #308259

  • Add support for CSS @import link node_modules resolution, allowing you to Ctrl+click through imports like @import "some-module/style.css" when using bundlers. #295074


April 7, 2026

  • Add #-triggered file-context completions to the Agents app, scoped to the workspace chosen in the picker. #299057

We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what’s new.

Take full control of your floating windows in Visual Studio


If you work with multiple monitors like I do, you’ve probably grown to love floating tool windows and documents in Visual Studio. Being able to pull out Solution Explorer, the debugger, or your code files onto a second (or third) screen can be a huge productivity boost.

But there’s always been a bit of friction with how these floating windows behave.

VSFancyZones image

By default, floating windows are “owned” by the main Visual Studio window. That means they don’t show up as separate buttons in your Windows taskbar, they disappear when you minimize the main IDE, and they always stay on top of everything else — even when you don’t want them to.

For some workflows that’s exactly what you want. For others, it gets annoying fast.

Fortunately, there’s a little-known setting that lets you decide exactly how much control Visual Studio has over your floating windows.

The setting is here: Tools > Options > Environment > Windows > Floating Windows

You’ll see this dialog:

floating windows tools options image

The dropdown is labeled “These floating windows are owned by the main window” and gives you three choices:

  • None
  • Tool Windows (the default)
  • Documents and Tool Windows

Changing this one setting can completely transform how you work with floating windows.

My favorite scenario: PowerToys FancyZones

This setting really shines when you combine it with Microsoft and its excellent FancyZones feature.

I like to set it to None and then use FancyZones to create custom layouts across my monitors. Suddenly all my floating tool windows and documents behave like normal application windows — they appear in the taskbar, stay visible even if I minimize the main Visual Studio window, and I can snap them perfectly into my FancyZones layouts without them forcing themselves to the front all the time.

It feels much more natural and gives me the clean multi-monitor setup I’ve always wanted.

When to choose each option

  • None: Maximum independence. Everything gets its own taskbar entry and full window behavior. Perfect for heavy multi-monitor users with PowerToys.
  • Tool Windows: A nice middle ground — keep your documents floating freely while tool windows stay tied to the IDE.
  • Documents and Tool Windows: The classic Visual Studio behavior.

Pro tip: Combine this with the Ctrl + double-click trick on any tool window title bar (see our earlier post on easily docking and floating tool windows) for lightning-fast layout switching. No restart required.

Have you played with this setting before? What option do you prefer: None, Tool Windows, or the default? Let me know in the comments. I’m always curious how other developers set up multi-monitor workspaces.

Happy coding!

Visual Studio Code 1.115


Follow us on LinkedIn, X, Bluesky |


Last updated: April 3, 2026

Welcome to the 1.115 release of Visual Studio Code.

Happy Coding!



April 2, 2026

  • Enable showing test coverage indicators in the minimap. #258961

  • Add support for pasting files (for example, images) into the terminal by using Ctrl+V, drag-and-drop, and right-click paste. #301603

  • Background terminals automatically notify the agent when commands complete, including the exit code and terminal output. Prompts for input in background terminals are also detected and surfaced to the user. #307201

  • Add support for pinch-to-zoom gestures on Mac in the integrated browser. #307267

  • Update code serve-web CLI command to support --disable-telemetry, --default-folder, and --default-workspace options. #192230

April 1, 2026

  • The Copilot status bar entitlements and usage information is available in Sessions. #306462

  • Add support for connecting to remote machines over SSH, automatically installing the CLI and starting it in agent host mode. #306196

  • Track and restore file edits in agent sessions, delivering diffs, undo/redo, and state restoration for customizations made during a session. #305332

March 31, 2026

  • Chat can now track and link to browser tabs that were opened or interacted with during a session, so agents can reference open web pages. #306537

  • The send_to_terminal tool lets agents send commands to background terminals with user confirmation, fixing an issue where run_in_terminal with a timeout would move terminals to the background and make them read-only. #305909

  • Rename agent sessions from the client side via a new client-to-server rename capability in the Agent Host Protocol. #305318

  • Open web pages now show their favicons in the Go to File quick pick list, matching the favicon display on browser tab labels. #299792


We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what’s new.

Bookmark Studio: evolving bookmarks in Visual Studio


Bookmarks in Visual Studio have always been a simple, reliable feature. Many developers use them regularly, and over the years we’ve heard consistent feedback from those users. Bookmarks were useful, but there were a few core gaps that kept them from being as effective and relevant as they could be.

Navigation was one of the biggest pain points. You could move between bookmarks, but there was no easy way to jump directly to a specific bookmark using the keyboard. That made bookmarks harder to rely on once you had more than a few. Another common request was sharing. Bookmarks worked well for personal, local navigation, but there was no good way to share them with teammates or reuse them across repos, branches, or pull requests.

That feedback is what led to Bookmark Studio, a new experimental Visual Studio extension that builds on the existing bookmark experience by filling in those missing pieces, without changing how bookmarks fundamentally work.

Faster, more intentional navigation

One of the core additions in Bookmark Studio is slot‑based navigation.

Bookmarks can be assigned to slots 1 through 9 and jumped to directly using simple keyboard shortcuts like Alt+Shift+1 through Alt+Shift+9. This makes bookmarks feel more deliberate and easier to rely on when you want fast access to a handful of important locations.

Toolbar

New bookmarks are automatically assigned the next available slot when possible, so fast navigation often works without any extra setup. Bookmark Studio also integrates with Visual Studio’s existing bookmark commands, which means your current shortcuts and muscle memory continue to work as expected.

A single place to work with bookmarks

Bookmark Studio also adds a dedicated Bookmark Manager tool window.

Tool window

The manager shows all bookmarks in one place and makes it easy to browse, search, and navigate between them. You can filter by name, file, location, color, or slot, and jump directly to a bookmark with a double‑click or keyboard navigation. It’s designed to make bookmarks easier to revisit, especially when switching context or coming back to code later.

Optional structure, when you need it

Another piece of feedback we heard was the need for just a bit more organization.

With Bookmark Studio, bookmarks can have labels, colors, and folders. None of this is required, and you can keep using bookmarks exactly as you do today. But when you’re debugging, refactoring, reviewing code, or exploring unfamiliar areas of a codebase, that extra context can make bookmarks more useful and easier to reason about.

Glyphs

All bookmark metadata is stored per solution, so it stays with your work across sessions.

Bookmarks you can share and reuse

Bookmarks are often most valuable when they capture intent, not just location.

Bookmark Studio makes it easy to export bookmarks as plain text, Markdown, or CSV. That means you can include bookmarks in pull requests, share investigation paths with teammates, or move useful bookmark sets between repos. Instead of being a purely personal tool, bookmarks can become a lightweight way to communicate context and decisions.

Bookmarks that stay put as code changes

Bookmark Studio tracks bookmarks as text moves during editing, so they stay attached to the relevant code instead of drifting to the wrong line. This makes bookmarks more dependable during active development, especially when files are changing frequently.

Drag and drop of glyph

A focused improvement, not a reinvention

Bookmark Studio doesn’t try to replace tasks, TODO comments, or issue tracking. It doesn’t introduce a new workflow you have to learn. Instead, it fills in the gaps that many bookmark users have pointed out over time, making bookmarks easier to navigate, easier to share, and more useful as part of everyday development.

If you already use bookmarks in Visual Studio, Bookmark Studio should feel familiar within minutes. And if you’ve ever wished bookmarks could do just a little more, this extension is worth a look.

You can download Bookmark Studio today from the Visual Studio Marketplace. As always, feedback and pull requests are welcome on the GitHub repo.

Visual Studio March Update – Build Your Own Custom Agents


This month’s Visual Studio update gives you new ways to customize GitHub Copilot. Custom agents allow you to build specialized Copilot agents tailored to your team’s workflow, backed by the tools and knowledge sources that matter to your project. Alongside that, agent skills bring reusable instruction sets, and a new find_symbol tool gives agents language-aware navigation across your codebase.

Beyond agents, we’re continuing to invest in the diagnostics experience with Copilot-powered profiling directly from Test Explorer and real-time perf tips during debugging. Security gets a boost too, with Copilot now helping you fix NuGet vulnerabilities right from Solution Explorer.

Download Visual Studio 2026 Insiders to try these features today.

Build your own custom agents

Want Copilot to follow your team’s coding standards, run your build pipeline, or query your internal docs? Custom agents make that possible. They’re specialized Copilot agents defined as .agent.md files in your repository, with full access to workspace awareness, code understanding, tools, your preferred model, and MCP connections to external knowledge sources.

Drop an .agent.md file into .github/agents/ in your repo, and it shows up in the agent picker ready to use.

vs18 4 custom agents image

A few things to keep in mind: if you don’t specify a model, the agent uses whatever you’ve selected in the model picker. Tool names can vary across GitHub Copilot platforms, so 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.

Use agent skills

Skills are picked up automatically from several locations in your repository (such as .github/skills/) or your user profile (such as ~/.copilot/skills/). Each skill lives in its own directory with a `SKILL.md` file that follows the Agent Skills specification. When a skill is activated, it appears in the chat so you know it’s being applied.

vs18 4 agent skills image

Check out the awesome-copilot repo for community-shared skills, and look for more user-friendly flows for browsing and creating skills inside Visual Studio in upcoming releases.

Find_symbol tool for agent mode

Copilot’s agent mode now has language-aware symbol navigation. The new find_symbol tool lets the agent find all references to symbols across your project and access metadata like type information, declarations, and scope. This means when you ask Copilot to refactor a method or update a parameter across call sites, it can actually see your code’s structure rather than guessing from text.

vs18 4 find symbol image

Enable the tool, and Copilot uses it automatically when answering questions or suggesting code changes. The difference is noticeable: instead of searching for text patterns, the agent navigates your code using language services.

vs18 4 find symbol example image

Supported languages include C++, C#, Razor, and TypeScript, plus any language with a supported LSP extension installed. For best results, use AI models that support tool-calling. Learn more at AI model comparison.

Enterprise MCP governance

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, only approved servers can be connected. If you try to use an unauthorized server, you’ll see an error explaining the restriction. This helps organizations control which MCP servers process sensitive data and maintain compliance with security policies.

Profile Tests with Copilot

Ever wanted to profile a specific test without wrestling with profiler configuration? There’s now a Profile with Copilot command right in the Test Explorer context menu.

vs18 4 profile test with copilot image

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, it uses Instrumentation profiling and is currently supported in .NET. If you need deeper analysis, you can launch the selected test directly from the Copilot chat window and choose additional profiling tools.

Perf tips powered by live profiling

Performance optimization now happens while you debug, not after. As you step through code, Visual Studio shows execution time and performance signals inline for each step. When you spot a slow line, just click the Perf Tip and ask Copilot for optimization suggestions on the spot.

vs18 4 profiler agent perf tip image

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

Fix vulnerabilities with Copilot

Spotted a NuGet package vulnerability? Copilot can now help you fix it directly from Solution Explorer. When a vulnerability is detected, you’ll see a notification with a Fix with GitHub Copilot link. Click through, and Copilot analyzes the vulnerability, recommends and implements targeted dependency updates that keep your packages secure without disrupting your workflow.

vs18 4 fix with copilot link image

No more manual vulnerability research or hunting down correct package versions. You address security issues right when they’re discovered.

HTML rich copy/cut

Need to paste code into a presentation, an Azure DevOps work item, or a web-based document? Visual Studio now supports HTML clipboard format when cutting or copying code from the editor. Syntax highlighting and formatting carry over when you paste into HTML-based applications. It’s turned on by default. To customize, go to Tools > Options > Text Editor > Advanced where you can toggle Copy rich text on copy/cut and set the max length.

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