Visual Studio Code Release Notes

Update 1.109.1: The update addresses these security issues.
Update 1.109.2: The update addresses an issue with chat.
Update 1.109.3: The update addresses these issues and introduces several notable features:
• Message steering and queueing: send follow-up messages while a request is still running
• Agent hooks: run custom shell commands at key agent lifecycle points
• Claude compatibility: reuse your Claude configuration files directly in VS Code
• Use skills as slash commands: invoke agent skills on demand from chat
Update 1.109.4: The update addresses these issues.
Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap

Welcome to the January 2026 release of Visual Studio Code. In this release, we are further evolving VS Code to make it the home for multi-agent development.
• Chat UX - chat just feels better and snappier with faster streaming, improved reasoning results, and a revamped editor inline chat
• Agent Session Management - it's now easier to delegate tasks to agents across local, background, and cloud and jump in when needed
• Agent Customization - build your own workflows using agent orchestrations, and have consistent results with Agent Skills and organization-wide customizations
• Agent Extensibility - reuse your knowledge with Claude agent support and new Anthropic model capabilities, and enjoy rich chat interactions with MCP Apps
• Agent Optimizations - agents work smarter with Copilot Memory and experience faster code search with external indexing
• Agent Security & Trust - feel confident running terminal commands with sandboxing and effective auto-approval rules
• Workbench & productivity - test your apps without leaving the editor with the new integrated browser
• Terminal Enhancements - quality-of-life improvements to make your terminal experience smoother and more reliable
• Coding & Editor - several impactful improvements to make everyday coding smoother
• Extensions & API - new capabilities for extension authors to build richer experiences

Happy Coding!
Watch our VS Code 1.109 release highlights video to hear about these features!

If you'd like to read these release notes online, go to Updates on code.visualstudio.com.

Insiders: Want to try new features as soon as possible?
You can download the nightly Insiders build and try the latest updates as soon as they are available.

Upcoming events
Agent Sessions Day
Join us for Agent Sessions Day on Feb 19th to see these latest updates demoed live! Discover how VS Code has evolved into a unified agent UX, while staying true to its core values of openness, extensibility, and developer choice.

Chat UX
Faster responses, clearer reasoning, and less friction. This release brings streaming improvements that show progress as it happens, a revamped inline chat that stays out of your way, and better visibility into what the model is thinking, so you can stay in flow while the AI works.

Message steering and queueing (Experimental)
Setting:
chat.requestQueuing.enabled,
chat.requestQueuing.defaultAction
Update 1.109.3: When working on longer tasks, you often think of the next task before the current or notice the agent heading in the wrong direction. Previously, you had to wait for a response to complete or cancel it entirely. Now you can send follow-up messages while a request is still running.
While a request is in progress, the Send button changes to a dropdown with three options:
• Add to Queue: your message waits and sends automatically after the current response completes.
• Steer with Message: signals the current request to yield after finishing the active tool execution, then processes your new message immediately. Use this to redirect the agent when it's heading in the wrong direction.
• Stop and Send: cancels the current request entirely and sends your new message immediately.
When you have multiple pending messages, drag and drop them to change the order in which they are processed.
Use chat.requestQueuing.defaultAction to set the default action of the Send button to steer (default) or queue.
Learn more about message steering and queueing in the documentation.

Anthropic models now show thinking tokens
Settings:
chat.thinking.style,
chat.agent.thinking.collapsedTools,
chat.agent.thinking.terminalTools,
chat.tools.autoExpandFailures
Many of you are using Anthropic's Claude models in VS Code. These models now support thinking tokens to give you more visibility into the model's reasoning process.
In this release, we've enhanced the chat UX to surface thinking tokens more effectively. More information, less noise!
• Choose between detailed or compact thinking styles to suit your preference (chat.thinking.style).
• You'll see the model's thought process interleaved with tool calls and responses (chat.agent.thinking.terminalTools).
• Failing tool calls automatically expand to show more context (chat.tools.autoExpandFailures).
• Various visual enhancements to make following model activity more intuitive, like scrollable thinking content and shimmer animations.

Mermaid diagrams in chat responses
Chat responses can now render interactive Mermaid diagrams with the renderMermaidDiagram tool. This lets models use flowcharts, sequence diagrams, and other visualizations to visually break down complex concepts. The diagrams are interactive, so you can pan and zoom to explore them in detail, or open them in a full-sized editor for easier viewing.
Interact with Mermaid diagrams using the following controls:
• Pan and zoom - Hold Alt/Option and use the mouse wheel to zoom, or pinch to zoom on a trackpad. Hold Alt/Option and drag to pan around the diagram.
• Click to zoom - Hold Alt/Option and click to zoom in. Add Shift to zoom out.
• Open in editor - Use the button to open the diagram in a full-sized editor for better viewing of larger diagrams.
• Copy source - Right-click on a diagram and select Copy diagram source to copy its Mermaid source code.

Ask Questions tool (Experimental)
Setting:
chat.askQuestions.enabled
Instead of making assumptions when something is unclear, the agent can now use the askQuestions tool to ask clarifying questions during chat conversations. It presents one or more questions directly in chat with single/multi-select options, free text input, and recommended answers highlighted for quick decisions.
Use the keyboard to navigate between answers with Up and Down, or type the number that matches the corresponding answer (use Escape to skip remaining questions).
We have revamped our Plan agent to also take advantage of the askQuestions tool to make sure your implementation plans align with your expectations and beyond!

Plan agent
The built-in Plan agent lets you create a structured implementation plan before starting to code. This helps ensure that the AI understands the task requirements and produces high-quality code that meets your expectations.
• The Plan agent now follows a structured 4-phase iterative workflow that produces higher-quality implementation plans:
• Discovery - Autonomously explores your codebase, searching for relevant files and understanding project structure.
• Alignment - Pauses to ask clarifying questions before committing to a plan, catching ambiguities early.
• Design - Drafts a comprehensive implementation plan with clear steps, file locations, and code snippets.
• Refinement - Adds verification criteria and documents decisions made during planning.
• You can now invoke the Plan agent by typing /plan in chat, followed by your task description. This provides a quick entry point for planning complex tasks before switching to implementation.

Context window details
To keep track of how the model is using its context window, you can now see a context window indicator in the chat input area. Hover over the indicator to see a breakdown of token usage by category.

Inline chat UX revamp (Preview)
Settings:
inlineChat.affordance,
inlineChat.renderMode
We continue to revamp the inline chat experience and have two preview features:
• An affordance that makes it easier to trigger inline chat when selecting text (inlineChat.affordance)
• A lightweight and easier-to-use contextual rendering (inlineChat.renderMode)

Model descriptions in the model picker
On hover or keyboard focus of a model in the model picker, you can now see its details at a glance.

Terminal command output
Richer command details
To make it clearer what command is being run, the terminal tool now shows additional details:
• Syntax highlighting for inline Node, Python, and Ruby
• Working directory
• Description of the command's intent

Output streaming
Terminal output now automatically expands when a command takes time to execute, giving you immediate visibility into what's happening. Quick commands stay collapsed to reduce visual noise.

Interactive input
Embedded terminals are now fully interactive. You can focus the terminal and type directly, which is useful when a command prompts for confirmation or requires user input. The cursor is now visible, making it clear when a terminal is ready for input.

Delete all hidden terminals
The Hidden Terminals item in the terminal panel now includes a delete icon to clear all hidden terminals with one action.

Tell us what you think about our new themes (Experimental)
We are developing new experimental VS Code Light and VS Code Dark themes to increase focus and bring a sense of elevation and lightness to the UI, through the use of shadows and transparency. These themes are a work-in-progress.
Let us know what works and where we can improve by giving feedback in the vscode repository.

Agent Session Management
Delegate, monitor, and switch without losing focus. You can now run multiple agent sessions in parallel across local, background, and cloud environments, all from a single unified view. Jump between sessions, track progress at a glance, and let agents work independently while you stay productive.

Switching and delegating between agent types
VS Code makes it easy to start agent sessions across different environments: locally in VS Code, in the background, in the cloud, or with other agent providers. We've made it easier to switch between these different agent types by introducing a new session type picker in the chat input area.
The picker serves two main purposes:
• Choose the type of agent session you want to start
• Hand off an ongoing session to a different agent type (for example, plan a task locally and implement in the cloud)

Keeping track of agent sessions
Keeping track of your active agent sessions is essential when working with multiple agents, especially when you have multiple parallel session across different environments.

Agent Sessions view
We've further improved the Agent Sessions view in VS Code to make this task easier:
• Resize the sessions list when showing side-by-side
• Multi-select sessions to perform operations in bulk
• Better stacked view to improve navigating sessions and applying filters

Agent status indicator
Settings:
chat.agentsControl.enabled,
chat.agentsControl.clickBehavior
In situations where you have multiple active sessions, it's important to quickly see which sessions need your attention. We added an agent status indicator (chat.agentsControl.enabled) in the VS Code command center to provide visibility into agent session updates.
The indicator shows different types of status information: in-progress, unread, and sessions that need your attention. Select the indicator to quickly open and filter the sessions list.
We have also updated the chat button in the command center to let you configure its behavior when clicked (chat.agentsControl.clickBehavior). By default, it now cycles through the different Chat view states: sidebar, maximized, or hidden.

Subagents
Setting:
chat.customAgentInSubagent.enabled
Agents can run subtasks using subagents to break down complex tasks into smaller parts. The nice thing about subagents is that they operate in their own dedicated context window and don't add up to the main agent's context window.
Subagents can now run in parallel, which can significantly speed up tasks that can be split into independent tasks.
To provide more visibility into what the different subagents are doing, the chat conversation now shows details such as what tasks it's doing, the custom agent used for the subagent, and whichever tool is currently used. You can expand the subagent information to show the full details of what it's doing, including the full initial prompt it was provided with and the result it returned.

Search subagent (Experimental)
Setting:
github.copilot.chat.searchSubagent.enabled
Searching your codebase is typically a task that can involve multiple iterations and which can quickly add up to your context window limit. We added support for a search subagent that runs in an isolated agent loop, enabling it to iteratively refine searches, try multiple queries, and explore different parts of your workspace.
This improves the quality of search results for complex queries where a single search isn't sufficient. It also preserves the main agent's context window and enables it to continue working while the search subagent does its job.

Cloud agents
When you start a new cloud agent session, you now have more options to configure your session. Choose from different models, use one of your custom agents, or select from available partner agents (where available).
• Model selection for cloud agents
• Third-party coding agents (Preview)
If you have third-party coding agents, such as Claude and Codex, configured as part of your GitHub Copilot subscription, VS Code will show these options after selecting the cloud agent type.
• Custom agents for cloud agents
Choose from custom Agents available in your target GitHub repository default branch.
• Multi-root workspace and empty workspace improvements
When in a multi-root workspace window or empty workspace window, you can now select the folder to be used for the cloud agents.
• Checkout always shows
The Checkout option for agent sessions now shows even when the GitHub Pull Requests extension is not installed. When you select this action, it installs GitHub Pull Requests if needed, and then hands off to it to perform the checkout.

Background agents
Aligning with local and cloud agents, we have added several improvements to background agents:
• Custom agents for background agents
• Attach images as context
• Multi-root workspace improvements
When in a multi-root workspace, you can now select the folder to be used in background agents.
• Auto-commit at the end of each turn
We have updated the background agent loop to commit the changes to the Git worktree at the end of each turn. This enabled us to remove the Keep/Undo actions for background sessions and simplify how changed files are shown in the working set.

Agent sessions welcome page (Experimental)
Setting:
workbench.startupEditor
Last but not least, we're experimenting with a new welcome page and need your help to make it great. When you have multiple agents working in parallel, keeping track of recent sessions matters. The new welcome page surfaces your agent sessions front and center.
Enable the welcome page as your startup editor by setting workbench.startupEditor to agentSessionsWelcomePage. Let us know what you think and send us feedback in the vscode repository!

Agent Customization
Shape how AI works with your codebase and share it across your team. Agent Skills now let you package domain expertise into reusable workflows, organization-wide instructions ensure consistency, and new controls give you fine-grained control over how and when agents get invoked.

Agent hooks (Preview)
Setting:
chat.hooks.enabled
Update 1.109.3: Hooks let you execute custom shell commands at key lifecycle points during agent sessions. Unlike instructions or custom prompts that guide agent behavior, hooks run your code deterministically with guaranteed outcomes. Use them to enforce security policies, automate code quality checks, create audit trails, or inject project-specific context.
VS Code supports eight hook events that fire at specific points during a session, including PreToolUse and PostToolUse for intercepting tool calls, SessionStart and Stop for session lifecycle, and SubagentStart and SubagentStop for tracking nested agent usage.
VS Code uses the same hook format as Claude Code and Copilot CLI, so you can reuse existing hook configurations across tools.
To get started, use the /hooks slash command in chat to configure a new hook, or create a hook file manually. For example, you can create a PreToolUse hook that runs a linter after every file edit, or block dangerous terminal commands before they execute.
Learn more about agent hooks in the documentation.

Use skills as slash commands
Agent Skills are now available as slash commands in chat, alongside prompt files. Type / in the chat input to see all available skills and prompts, and select a skill to invoke it immediately. You can add extra context after the command, for example /webapp-testing for the login page or /github-actions-debugging PR #42.
By default, all skills appear in the / menu. Use the user-invokable and disable-model-invocation frontmatter properties in your skill files to control how each skill is accessed:
• Set user-invokable: false to hide a skill from the menu while still letting the model load it automatically.
• Set disable-model-invocation: true to show the skill in the menu but prevent the model from loading it on its own.
Learn more about using skills as slash commands in the documentation.

Set up your workspace for AI with /init
With always-on custom instructions like copilot-instructions.md or AGENTS.md, you can ensure that the AI uses your project's conventions for generating code.
To prime your project with an initial set of instructions based on your codebase, you can now use the /init slash command in chat to generate or update your workspace instructions.
When you run /init, the agent discovers existing AI conventions in your workspace (such as copilot-instructions.md or AGENTS.md), analyzes your project structure and coding patterns, and generates comprehensive workspace instructions tailored to your project. The /init command is implemented as a contributed prompt file, so you can customize its behavior by modifying the underlying prompt.

Agent Skills are generally available
Settings:
chat.useAgentSkills,
chat.agentSkillsLocations
Agent Skills are now generally available and enabled by default. Skills provide specialized capabilities, domain knowledge, and refined workflows to help the AI produce high-quality outputs. Each skill folder contains tested instructions for specific domains like testing strategies, API design, or performance optimization.
You can now manage skills in VS Code in the same way you manage prompt files, instructions, or custom agents. Use the Chat: Configure Skills command to view all available skills, or Chat: New Skill File to create a new skill in your workspace or user home.
By default, VS Code looks for skills definitions in the .github/skills and .claude/skills folder of your workspace, or in the ~/.copilot/skills or ~/.claude/skills folder in your user home. You can specify custom paths where VS Code should look for skills by using the chat.agentSkillsLocations setting.
If you're an extension author, you can also package and distribute skills with your extension by including them in the extension and registering them using the chatSkills contribution point in the package.json.
The path must point to a directory that contains a SKILL.md file, and the name field in the SKILL.md frontmatter must match the parent directory name. For example, if the path is ./skills/my-skill, the directory must contain a SKILL.md with name: my-skill in its frontmatter. Learn more about the required folder structure in the Agent Skills documentation.

Organization-wide instructions
Setting:
github.copilot.chat.organizationInstructions.enabled
Previously, VS Code already added support for organization-level custom agents. In this release, VS Code now also supports organization-level custom instructions. If your GitHub organization has configured custom instructions for Copilot, they are automatically applied to your chat sessions, ensuring consistent guidance across your team.
This feature is enabled by default. You can disable organization instructions by setting github.copilot.chat.organizationInstructions.enabled to false.
Learn more about Custom Instructions in the documentation.

Custom agent file locations
Setting:
chat.agentFilesLocations
Like for other customization files, such as prompt files, instructions, and skills, you can now configure where VS Code looks for custom agent definitions (.agent.md).
By default, VS Code searches for agent files in your workspace's .github/agents folder. With the new chat.agentFilesLocations setting, you can add additional directories to search, making it easier to organize and share agents across projects or keep them in a central location outside your workspace.

Control how custom agents are invoked
Settings:
chat.customAgentInSubagent.enabled
Custom agents now support additional attributes in the frontmatter header that give you more control over how agents can be invoked. This is particularly useful for setting up agent orchestrations to handle complex tasks with confidence.
• user-invokable: controls whether the agent can be selected from the agents dropdown in chat. Set to false to create agents that are only accessible programmatically or as subagents.
• disable-model-invocation: prevents the agent from being invoked as a subagent by other agents when enabled. This is useful for agents that should only be triggered explicitly by users.
• agents: limits which subagents the current agent can invoke. When specified, the agent can only hand off work to the listed agents. Use the agent tool to enable subagent invocation.
The use of custom agents as subagents is currently still behind a setting. Enable chat.customAgentInSubagent.enabled to enable custom agents as subagents.

Multiple model support for custom agents
Custom agents can now specify more than one model in the frontmatter header. The first available model in the list is used, providing fallback options if a preferred model is unavailable.

Chat customization diagnostics
Chat customization files can originate from various locations, including your user profile, workspace, extensions, and your GitHub organization. When troubleshooting issues with custom agents, prompts, instructions, or skills, it can be challenging to determine which files are currently loaded and whether any errors occurred during loading.
A new diagnostics view helps you troubleshoot chat customization issues by showing all currently loaded custom agents, prompt files, instruction files, and skills. To access it, right-click in the Chat view and select Diagnostics. This opens a Markdown document listing all active customization files, their load status, and any errors that occurred during loading.

Language Models editor
The Language Models editor in VS Code provides a centralized interface for managing and configuring language models used in chat. This iteration, we further enhanced this experience:
• Multiple configurations per provider: create multiple configurations for the same model provider, each with a different API key. This is useful for separating personal and work accounts, or using different API keys for different projects. For example, you might have one Gemini configuration with your personal API key and another with your team's API key.
• Configuring models from Azure provider: when configuring Azure models, VS Code opens the chatLanguageModels.json configuration file and inserts a snippet template. This snippet includes the required properties such as model ID, name, endpoint URL, and token limits. You can then fill in the values for each model you want to add.
• Manage provider groups: configure an existing provider group by selecting the configure action, for example to update the API key. You can also remove a provider group entirely by using the remove action.
• Additional UI improvements: several usability improvements, such as keyboard access for toggling model visibility, context menu actions, and multi-select for bulk actions.
• Language-model configuration file: model configurations are now stored in a dedicated chatLanguageModels.json file. Open this file directly by selecting the file icon in the top-right corner of the Language Models editor. This makes it easy to view, edit, or share your model configurations.
• Model provider configuration UI: model providers can declare their configuration schema, and VS Code provides the UI for users to enter their configuration. See Chat Model Provider Configuration for details on this new proposed API. Existing model configurations from the GitHub Copilot Chat extension are automatically migrated.

Language model configuration
Settings:
github.copilot.chat.implementAgent.model,
inlineChat.defaultModel
• Default model for plan implementation (Experimental): You can now configure a default language model for the implementation step of the Plan agent (github.copilot.chat.implementAgent.model). Leave the setting empty to use the default model. The model value should be a qualified model name in the format Model Name (vendor), for example GPT-5 (copilot) or Claude Sonnet 4.5 (copilot).
• Default model for inline chat: By default, editor inline chat uses the default model of the selected vendor. This enables extensions to provide a model that's specifically tailored for inline chat scenarios. If you prefer to use a different model, you can configure this with the inlineChat.defaultModel setting. This setting lets you choose a consistent default language model for inline chat, so your preferred model is used automatically whenever you start an inline chat session, without needing to select it manually each time.
• Specify language model for agent handoffs: Agent handoffs now support an optional model parameter that lets you specify which language model to use when the handoff executes. This enables you to control the model that is used for specific agent workflows directly from your .agent.md file. The model value should be a qualified model name in the format Model Name (vendor), for example GPT-5 (copilot) or Claude Sonnet 4.5 (copilot).

Agent customization skill (Experimental)
Setting:
chat.agentCustomizationSkill.enabled
A new agent-customization skill teaches the agent how to help you customize your AI coding experience. When you ask about creating custom agents, instructions, prompts, or skills, the agent automatically loads this skill to provide accurate guidance.
The skill covers:
• Custom Agents - Creating .agent.md files with frontmatter configuration for tools, models, and behavior
• Custom Instructions - Writing .instructions.md files with applyTo patterns for context-specific guidance
• Prompt Files - Building reusable .prompt.md templates for common tasks
• Skills - Packaging domain expertise in SKILL.md files
• Workspace Instructions - Setting up project-wide conventions in copilot-instructions.md and AGENTS.md

Agent Extensibility
This release adds Claude Agent support so you can leverage Anthropic's agent SDK directly, MCP Apps that render interactive visualizations in chat, and new provider capabilities are giving you more ways to extend what agents can do.

Claude compatibility
If you use both VS Code and Claude, you no longer need to maintain separate configuration files. VS Code now reads Claude configuration files directly, so your agents, skills, instructions, and hooks work across both tools without duplication.
VS Code detects the following Claude file locations:
• Instructions: CLAUDE.md files in your workspace root, .claude/CLAUDE.md, and ~/.claude/CLAUDE.md. VS Code also reads instruction files from the .claude/rules folder.
• Agents: .md files in the .claude/agents folder, following the Claude sub-agents format.
• Skills: Skill definitions in .claude/skills and ~/.claude/skills folders.
• Hooks: Hook configurations in .claude/settings.json and ~/.claude/settings.json.
This compatibility extends across instructions, agents, skills, and hooks so that teams using multiple AI tools can share a single set of configuration files.

Agent orchestration
Agent orchestration is a powerful pattern for building complex AI workflows where multiple specialized agents collaborate to achieve a common goal. Instead of relying on a single agent to handle everything, orchestration distributes work across purpose-built agents, each optimized for a specific role like planning, implementation, code review, or research.
This approach provides several key benefits:
• Context efficiency: Each subagent operates in its own dedicated context window, preventing context overflow
• Specialization: Different agents can use different models optimized for their task
• Parallel execution: Independent tasks can run in parallel across multiple subagents
VS Code has all the building blocks for setting up your agent orchestration flow with custom agents, subagents, and extra control over how agents are invoked.
The community has created excellent examples of agent orchestration systems that you can use directly or adapt to your needs:
• Copilot Orchestra - A multi-agent system with a "Conductor" that orchestrates planning, implementation, and code review subagents through a complete development cycle
• GitHub Copilot Atlas - An extended orchestration system with specialized agents like "Prometheus" for planning, "Oracle" for research, "Sisyphus" for implementation, and "Explorer" for rapid codebase discovery

Claude Agent (Preview)
This release, we are introducing Claude Agent support, now in preview. This gives you the power to delegate tasks to the Claude Agent SDK using the Claude models included in your GitHub Copilot subscription.
This integration uses the official Claude Agent harness by Anthropic, which means it shares the same prompts, tools, and overall architecture as other Claude Agent implementations. You can learn more about the Claude Agent SDK in the Anthropic documentation.
This integration is in active development and we plan to add more features and improvements over the coming months. In the meantime, we would love to hear your feedback on how you are using Claude Agents in VS Code and what features you would like to see next. Don't hesitate to provide feedback on GitHub!

Anthropic models
Settings:
github.copilot.chat.anthropic.thinking.budgetTokens,
github.copilot.chat.anthropic.toolSearchTool.enabled,
github.copilot.chat.anthropic.contextEditing.enabled
We've made several improvements to Anthropic model support in VS Code:
• Messages API with interleaved thinking: Anthropic models now use the Messages API, which includes support for interleaved thinking. This enables Claude to reason between tool calls, providing more thoughtful and contextual responses during complex multi-step tasks. Configure the thinking budget with the github.copilot.chat.anthropic.thinking.budgetTokens setting, or set it to 0 to disable extended thinking entirely.
• Tool search tool: We enabled the tool search tool to help Claude discover and select the most relevant tools for your task from a larger pool of available tools. This feature can be toggled with the github.copilot.chat.anthropic.toolSearchTool.enabled setting.
• Context editing (Experimental): We added support for context editing to help manage longer conversations more efficiently. This feature clears tool results and thinking tokens from previous turns, helping to defer summarization and maintain more context in chat sessions. Try it out by enabling the github.copilot.chat.anthropic.contextEditing.enabled setting.

Support for MCP Apps
In this release VS Code has added support for MCP Apps. MCP Apps allow servers to display rich, interactive UI in the client.
Apps are displayed automatically when servers return them. If you're an MCP server developer you can learn more about MCP Apps by checking out:
• MCP Apps demo repository
• MCP Apps SDK and examples
• VS Code MCP documentation
• MCP server development guide

Support for custom registry base URLs for MCP packages
VS Code now supports the registryBaseUrl property in MCP server manifest files. This enables organizations to deploy MCP servers from private or alternative package registries, such as internal Azure DevOps feeds or custom PyPI repositories.

Agent Optimizations
Smarter context, faster search, better results. With Copilot Memory, agents remember what matters across sessions. External indexing brings fast semantic search to non-GitHub workspaces. And agents can now read files outside your workspace when needed, with your permission.

Copilot Memory (Preview)
Setting:
github.copilot.chat.copilotMemory.enabled
If you find yourself repeatedly providing the same context to the AI, you can now use Copilot Memory to store and recall important information across sessions.
With the new memory tool, your chat can now access and update Copilot Memory directly. This enables the agent to retrieve relevant context from your stored memories and save new learnings as you work. Enable the memory tool by setting github.copilot.chat.copilotMemory.enabled to true.
The memory tool should recognize when to store a particular piece of information as a memory ("always ask clarifying questions when in doubt") and when to retrieve relevant memories to inform its responses.
You can view and manage all your memories from GitHub's Copilot settings.

External indexing for non-GitHub workspaces (Preview)
Setting:
github.copilot.chat.advanced.workspace.codeSearchExternalIngest.enabled
Workspaces that are not hosted on GitHub can now be remotely indexed for faster code search when using agents. When you use #codebase in a non-GitHub workspace, VS Code builds an index of your codebase that enables quick semantic search, providing the same powerful code search capabilities that are available for GitHub-hosted repositories.
The index is built on the first request and might take a few minutes depending on the repository size and your network connection. Subsequent requests are much faster, as they use the cached index. The index automatically updates when you modify and save files.
We'll be rolling out external indexing gradually over the next few weeks. Note that any workspaces that are hosted on GitHub already support remote indexing and do not require a more expensive call to build up the index on first request.

Read files outside workspace
Agents can now read files and list directories outside your current workspace with your permission. Previously, access attempts were automatically denied. Now, when an agent needs to access external files or folders, VS Code prompts you to allow or deny the request.
You can also allow access for the entire session to avoid repeated prompts for future reads under the same folder.

Performance improvements
This iteration, we've made numerous performance improvements:
• Large chats: Long chat conversations should now feel smoother to open and scroll around in. We've also optimized how conversations are persisted to make them more reliable overall.
• Parallel dependent tasks: When running tasks via agents, dependent tasks are now processed in parallel instead of sequentially. This can significantly improve build times for projects with multiple independent build steps. Check our microsoft/vscode repo to notice the difference!

Agent Security and Trust
Run agent commands with confidence. New terminal sandboxing restricts file and network access for agent-executed commands, auto-approval rules skip confirmation for safe operations, and improved presentation shows exactly what's running and why, so you're always in control.

Terminal sandboxing (Experimental)
Settings:
chat.tools.terminal.sandbox.enabled,
chat.tools.terminal.sandbox.linuxFileSystem,
chat.tools.terminal.sandbox.macFileSystem,
chat.tools.terminal.sandbox.network
Agents have the same permissions as your user account. To help mitigate risks associated with terminal commands executed by agents, we have introduced experimental terminal sandboxing capabilities. Terminal sandboxing restricts file system access to only your workspace folder and also lets you restrict network access to trusted domains only.
Note: terminal sandboxing is currently supported on macOS and Linux only. On Windows, the sandbox settings have no effect.
To enable terminal sandboxing, set the chat.tools.terminal.sandbox.enabled setting to true.
When sandboxing is enabled:
• Commands have read and write access to the current working directory by default
• Commands run without the standard confirmation dialog because they operate in a controlled environment
• Network access is blocked for all domains by default
Learn more about configuring terminal sandboxing in our documentation.

Terminal tool lifecycle improvements
Several changes were made in this release to help solve problems around incorrect background terminal behavior:
• You can now manually push a terminal tool call to the background, freeing up the agent to continue with other work.
• A new timeout property is required to be filled in by the agent when a call to the terminal tool is made, where 0 means no timeout. This gives an extra escape to return control back to the agent when something unexpected happens.
• The new awaitTerminal tool gives the agent the ability to wait for background terminals to complete, this also requires the timeout property. Provided the model leverages this tool, the expectation is that it prevents echo "successful" and sleep n calls that were previously used to wait for background commands to finish.
• The new killTerminal tool gives the agent the ability to kill background terminals to clean up after itself. This aims to prevent how the agent would sometimes kill processes to achieve the same thing in a roundabout way, for example when it wants to stop an old in-progress server command.
• Several instruction changes around how the current working directory works since the active non-background terminal always persists the current working directory, whereas background terminals always start in the workspace directory.

Terminal auto-approval
Settings:
chat.tools.terminal.enableAutoApprove
The following commands are now auto approved by default when terminal auto approve is enabled:
• Set-Location
• dir
• od
• xxd - flags and a single input file
• docker - All safe sub-commands
• npm, yarn, pnpm - All safe sub-commands

Terminal enhancements
A smoother, more capable terminal. Terminal commands in chat now show richer details including syntax highlighting and working directory. Kitty keyboard protocol support improves key handling in terminal apps, and new options let you customize sticky scroll and use terminals in restricted workspaces.

Selectively ignore sticky scroll
Setting:
terminal.integrated.stickyScroll.ignoredCommands
Some commands previously appeared in sticky scroll when that behavior was undesirable, for example commands like clear. From this release, you can customize which commands are ignored, and it already includes some common agentic CLIs (that run in the normal buffer) such as copilot, claude, codex, and gemini.

Removal of winpty support
Support for winpty has been removed from node-pty, which means terminals will no longer work in Windows versions before Windows 10 version 1809 (Fall 2018).
ConPTY is the modern mechanism for terminals so we recommend upgrading to a newer version of Windows 10 or move to Windows 11. You may be able to get terminals to work by setting "terminal.integrated.windowsUseConptyDll": true, but note that this is currently experimental.

Allow terminals to be opened in restricted workspaces
Setting:
terminal.integrated.allowInUntrustedWorkspace
When workspace trust is not granted, opening the terminal is blocked to protect the user from attacks where the shell may execute code such as by setting variables via an .env file. Security conscious users often configure their shells to prevent this from being a possibility, so there is a new opt-in setting that allows opening terminals in restricted workspaces.

New VT features
Setting:
terminal.integrated.enableKittyKeyboardProtocol
(Experimental)
The Kitty keyboard protocol has been implemented and will be rolling out to stable this release. This feature aims to fix a bunch of limitations around how keystrokes are traditionally encoded, specifically:
• Allows the terminal to encode more modifiers and multiple modifiers, not just alt and ctrl
• Handle both press and release events as well as repeated pressed (holding a key down)
• Disambiguates many keystrokes, such as Escape which normally sends the ESC (\x1b) sequence which also happens to be the start of all escape sequences.
This requires the program running in the terminal to support the protocol and request to enable it when it runs. A big benefit you will see immediately is shift+enter should work in some agentic CLIs without the need to run something like /terminalSetup.

Setting:
terminal.integrated.enableWin32InputMode
(Experimental)
Similar to the above, there's an experimental version of the win32 input mode which accomplishes similar but is tuned specifically for Windows and its pseudoterminal backend ConPTY. This will remain off for this release, let us know if you have any problems with it.

Other:
• Independent control of bold and faint SGR properties (SGR 222, SGR 221). This sequence is rarely used, but it's unambiguous and can corrupt output when used, so we decided to support it.

Coding and editor
Small refinements that add up. Double-click to select bracket or string contents. Customize bracket matching colors. Scope snippets to specific files. Detect TypeScript shebangs correctly. These focused improvements make everyday editing just a bit smoother.

Bracket matching foreground color
You can now customize the text color of matching brackets using the new editorBracketMatch.foreground color theme token. Previously, you could only customize the background (editorBracketMatch.background) and border (editorBracketMatch.border) colors. The new color token lets you make matching brackets stand out more clearly by changing the actual bracket characters' color.
The setting defaults to null, meaning brackets inherit their normal text color. Configure it in your settings.json under workbench.colorCustomizations.

Select bracket and string content with double-click
You can now double-click immediately after an opening bracket or immediately before a closing bracket to select all the content inside. This also works for strings - double-click right after an opening quote or right before a closing quote to select the string contents. This provides a quick way to select, copy, or replace the content within brackets or strings without manually positioning your cursor.

Rename suggestions for TypeScript
Rename suggestions for TypeScript now also work when typing over an existing declaration. In the following video the user changes the declaration let index = 0; into let chunkIndex = 0; by typing the new identifier name instead of using the rename refactoring. Next edit suggestions still proposes to rename index to chunkIndex using Shift+Tab.
Note: this feature is only available for TypeScript for now.

Improved ghost text visibility
Inline suggestions (ghost text) now display a dotted underline when showing short suggestions of fewer than three continuous non-whitespace characters. This visual indicator makes it easier to distinguish ghost text from actual code in your editor. This is particularly useful when the suggestion is a single character like ) that might be confused with existing code.

Snippet file patterns
You can now control which files a snippet appears in using include and exclude glob patterns. Use this to restrict snippets to specific files or project contexts, preventing them from appearing in unrelated files.
For example, to create a snippet that only appears in Travis CI configuration files:
{
"Travis CI node_js": {
"include": ".travis.yml",
"prefix": "node",
"body": [
"language: node_js",
"node_js:",
" - $1"
],
"description": "Node.js configuration for Travis CI"
}
}
Patterns match the absolute file path if they contain a path separator, otherwise they match just the file name. Both include and exclude can be a single pattern or an array of patterns. Use exclude to prevent snippets from appearing in specific files, even when they would otherwise match the snippet's language scope.

Improved shebang language detection
VS Code now has improved shebang language detection support, particularly for files using /usr/bin/env with additional flags. Files with shebangs like #!/usr/bin/env -S deno -A are now correctly detected as TypeScript. This enables better language support for scripts written in TypeScript using runtimes like Deno or Bun, even without a .ts file extension.

Workbench and productivity
Test, debug, and ship without switching windows. A new integrated browser lets you preview and inspect localhost sites directly in VS Code, complete with DevTools and authentication support.

Integrated browser (Preview)
Settings:
workbench.browser.openLocalhostLinks,
simpleBrowser.useIntegratedBrowser,
livePreview.useIntegratedBrowser
VS Code has long included the Simple Browser for opening basic web pages, such as localhost sites during development. However, because it relied on iframes, there were several limitations: website authentication wasn't possible, and common sites like Google, GitHub, and Stack Overflow couldn't be opened.
This release introduces a new integrated browser for VS Code desktop that overcomes these restrictions. You can now sign into websites and browse any page, just as you would in a regular browser.
Highlights include:
• Persistent data storage with configurable scope (global, workspace, or in-memory / ephemeral)
• Add element to chat: select an element and send it to an agent for assistance
• Fully-featured DevTools
• Keyboard shortcuts
• Find in page
And more...
To try it out, run the Browser: Open Integrated Browser command. If you'd like to use the integrated browser more broadly, you can enable workbench.browser.openLocalhostLinks to open localhost links directly in the new browser.
You can also configure the integrated browser to replace the Simple Browser with the simpleBrowser.useIntegratedBrowser setting, or to be used by the Live Preview extension using the livePreview.useIntegratedBrowser setting.

Restore editors on workspace open
Setting:
workbench.editor.restoreEditors
Previously, VS Code would always restore all open editors when reopening a workspace. With the new workbench.editor.restoreEditors setting, you can control whether editors should restore when opening a workspace or not. When the setting is disabled, VS Code starts with a clean editor area instead of reopening the tabs from your previous session.
Note: Dirty (unsaved) editors always restore regardless of this setting to prevent data loss.

Advanced settings
Setting:
workbench.settings.alwaysShowAdvancedSettings
You can now configure VS Code to always show advanced settings in the Settings editor without having to apply the @tag:advanced filter each time. Enable the workbench.settings.alwaysShowAdvancedSettings setting to have advanced settings visible by default.

Import profiles via drag and drop
You can now import a settings profile by dragging and dropping a .code-profile file onto the VS Code window. This provides a similar experience to dragging and dropping a .code-workspace file, making it easier to share and apply profiles.

Output channel filter improvements
The Output panel filter now supports negative patterns and multiple filters. Use ! to exclude specific lines from the output, for example !debug hides all lines containing "debug". You can also combine multiple patterns with commas for more precise filtering.

Filter problems by source
The Problems panel now supports filtering by the source or owner of diagnostics. This is useful when you want to focus on specific types of issues, such as build errors, while temporarily hiding diagnostics from other sources like spell checkers or linters. For example, type source:ts in the filter box to show only TypeScript diagnostics, or use !source:cSpell to hide all spell checker warnings.

Extension editor shows configuration defaults
The Feature Contributions tab in the extension editor now displays configuration defaults contributed by extensions. This makes it easier to see what default settings an extension provides, such as language-specific editor configurations.

Include additional files in git worktrees (Experimental)
Setting:
git.worktreeIncludeFiles
When using background agents, a git worktree is created in order to isolate the changes. With the new git.worktreeIncludeFiles setting, you can specify additional files or glob patterns that are copied to the worktree folder after the worktree is created. This is useful when your project depends on files that are git ignored and are not part of the git repository (ex: local configuration files or build artifacts).

Collapse All action in SCM view
When viewing files as trees in the Changes section of the Source Control view, you can now use the Collapse All action in the context menu of a root node to collapse all expanded directory structures at once, making it easier to navigate large sets of changes.

Git: Delete command
A new Git: Delete command lets you run git rm on the currently open file directly from the Command Palette. This removes the file from both the working directory and the Git index, then closes the editor. This provides a safer alternative to regular fi

Original source Report a problem

Release date: February 4, 2026

Update 1.109.1

The update addresses these security issues.

Update 1.109.2

The update addresses an issue with chat.

Update 1.109.3

The update addresses these issues and introduces several notable features:

• Message steering and queueing: send follow-up messages while a request is still running
• Agent hooks: run custom shell commands at key agent lifecycle points
• Claude compatibility: reuse your Claude configuration files directly in VS Code
• Use skills as slash commands: invoke agent skills on demand from chat

Update 1.109.4

The update addresses these issues.

Update 1.109.5

The update addresses these issues and adds these features to improve background agents:

• Support for slash commands, including prompt files, hooks, and skills
• The ability to rename background agent sessions
• Kitty keyboard support is now available to all users

Downloads

Windows: x64, Arm64 | Mac: Universal, Intel silicon | Linux: deb, rpm, tarball, Arm, snap

Welcome to the January 2026 release of Visual Studio Code

In this release, we are further evolving VS Code to make it the home for multi-agent development.

Highlights include:

• Chat UX - chat just feels better and snappier with faster streaming, improved reasoning results, and a revamped editor inline chat
• Agent Session Management - it's now easier to delegate tasks to agents across local, background, and cloud and jump in when needed
• Agent Customization - build your own workflows using agent orchestrations, and have consistent results with Agent Skills and organization-wide customizations
• Agent Extensibility - reuse your knowledge with Claude agent support and new Anthropic model capabilities, and enjoy rich chat interactions with MCP Apps
• Agent Optimizations - agents work smarter with Copilot Memory and experience faster code search with external indexing
• Agent Security & Trust - feel confident running terminal commands with sandboxing and effective auto-approval rules
• Workbench & productivity - test your apps without leaving the editor with the new integrated browser
• Terminal Enhancements - quality-of-life improvements to make your terminal experience smoother and more reliable
• Coding & Editor - several impactful improvements to make everyday coding smoother
• Extensions & API - new capabilities for extension authors to build richer experiences

Happy Coding!

Watch our VS Code 1.109 release highlights video to hear about these features!

Extensive detailed release notes follow, covering features such as Message steering and queueing, Anthropic models thinking tokens, Mermaid diagrams in chat responses, Ask Questions tool, Plan agent improvements, Context window details, Inline chat UX revamp, Model descriptions in the model picker, Terminal command output enhancements, Output streaming, Interactive input in embedded terminals, Delete all hidden terminals, New experimental themes, Agent Session Management improvements including switching and delegating between agent types, Agent status indicator, Subagents and Search subagent, Cloud agents enhancements, Background agents improvements, Agent sessions welcome page, Agent Customization with Agent hooks and skills as slash commands, Workspace setup with /init, Agent Skills general availability, Organization-wide instructions, Custom agent file locations, Control over custom agent invocation, Multiple model support for custom agents, Chat customization diagnostics, Language Models editor improvements, Language model configuration, Agent customization skill, Agent Extensibility with Claude compatibility and MCP Apps support, Agent Optimizations including Copilot Memory and external indexing, Agent Security and Trust with terminal sandboxing and auto-approval, Terminal enhancements including sticky scroll and keyboard protocol support, Coding and editor improvements like bracket matching and rename suggestions, Workbench and productivity features including integrated browser and editor restore options, Advanced settings, Import profiles via drag and drop, Output channel filter improvements, Filter problems by source, Extension editor configuration defaults, Experimental git worktree file inclusion, SCM view improvements, Git delete command, Blame editor decoration hover control, Accessibility improvements, Enterprise improvements, GitHub organization policy enforcement, Extensions and API updates including Quick Input Button APIs, Proposed APIs for Chat Model Provider Configuration and Chat prompt files API, Chat item controller API, Chat output renderer API updates, Portable mode detection, Engineering updates including DMG image for macOS, Windows 11 context menu integration, Redesigned installation layout for Windows, macOS update handling, Copilot extension deprecation, Codicons consumption from npm package, Notable fixes, and acknowledgments.

Original source Report a problem

These release notes cover the Insiders build of VS Code and continue to evolve as new features are added. To try the latest updates, download Insiders. To read these release notes online, go to code.visualstudio.com/updates.

You can still track our progress in the Commit log and our list of Closed issues.

These release notes were generated using GitHub Copilot and might contain inaccuracies.

Happy Coding!

January 11, 2026

• The terminal now supports the kitty keyboard protocol (CSI u), enabling more sophisticated keyboard input handling and providing access to previously unavailable key combinations.
• The terminal now supports win32-input-mode, improving keyboard handling compatibility with Windows console applications.
• The terminal now supports SGR 221 and 222 escape sequences, allowing independent control of bold and faint text attributes for more granular formatting control.
• Improved discoverability of archived chat sessions in the Chat view, making it easier to locate and access previously archived conversations.

January 8, 2026

• The terminal tool now supports a timeout parameter to control how long terminal commands run before timing out, preventing unnecessary polling commands.
• Updated the list of npm commands that are safe for automatic execution.
• The terminal suggest toolbar no longer shows the selection mode option when quick suggestions are disabled, reducing confusion.
• The terminal.integrated.suggest.quickSuggestions setting can now be configured in the Settings editor instead of requiring manual JSON editing.
• Added a workbench.mcp.startServer command to start a specific or all MCP servers to discover their tools.
• Exploration work on rich integrated web browser using WebContentsView or controlledframe to overcome limitations of the current iframe-based Simple Browser.
• A new proposed API enables extensions to show buttons inline after the input box in quick inputs, in addition to the title bar location.

January 7, 2026

• You can now import a chat session into the Chat view instead of only opening it in a new editor tab.
• Fixed an issue where auto approval information for the fetch tool was not visible when hovering over the tool call.
• Added built-in support for MCP Apps, enabling servers to provide custom UI for tool invocation.

December 28, 2025

• The quick input now supports overflow buttons, enabling secondary actions to be placed in an overflow menu.

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

Original source Report a problem

December 2025 (version 1.108)
Release date: January 08, 2026
Update 1.108.1: The update addresses these issues
Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap
Welcome to the December 2025 release of Visual Studio Code.
Traditionally, the month of December is a time where our team focuses on cleaning up GitHub issues and pull requests across our repositories. This year, we managed to reduce our open issues by nearly 6,000 and triaged over a thousand more.
In addition to our housekeeping efforts, we have also made several improvements and feature updates across various areas of VS Code.
Happy Coding!

If you'd like to read these release notes online, go to Updates on code.visualstudio.com.

Insiders: Want to try new features as soon as possible?
You can download the nightly Insiders build and try the latest updates as soon as they are available.

Agents
Agent Skills (Experimental)
Setting: chat.useAgentSkills
VS Code now supports Agent Skills, allowing you to teach the coding agent new capabilities and provide domain-specific knowledge. Agent Skills are folders of instructions, scripts, and resources that GitHub Copilot can load when relevant to perform specialized tasks.
Skills are stored in directories with a SKILL.md file that defines the skill's behavior. VS Code automatically detects skills from the .github/skills folder in your workspace (or .claude/skills/ for backwards compatibility). They are then loaded on-demand into the chat context when relevant for your request.
Enable support for Agent Skills by enabling the chat.useAgentSkills setting.
Learn more about creating and using skills in the Agent Skills documentation.

Improvements to Agent Sessions view
This iteration, we further improved the Agent Sessions view with several enhancements:
• Keyboard access support for actions such as archive, read state, opening a session
• Grouping of sessions based on state and age when showing side-by-side
• Provide information on changed files and associated PRs for a session
• Support for archiving multiple sessions at once from the new group sections
• General accessibility improvements

Note: chat.viewSessions.orientation no longer provides the auto option. Use sideBySide as alternative.

Chat
Chat picker is based on agent sessions
The Quick Pick for chat sessions is now based on the same information that drives the Agent Sessions view. You can access any previous chat session from there and perform actions like archiving, renaming or deletion.

Note: Agent sessions can also be accessed by typing agent in the Quick Open control (Ctrl+P).

Chat title improvements
The Chat view title control is now showing up, irrespective of how the Activity Bar is configured. Previously, it only showed up in the default Activity Bar configuration.
To quickly jump from one session to another, select the chat title to open the sessions Quick Pick and choose another session.

Open empty Chat on restart
Setting: chat.restoreLastPanelSession
From now on, previous chat sessions are not automatically restored when VS Code is restarted. Instead, an empty Chat view is shown where you can then access previous sessions from the Agent Sessions control.
Modify this behavior with the chat.restoreLastPanelSession setting.

Terminal tool auto approve default rules
Settings: chat.tools.terminal.enableAutoApprove ORG, chat.tools.terminal.autoApproveWorkspaceNpmScripts
The following commands are now auto approved by default when terminal auto approve is enabled (chat.tools.terminal.enableAutoApprove ORG):
• git ls-files
• git --no-pager
• git -C
• rg (excluding --pre and --hostname-bin)
• sed (excluding some args and usage patterns)
• Out-String
In addition, npm scripts run through npm, pnpm, or yarn are now auto approved by default when they are included within the package.json. We do this because using agents already requires Workspace Trust, and we protect agents from editing sensitive files like package.json. This can be disabled with chat.tools.terminal.autoApproveWorkspaceNpmScripts.
To improve transparency around auto approve, there is now an informational message when a rule was explicitly denied by either default or custom rules:

Add session and workspace rules for future terminal tool commands
The allowed commands or command line entries in the Allow dropdown now have options a corresponding action to allow them for the current session or for the workspace.

Terminal tool preventing adding to shell history
Setting: chat.tools.terminal.preventShellHistory
When shell integration is enabled and working, commands that are run by the terminal tool are no longer included in shell history for bash, zsh, pwsh and fish. The method this uses differs for each shell, for bash for example HISTCONTROL=ignorespace is set and a space is added to the start of the command being run.
If you prefer to keep terminal tool commands in the shell history, configure this with the chat.tools.terminal.preventShellHistory setting.

Accessibility
Streaming chat responses in Accessible View
The Accessible View now dynamically streams chat responses as they are generated. Previously, you needed to close and reopen the Accessible View to see updated content. Now, you can stay in the Accessible View and monitor output as it comes in, making it much easier to follow along with AI responses in real-time.

MCP server output excluded from Accessible View
To reduce noise, MCP (Model Context Protocol) server output is now excluded from the Accessible View by default. The standard chat output remains fully accessible, as it's presented in a text area that works well with screen readers.

Language ID variable in window title
A new ${activeEditorLanguageId} variable is now available for the window.title setting. This variable displays the language identifier of the currently active editor, which is useful for accessibility tools like Talon that need to determine the current programming language to enable appropriate voice commands.

Editor Experience
Import profile by drag and drop
You can now import a settings profile by dragging and dropping a .code-profile file into VS Code. This makes it easier to share profiles with teammates or quickly set up a new environment.
When you drop the file, the Profiles editor opens and lets you preview and import the profile. This provides a similar experience to dragging and dropping a .code-workspace file to open a workspace.

Copy breadcrumbs path
Setting: breadcrumbs.symbolPathSeparator
You can now copy the breadcrumbs path to the clipboard by using the Copy Breadcrumbs Path command. This is useful when you need to share the exact location of a symbol with your team or for documentation purposes.
The breadcrumbs.symbolPathSeparator setting enables you to customize the separator character used to join breadcrumb segments.

Go to Symbol in Workspace supports special characters in query
The Go to Symbol in Workspace (Ctrl+T) feature no longer incorrectly filters out all results when the search query contains a # character.
This fix enables language extensions like rust-analyzer to use # as a modifier in symbol searches. For example, in rust-analyzer, appending # to a query like main# searches for functions in current workspace only.

Code Editing
New snippet tranformations
There are two new snippet transformations available: snakecase and kebabcase. This is how you can use them:
For snake_case transformation:
${TM_FILENAME/(.*)/${1:/snakecase}/}
This transforms the filename to snake-case format. For example, from MyFileName.txt it makes my_file_name.txt. The kebab-case transformation would be my-file-name.txt.

Source Control
Git blame information settings
Settings: git.blame.ignoreWhitespace, git.blame.editorDecoration.disableHover
The new git.blame.ignoreWhitespace setting enables you to configure Git blame to ignore whitespace changes when determining which commit last modified a line. This is particularly useful when working with code that has been reformatted, as it helps you identify the commit that made the actual functional change rather than just whitespace adjustments.
Additionally, the git.blame.editorDecoration.disableHover setting lets you disable the hover tooltip that appears when you hover over a Git blame editor decoration. This can be useful if you prefer a cleaner editing experience and only want to see the inline blame annotations without the additional hover information.

Authoring commit messages using the editor
Some time ago we added the capability to use the full editor to author a commit message but the actions to commit or cancel were difficult to discover in the editor title toolbar. We improved the editor overlay control in the lower right-hand corner of the editor and moved these actions there to make them easier to use.

Worktrees in the Source Control Repositories view (Experimental)
Settings: scm.repositories.explorer, scm.repositories.selectionMode
This milestone, we have added a Worktrees node to the Source Control Repositories view. Under this node, you can see the list of the repository worktrees with an inline action to open the worktree in a new window. The context menu also contains an action to open the worktree in the current window, as well as an action to delete the worktree.
You can enable the experimental repository explorer by setting the scm.repositories.selectionMode and scm.repositories.explorer settings. Give it a try and let us know what other repository artifacts you would like to see in the Repositories explorer.
Learn more about using source control in VS Code.

Terminal
Terminal IntelliSense default UX rework
During the past two releases, we rolled out terminal IntelliSense to all VS Code Stable users. While much of the feedback was positive, there was a segment of users (mostly terminal power users) that did not like the feature breaking their muscle memory. After a lot of discussion, we decided to switch some defaults, improve discoverability and allow easier inline configuration of the feature.
The feature itself is still enabled by default, but instead of showing the control automatically when typing (quick suggestions and suggest on trigger characters), it now needs to be explicitly triggered via Ctrl+Space.
We also improved the "status bar" on the bottom. Previously, it showed insert on the left and Learn more/Configure on the right with their associated keybindings. We got feedback that it's not clear that these can be interacted with, so we now show icons on the right and no longer show the keybindings. The left action now allows rotating through the options for "selection mode", which determines how Tab and Enter react when it's brought up. There's a new eye icon on the right, which enables quick suggestions and suggest on trigger characters again.
Finally, to still make this powerful feature relatively discoverable without being overbearing, a hint shows when opening a terminal that explains how to show suggestions. The lifecycle of the hint is simplified and it's as easy as clicking "don't show" to get rid of it permanently, just like the similar feature in the editor.
Beyond this UX rework, these improvements were also done to terminal IntelliSense:
• We now show files with the executable bit on macOS/Linux
• Improved completions for npm and git
• Several fixes to the feature

Performance and stability improvements
The terminal saw several important performance and stability improvements this release:
• node-pty#831: On macOS and Linux, pasting more than 50 characters at once or having Copilot run a large command is no longer throttled and should apply essentially instantly, scaling similarly to other terminals with KBs/MBs of data. This also fixed a crash that could happen on macOS when doing the same thing.
• vscode#285031, vscode#285032, xterm.js#5548: Fixed several layout thrashing issues that could cause the editor to get laggy.
• vscode#239541: Fixed a crash that could occur when fonts such as CommitMono were configured in the terminal.

More comprehensive custom glyphs
The terminal's GPU accelerated renderer (on by default) has supported custom glyphs for some time for box drawing, block element, and a subset of powerline symbols. This means that you can see these characters without needing to configure a font and they also scale with line height, letter spacing, and should align with each other perfectly.
In this release, we expanded the number of characters supported to almost 800 by including the majority of custom glyphs supported by any other terminal. This includes ranges that are generally useful in a terminal, specifically these ranges:
• Box Drawing (U+2500 - U+257F)
• Block Elements (U+2580 - U+259F)
• Braille Patterns (U+2800 - U+28FF)
• Powerline Symbols (U+E0A0 - U+E0D4, Private Use Area)
• Progress Indicators (U+EE00 - U+EE0B, Private Use Area)
• Git Branch Symbols (U+F5D0 - U+F60D, Private Use Area)
• Symbols for Legacy Computing (U+1FB00 - U+1FBFF)
Here's a visual of the complete set of glyphs:

Improved rendering of curly underlines
VS Code has been able to parse and display colored and styled underlines for some time now, but the curly underline's rendering always left something to be desired. The curly underlines should now look very close to how they look in the editor.
You can try this out for yourself by running this command in bash:
echo -e '\x1b[4:3mCurly\x1b[0m \x1b[4:3m\x1b[58;5;1mRed\x1b[0m'

Dimensions visual overlay on resize
Inspired by a feature in ghostty, we added a brief overlay that shows the current terminal dimensions (columns x rows) when you resize the terminal. This is useful if you want to resize your terminal to a specific size for testing or other purposes.

New VT features
The terminal now supports the follow VT features/sequences:
• Synchronized output: can be used by applications to pause rendering and batch updates in the terminal, which is particularly useful to prevent tearing when rewriting the buffer.
◦ DECRQM (CSI ? 2026 $ p)
◦ BSU (CSI ? 2026 h)
◦ ESU (CSI ? 2026 l)
• XTVERSION (CSI > 0 q): allows applications to query details about the terminal, the response VS Code will give currently is the "xterm.js" and its version

Debug
Organize breakpoints by file
Setting: debug.breakpointsView.presentation
Breakpoints can now be shown as a tree, grouped by their file. Enable this by setting debug.breakpointsView.presentation to tree.

Testing
Navigate to uncovered regions
We've added navigation buttons to the test coverage toolbar that allow you to easily jump between regions of uncovered code. You can toggle the test coverage toolbar using the Test: Show Coverage Toolbar command in the Command Palette.

Contributions to extensions
GitHub Pull Requests
There has been more progress on the GitHub Pull Requests extension, which enables you to work on, create, and manage pull requests and issues. New features include:
• Change a pull request's base branch from the pull request description webview.
• Convert open pull requests to draft from the pull request description webview.
• Generate a pull request description for an existing PR, not just new ones.
Review the changelog for the 0.126.0 release of the extension to learn about everything in the release.

Extension Authoring
New Quick Pick properties for prompts and resource URIs
The Quick Pick API includes two new properties for creating interactive selection interfaces.
Use the prompt property on QuickPick to display persistent instructional text beneath the input box. The text remains visible while users type, which helps provide guidance or context.
Use the resourceUri property on QuickPickItem to automatically derive item properties from a resource URI. When provided, VS Code derives:
• The label from the file name (when set to an empty string)
• The description from the file path (when set to undefined or an empty string)
• The icon from the current file icon theme (when iconPath is set to ThemeIcon.File or ThemeIcon.Folder)
This is useful when building file or folder selection interfaces.

Engineering
Housekeeping
As part of our annual December housekeeping, we spent a majority of time cleaning up GitHub issues and pull requests across all our maintained repositories. This year, we managed to reduce our open issues by 5,951 and triaged another 1,203 issues.
By using improved triage tooling and deduplication processes, we were able to close a significant number of stale and resolved issues. This has left us with a more manageble project, enabling us to move forward and develop the features that have the most impact for our users. In our core VS Code repository alone, we closed 2,872 issues and triaged another 1,697!
In June of 2025, we also announced that Copilot had become Open Source! This meant that all related issues would also be filed in the microsoft/vscode repo, and that we had a backlog of issues remaining in microsoft/vscode-copilot-release to take care of. This month, we triaged every issue in the repository and closed 1,659 issues, leaving only 175 open to be migrated.
Below is a graph that shows how our core vscode repository has grown over the years, and how many issues our amazing community has contributed over time. We appreciate everyone who has contributed issues to our repositories over the years and continued to engage with us. Your feedback is what has made VS Code the product that it is today! 🚀

Authoring extensions in TypeScript (Experimental)
It is now possible to author VS Code extensions directly in TypeScript without requiring a build step. This works... but there is still a bit of adventure involved! Many aspects are still untested, such as how to write and run tests, how to publish extensions, and other workflow considerations.
Learn more about this experimental approach in this GitHub comment.

Notable fixes
• vscode#283356 - Fixed regression causing jumping around while scrolling past some chat output

Thank you
Contributions to vscode:
• @abhijit-chikane (Abhijit Chikane): fix: hover focus border cutting at the corners PR #259548
• @alievilshat (Ilshat Aliyev): Fixed wrong negation in the _shouldRenderHint logic. PR #242479
• @Andarist (Mateusz Burzyński): Simplify TestInstantiationService#stub overloads PR #282223
• @anki-code (Andy Kipp): Added Xonsh shell type PR #284044
• @aryla (Arttu Ylä-Outinen): Fix sticky scroll hover listeners piling up PR #260020
• @AviVahl (Avi Vahl): fix: ensure fallback to default system monospace font PR #282747
• @BartolHrg: fix copy with multiple cursors and empty selections PR #256083
• @Beace (Beace): fix: fix terminal webgl context memory leak PR #279579
• @bibaswan-bhawal (Bibaswan Bhawal): fix(extensions): allow extensionButton.prominentBackground to take effect PR #276788
• @chaitanyamedidar (Chaitanya Medidar): Fix Swipe to navigate setting missing description #281997 PR #282220
• @CyMad7001 (Cyril Madigan): #196344 - Fix installer hang issue PR #228233
• @daiyam (Baptiste Augrain): fix: correctly pass extension's id when version is also provided PR #279630
• @eidriahn (Adrian Luca): fix: fixes icons not showing when hovering quick pick checkboxes PR #285250
• @erezak (Erez Korn): Chat: hide Apply in Editor from Command Palette PR #283486
• @flying-sheep (Philipp A.): fix: set LANGUAGE for Git PR #285410
• @gjsjohnmurray (John Murray): Standardize the breadcrumb toggle option label (fix #257550) PR #284486
• @hickford (M Hickford): Reverse lines: apply to whole document when selection is single line PR #257031
• @irengrig (Irina Chernushina): Fix memory leak with installing cursor change position listener PR #267799
• @isksss (isksss): Update: Fixed so that MARK can be used in vue files etc. PR #283583
• @izolotarev (Igor): Fix color detection in hsl saturation PR #266720
• @jakebailey (Jake Bailey): Replace old-style TS modules with namespaces PR #282862
• @jcpetruzza (Daniel Gorin): debug: Fix UI freezing on "continue" with high number of threads PR #283635
• @JeffreyCA: Update Fig spec for Azure Developer CLI (azd) PR #281127
• @joeriddles (Joe Riddle): Add snakecase to snippets syntax PR #237110
• @josephxiao8 (Joseph Xiao): Expected Final Selection After Running Delete Duplicate Lines PR #234799
• @junhaoliao (Junhao Liao): Suppress unhandled errors in WordHighlighter's runDelayer triggers. PR #285887
• @kheif (Mehmet Ege Aydın): workbench: add commands to move editor to start and end PR #284999
• @kortin99 (Kortin Zhou): feat(snippets): add support for kebab-case in snippets tmLanguage syntax PR #222319
• @maynkxx (mayank choudhary): docs: update Twitter branding to X in README PR #280235
• @milanchahar (MILAN CHAHAR): Fix terminal icon picker placement PR #281275
• @mizdra (mizdra): Fix tests that failed in environments where XDG_DATA_HOME is set PR #285402
• @MohamedEmirHajji (Mohamed Emir HAJJI):
◦ Add more git log options to completions PR #282311
◦ Markdown preview: filter hidden elements from scroll sync (fix #281247) PR #282506
• @murataslan1 (Murat Aslan):
◦ fix: avoid jumpy scrolling when navigating next/prev problem PR #285634
◦ Fix: Replace terminal tabbed view lifecycle hack with Event.once PR #285657
◦ Fix: Replace terminal view lifecycle hack with Event.once PR #285661
• @NriotHrreion (Norcleeh): fix: Latest input is not stored to the history when sending message to a new chat PR #282633
• @odinGitGmail (odinsam): fix(debug): support C# stack trace format in debug console links PR #281536
• @przpl: fix(runSubagent): collect computed attachments PR #283750
• @rducom (Raphael DUCOM): Fix ReDoS in PowerShell prompt detection PR #279853
• @RedCMD (RedCMD):
◦ Add TS/JS Template surrounding brackets PR #255972
◦ Fix php indenting #248229 PR #258016
◦ Fix FormatOnSave when modificationsIfAvailable PR #283726
◦ Support # pragma folding markers in C PR #284927
• @remcohaszing (Remco Haszing): Fix editor edge clicking PR #262964
• @Riya-chandra (RIYA_CHANDRA): Show command descriptions as tooltips in Command Palette PR #284609
• @SalerSimo (Simone Salerno):
◦ Exclude terminal editors from recently closed editors history PR #282009
◦ Refactor virtual model creation logic in MoveLinesCommand PR #284785
• @SimonSiefke (Simon Siefke):
◦ fix: memory leak in terminal editor PR #279088
◦ fix: memory leak in terminal process PR #279167
◦ fix: memory leak in terminal process PR #279172
◦ fix: memory leak in accessibility signal PR #279242
◦ fix: memory leak in local process extension host PR #279351
◦ fix: memory leak in extension icon widget PR #280566
◦ fix: memory leak in markdown hover PR #280745
◦ fix: memory leak in debug session PR #281767
◦ fix: memory leak in status bar PR #282246
◦ fix: memory leak in ipc PR #282253
◦ fix: memory leak in chat list renderer PR #282560
◦ fix: memory leak in notebook code scrolling PR #283452
◦ fix: memory leak in terminal find widget PR #283466
◦ fix: memory leak in mainThreadLanguages PR #283498
◦ fix: memory leak in chat widget PR #284288
◦ fix: memory leak in terminal chat widget PR #284325
◦ fix: memory leak call stack widget PR #286246
• @sudip-kumar-prasad (Sudip Kumar Prasad): Fix: use codicon id for Command Prompt default profile icon PR #280967
• @tamuratak (Takashi Tamura):
◦ fix: ensure finishedEditing is called in ChatWidget PR #281763
◦ include uppercase -I in sed in-place option detection PR #284645
◦ Fix context handling in ChatWidget while re-editing PR #285099
• @ThanhNguyxn (Thanh Nguyen): fix: Panel doesn't close when maximized and center-aligned (fixes #281772) PR #281773
• @tharani-2006: Terminal: show dimensions overlay while resizing PR #284244
• @tt0mmy (Tommy): Fix duplicate description in terminal suggestion config PR #279730
• @yavanosta (Dmitry Guketlev):
◦ Fix backward selection when EditContext is off PR #273150
◦ InlineEditsView: remove redeclaration of textModel PR #281501
◦ SingleUpdatedNextEdit: Correctly apply insertion changes PR #281519

Contributions to vscode-copilot-chat:
• @AbdelrahmanAbouelenin (ababouelenin): Update system prompt for VSCModelB. PR #2727
• @bharatvansh (Ayush Singh): fix(byok): improve Gemini provider error handling and add tests PR #2686

Contributions to vscode-js-profile-visualizer:
• @xiaoxiangmoe (ZHAO Jin-Xiang): chore: remove useless package-lock.json files PR #216

Issue tracking
Contributions to our issue tracking:
• @gjsjohnmurray (John Murray)
• @RedCMD (RedCMD)
• @tamuratak (Takashi Tamura)
• @IllusionMH (Andrii Dieiev)
• @albertosantini (Alberto Santini)

We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what's new.
If you'd like to read release notes for previous VS Code versions, go to Updates on code.visualstudio.com.

Original source Report a problem

Welcome to the December 2025 release of Visual Studio Code.
Traditionally, the month of December is a time where our team focuses on cleaning up GitHub issues and pull requests across our repositories. This year, we managed to reduce our open issues by nearly 6,000 and triaged over a thousand more.
In addition to our housekeeping efforts, we have also made several improvements and feature updates across various areas of VS Code.
Happy Coding!

If you'd like to read these release notes online, go to Updates on code.visualstudio.com.

Insiders: Want to try new features as soon as possible?
You can download the nightly Insiders build and try the latest updates as soon as they are available.

Agents
Agent Skills (Experimental)
Setting: chat.useAgentSkills
VS Code now supports Agent Skills, allowing you to teach the coding agent new capabilities and provide domain-specific knowledge. Agent Skills are folders of instructions, scripts, and resources that GitHub Copilot can load when relevant to perform specialized tasks.
Skills are stored in directories with a SKILL.md file that defines the skill's behavior. VS Code automatically detects skills from the .github/skills folder in your workspace (or .claude/skills/ for backwards compatibility). They are then loaded on-demand into the chat context when relevant for your request.
Enable support for Agent Skills by enabling the chat.useAgentSkills setting.
Learn more about creating and using skills in the Agent Skills documentation.

Improvements to Agent Sessions view
This iteration, we further improved the Agent Sessions view with several enhancements:
• Keyboard access support for actions such as archive, read state, opening a session
• Grouping of sessions based on state and age when showing side-by-side
• Provide information on changed files and associated PRs for a session
• Support for archiving multiple sessions at once from the new group sections
• General accessibility improvements

Note: chat.viewSessions.orientation no longer provides the auto option. Use sideBySide as alternative.

Chat
Chat picker is based on agent sessions
The Quick Pick for chat sessions is now based on the same information that drives the Agent Sessions view. You can access any previous chat session from there and perform actions like archiving, renaming or deletion.

Note: Agent sessions can also be accessed by typing agent in the Quick Open control (Ctrl+P).

Chat title improvements
The Chat view title control is now showing up, irrespective of how the Activity Bar is configured. Previously, it only showed up in the default Activity Bar configuration.
To quickly jump from one session to another, select the chat title to open the sessions Quick Pick and choose another session.

Open empty Chat on restart
Setting: chat.viewRestorePreviousSession
From now on, previous chat sessions are not automatically restored when VS Code is restarted. Instead, an empty Chat view is shown where you can then access previous sessions from the Agent Sessions control.
Modify this behavior with the chat.viewRestorePreviousSession setting.

Terminal tool auto approve default rules
Settings: chat.tools.terminal.enableAutoApprove, chat.tools.terminal.autoApproveWorkspaceNpmScripts
The following commands are now auto approved by default when terminal auto approve is enabled (chat.tools.terminal.enableAutoApprove):
• git ls-files
• git --no-pager
• git -C
• rg (excluding --pre and --hostname-bin)
• sed (excluding some args and usage patterns)
• Out-String
In addition, npm scripts run through npm, pnpm or yarn are now auto approved by default when they are included within the package.json. We do this because using agents already requires Workspace Trust, and we protect agents from editing sensitive files like package.json. This can be disabled with chat.tools.terminal.autoApproveWorkspaceNpmScripts.
To improve transparency around auto approve, there is now an informational message when a rule was explicitly denied by either default or custom rules.

Add session and workspace rules for future terminal tool commands
The allowed commands or command line entries in the Allow dropdown now have options a corresponding action to allow them for the current session or for the workspace.

Terminal tool preventing adding to shell history
Setting: chat.tools.terminal.preventShellHistory
When shell integration is enabled and working, commands that are run by the terminal tool are no longer included in shell history for bash, zsh, pwsh and fish. The method this uses differs for each shell, for bash for example HISTCONTROL=ignorespace is set and a space is added to the start of the command being run.
If you prefer to keep terminal tool commands in the shell history, configure this with the chat.tools.terminal.preventShellHistory setting.

Accessibility
Streaming chat responses in Accessible View
The Accessible View now dynamically streams chat responses as they are generated. Previously, you needed to close and reopen the Accessible View to see updated content. Now, you can stay in the Accessible View and monitor output as it comes in, making it much easier to follow along with AI responses in real-time.

MCP server output excluded from Accessible View
To reduce noise, MCP (Model Context Protocol) server output is now excluded from the Accessible View by default. The standard chat output remains fully accessible, as it's presented in a text area that works well with screen readers.

Language ID variable in window title
A new ${activeEditorLanguageId} variable is now available for the window.title setting. This variable displays the language identifier of the currently active editor, which is useful for accessibility tools like Talon that need to determine the current programming language to enable appropriate voice commands.

Editor Experience
Import profile by drag and drop
You can now import a settings profile by dragging and dropping a .code-profile file into VS Code. This makes it easier to share profiles with teammates or quickly set up a new environment.
When you drop the file, the Profiles editor opens and lets you preview and import the profile. This provides a similar experience to dragging and dropping a .code-workspace file to open a workspace.

Copy breadcrumbs path
Setting: breadcrumbs.symbolPathSeparator
You can now copy the breadcrumbs path to the clipboard by using the Copy Breadcrumbs Path command. This is useful when you need to share the exact location of a symbol with your team or for documentation purposes.
The breadcrumbs.symbolPathSeparator setting enables you to customize the separator character used to join breadcrumb segments.

Go to Symbol in Workspace supports special characters in query
The Go to Symbol in Workspace (Ctrl+T) feature no longer incorrectly filters out all results when the search query contains a # character.
This fix enables language extensions like rust-analyzer to use # as a modifier in symbol searches. For example, in rust-analyzer, appending # to a query like main# searches for functions in current workspace only.

Code Editing
New snippet tranformations
There are two new snippet transformations available: snakecase and kebabcase. This is how you can use them:
For snake_case transformation:
${TM_FILENAME/(.*)/${1:/snakecase}/}
This transforms the filename to snake-case format. For example, from MyFileName.txt it makes my_file_name.txt. The kebab-case transformation would be my-file-name.txt.

Source Control
Git blame information settings
Settings: git.blame.ignoreWhitespace, git.blame.editorDecoration.disableHover
The new git.blame.ignoreWhitespace setting enables you to configure Git blame to ignore whitespace changes when determining which commit last modified a line. This is particularly useful when working with code that has been reformatted, as it helps you identify the commit that made the actual functional change rather than just whitespace adjustments.
Additionally, the git.blame.editorDecoration.disableHover setting lets you disable the hover tooltip that appears when you hover over a Git blame editor decoration. This can be useful if you prefer a cleaner editing experience and only want to see the inline blame annotations without the additional hover information.

Authoring commit messages using the editor
Some time ago we added the capability to use the full editor to author a commit message but the actions to commit or cancel were difficult to discover in the editor title toolbar. We improved the editor overlay control in the lower right-hand corner of the editor and moved these actions there to make them easier to use.

Worktrees in the Source Control Repositories view (Experimental)
Settings: scm.repositories.explorer, scm.repositories.selectionMode
This milestone, we have added a Worktrees node to the Source Control Repositories view. Under this node, you can see the list of the repository worktrees with an inline action to open the worktree in a new window. The context menu also contains an action to open the worktree in the current window, as well as an action to delete the worktree.
You can enable the experimental repository explorer by setting the scm.repositories.selectionMode and scm.repositories.explorer settings. Give it a try and let us know what other repository artifacts you would like to see in the Repositories explorer.
Learn more about using source control in VS Code.

Terminal
Terminal IntelliSense default UX rework
During the past two releases, we rolled out terminal IntelliSense to all VS Code Stable users. While much of the feedback was positive, there was a segment of users (mostly terminal power users) that did not like the feature breaking their muscle memory. After a lot of discussion, we decided to switch some defaults, improve discoverability and allow easier inline configuration of the feature.
The feature itself is still enabled by default, but instead of showing the control automatically when typing (quick suggestions and suggest on trigger characters), it now needs to be explicitly triggered via Ctrl+Space.
We also improved the "status bar" on the bottom. Previously, it showed insert on the left and Learn more/Configure on the right with their associated keybindings. We got feedback that it's not clear that these can be interacted with, so we now show icons on the right and no longer show the keybindings. The left action now allows rotating through the options for "selection mode", which determines how Tab and Enter react when it's brought up. There's a new eye icon on the right, which enables quick suggestions and suggest on trigger characters again.
Finally, to still make this powerful feature relatively discoverable without being overbearing, a hint shows when opening a terminal that explains how to show suggestions. The lifecycle of the hint is simplified and it's as easy as clicking "don't show" to get rid of it permanently, just like the similar feature in the editor.
Beyond this UX rework, these improvements were also done to terminal IntelliSense:
• We now show files with the executable bit on macOS/Linux
• Improved completions for npm and git
• Several fixes to the feature

Performance and stability improvements
The terminal saw several important performance and stability improvements this release:
• node-pty#831: On macOS and Linux, pasting more than 50 characters at once or having Copilot run a large command is no longer throttled and should apply essentially instantly, scaling similarly to other terminals with KBs/MBs of data. This also fixed a crash that could happen on macOS when doing the same thing.
• vscode#285031, vscode#285032, xterm.js#5548: Fixed several layout thrashing issues that could cause the editor to get laggy.
• vscode#239541: Fixed a crash that could occur when fonts such as CommitMono were configured in the terminal.

More comprehensive custom glyphs
The terminal's GPU accelerated renderer (on by default) has supported custom glyphs for some time for box drawing, block element, and a subset of powerline symbols. This means that you can see these characters without needing to configure a font and they also scale with line height, letter spacing, and should align with each other perfectly.
In this release, we expanded the number of characters supported to almost 800 by including the majority of custom glyphs supported by any other terminal. This includes ranges that are generally useful in a terminal, specifically these ranges:
• Box Drawing (U+2500 - U+257F)
• Block Elements (U+2580 - U+259F)
• Braille Patterns (U+2800 - U+28FF)
• Powerline Symbols (U+E0A0 - U+E0D4, Private Use Area)
• Progress Indicators (U+EE00 - U+EE0B, Private Use Area)
• Git Branch Symbols (U+F5D0 - U+F60D, Private Use Area)
• Symbols for Legacy Computing (U+1FB00 - U+1FBFF)
Here's a visual of the complete set of glyphs:

Improved rendering of curly underlines
VS Code has been able to parse and display colored and styled underlines for some time now, but the curly underline's rendering always left something to be desired. The curly underlines should now look very close to how they look in the editor.
You can try this out for yourself by running this command in bash:
echo -e '\x1b[4:3mCurly\x1b[0m \x1b[4:3m\x1b[58;5;1mRed\x1b[0m'

Dimensions visual overlay on resize
Inspired by a feature in ghostty, we added a brief overlay that shows the current terminal dimensions (columns x rows) when you resize the terminal. This is useful if you want to resize your terminal to a specific size for testing or other purposes.

New VT features
The terminal now supports the follow VT features/sequences:
• Synchronized output: can be used by applications to pause rendering and batch updates in the terminal, which is particularly useful to prevent tearing when rewriting the buffer.
◦ DECRQM (CSI ? 2026 $ p)
◦ BSU (CSI ? 2026 h)
◦ ESU (CSI ? 2026 l)
• XTVERSION (CSI > 0 q): allows applications to query details about the terminal, the response VS Code will give currently is the "xterm.js" and its version

Debug
Organize Breakpoints by File
Breakpoints can now be shown as a tree, group by their file, using the setting debug.breakpointsView.presentation.

Testing
Navigate to uncovered regions
We've added navigation buttons to the test coverage toolbar that allow you to easily jump between regions of uncovered code.
You can toggle the test coverage toolbar using the Test: Show Coverage Toolbar command.

Contributions to extensions
GitHub Pull Requests
There has been more progress on the GitHub Pull Requests extension, which enables you to work on, create, and manage pull requests and issues. New features include:
• Change a pull request's base branch from the pull request description webview.
• Convert open pull requests to draft from the pull request description webview.
• Generate a pull request description for an existing PR, not just new ones.
Review the changelog for the 0.126.0 release of the extension to learn about everything in the release.

Extension Authoring
New Quick Pick properties for prompts and resource URIs
The Quick Pick API includes two new properties for creating interactive selection interfaces.
Use the prompt property on QuickPick to display persistent instructional text beneath the input box. The text remains visible while users type, which helps provide guidance or context.
Use the resourceUri property on QuickPickItem to automatically derive item properties from a resource URI. When provided, VS Code derives:
• The label from the file name (when set to an empty string)
• The description from the file path (when set to undefined or an empty string)
• The icon from the current file icon theme (when iconPath is set to ThemeIcon.File or ThemeIcon.Folder)
This is useful when building file or folder selection interfaces.

Engineering
Housekeeping
As part of our annual December housekeeping, we spent a majority of time cleaning up GitHub issues and pull requests across all our maintained repositories. This year, we managed to reduce our open issues by 5,951 and triaged another 1,203 issues.
By using improved triage tooling and deduplication processes, we were able to close a significant number of stale and resolved issues. This has left us with a more manageble project, enabling us to move forward and develop the features that have the most impact for our users. In our core VS Code repository alone, we closed 2,872 issues and triaged another 1,697!
In June of 2025, we also announced that Copilot had become Open Source! This meant that all related issues would also be filed in the microsoft/vscode repo, and that we had a backlog of issues remaining in microsoft/vscode-copilot-release to take care of. This month, we triaged every issue in the repository and closed 1,659 issues, leaving only 175 open to be migrated.
Below is a graph that shows how our core vscode repository has grown over the years, and how many issues our amazing community has contributed over time. We appreciate everyone who has contributed issues to our repositories over the years and continued to engage with us. Your feedback is what has made VS Code the product that it is today! 🚀

Authoring extensions in TypeScript (Experimental)
It is now possible to author VS Code extensions directly in TypeScript without requiring a build step. This works... but there is still a bit of adventure involved! Many aspects are still untested, such as how to write and run tests, how to publish extensions, and other workflow considerations.
Learn more about this experimental approach in this GitHub comment.

Notable fixes
• vscode#283356 - Fixed regression causing jumping around while scrolling past some chat output

Thank you
Contributions to vscode:
• @abhijit-chikane (Abhijit Chikane): fix: hover focus border cutting at the corners PR #259548
• @alievilshat (Ilshat Aliyev): Fixed wrong negation in the _shouldRenderHint logic. PR #242479
• @Andarist (Mateusz Burzyński): Simplify TestInstantiationService#stub overloads PR #282223
• @anki-code (Andy Kipp): Added Xonsh shell type PR #284044
• @aryla (Arttu Ylä-Outinen): Fix sticky scroll hover listeners piling up PR #260020
• @AviVahl (Avi Vahl): fix: ensure fallback to default system monospace font PR #282747
• @BartolHrg: fix copy with multiple cursors and empty selections PR #256083
• @Beace (Beace): fix: fix terminal webgl context memory leak PR #279579
• @bibaswan-bhawal (Bibaswan Bhawal): fix(extensions): allow extensionButton.prominentBackground to take effect PR #276788
• @chaitanyamedidar (Chaitanya Medidar): Fix Swipe to navigate setting missing description #281997 PR #282220
• @CyMad7001 (Cyril Madigan): #196344 - Fix installer hang issue PR #228233
• @daiyam (Baptiste Augrain): fix: correctly pass extension's id when version is also provided PR #279630
• @eidriahn (Adrian Luca): fix: fixes icons not showing when hovering quick pick checkboxes PR #285250
• @erezak (Erez Korn): Chat: hide Apply in Editor from Command Palette PR #283486
• @flying-sheep (Philipp A.): fix: set LANGUAGE for Git PR #285410
• @gjsjohnmurray (John Murray): Standardize the breadcrumb toggle option label (fix #257550) PR #284486
• @hickford (M Hickford): Reverse lines: apply to whole document when selection is single line PR #257031
• @irengrig (Irina Chernushina): Fix memory leak with installing cursor change position listener PR #267799
• @isksss (isksss): Update: Fixed so that MARK can be used in vue files etc. PR #283583
• @izolotarev (Igor): Fix color detection in hsl saturation PR #266720
• @jakebailey (Jake Bailey): Replace old-style TS modules with namespaces PR #282862
• @jcpetruzza (Daniel Gorin): debug: Fix UI freezing on "continue" with high number of threads PR #283635
• @JeffreyCA: Update Fig spec for Azure Developer CLI (azd) PR #281127
• @joeriddles (Joe Riddle): Add snakecase to snippets syntax PR #237110
• @josephxiao8 (Joseph Xiao): Expected Final Selection After Running Delete Duplicate Lines PR #234799
• @junhaoliao (Junhao Liao): Suppress unhandled errors in WordHighlighter's runDelayer triggers. PR #285887
• @kheif (Mehmet Ege Aydın): workbench: add commands to move editor to start and end PR #284999
• @kortin99 (Kortin Zhou): feat(snippets): add support for kebab-case in snippets tmLanguage syntax PR #222319
• @maynkxx (mayank choudhary): docs: update Twitter branding to X in README PR #280235
• @milanchahar (MILAN CHAHAR): Fix terminal icon picker placement PR #281275
• @mizdra (mizdra): Fix tests that failed in environments where XDG_DATA_HOME is set PR #285402
• @MohamedEmirHajji (Mohamed Emir HAJJI):
◦ Add more git log options to completions PR #282311
◦ Markdown preview: filter hidden elements from scroll sync (fix #281247) PR #282506
• @murataslan1 (Murat Aslan):
◦ fix: avoid jumpy scrolling when navigating next/prev problem PR #285634
◦ Fix: Replace terminal tabbed view lifecycle hack with Event.once PR #285657
◦ Fix: Replace terminal view lifecycle hack with Event.once PR #285661
• @NriotHrreion (Norcleeh): fix: Latest input is not stored to the history when sending message to a new chat PR #282633
• @odinGitGmail (odinsam): fix(debug): support C# stack trace format in debug console links PR #281536
• @przpl: fix(runSubagent): collect computed attachments PR #283750
• @rducom (Raphael DUCOM): Fix ReDoS in PowerShell prompt detection PR #279853
• @RedCMD (RedCMD):
◦ Add TS/JS Template surrounding brackets PR #255972
◦ Fix php indenting #248229 PR #258016
◦ Fix FormatOnSave when modificationsIfAvailable PR #283726
◦ Support # pragma folding markers in C PR #284927
• @remcohaszing (Remco Haszing): Fix editor edge clicking PR #262964
• @Riya-chandra (RIYA_CHANDRA): Show command descriptions as tooltips in Command Palette PR #284609
• @SalerSimo (Simone Salerno):
◦ Exclude terminal editors from recently closed editors history PR #282009
◦ Refactor virtual model creation logic in MoveLinesCommand PR #284785
• @SimonSiefke (Simon Siefke):
◦ fix: memory leak in terminal editor PR #279088
◦ fix: memory leak in terminal process PR #279167
◦ fix: memory leak in terminal process PR #279172
◦ fix: memory leak in accessibility signal PR #279242
◦ fix: memory leak in local process extension host PR #279351
◦ fix: memory leak in extension icon widget PR #280566
◦ fix: memory leak in markdown hover PR #280745
◦ fix: memory leak in debug session PR #281767
◦ fix: memory leak in status bar PR #282246
◦ fix: memory leak in ipc PR #282253
◦ fix: memory leak in chat list renderer PR #282560
◦ fix: memory leak in notebook code scrolling PR #283452
◦ fix: memory leak in terminal find widget PR #283466
◦ fix: memory leak in mainThreadLanguages PR #283498
◦ fix: memory leak in chat widget PR #284288
◦ fix: memory leak in terminal chat widget PR #284325
◦ fix: memory leak call stack widget PR #286246
• @sudip-kumar-prasad (Sudip Kumar Prasad): Fix: use codicon id for Command Prompt default profile icon PR #280967
• @tamuratak (Takashi Tamura):
◦ fix: ensure finishedEditing is called in ChatWidget PR #281763
◦ include uppercase -I in sed in-place option detection PR #284645
◦ Fix context handling in ChatWidget while re-editing PR #285099
• @ThanhNguyxn (Thanh Nguyen): fix: Panel doesn't close when maximized and center-aligned (fixes #281772) PR #281773
• @tharani-2006: Terminal: show dimensions overlay while resizing PR #284244
• @tt0mmy (Tommy): Fix duplicate description in terminal suggestion config PR #279730
• @yavanosta (Dmitry Guketlev):
◦ Fix backward selection when EditContext is off PR #273150
◦ InlineEditsView: remove redeclaration of textModel PR #281501
◦ SingleUpdatedNextEdit: Correctly apply insertion changes PR #281519

Contributions to vscode-copilot-chat:
• @AbdelrahmanAbouelenin (ababouelenin): Update system prompt for VSCModelB. PR #2727
• @bharatvansh (Ayush Singh): fix(byok): improve Gemini provider error handling and add tests PR #2686

Contributions to vscode-js-profile-visualizer:
• @xiaoxiangmoe (ZHAO Jin-Xiang): chore: remove useless package-lock.json files PR #216

Issue tracking
Contributions to our issue tracking:
• @gjsjohnmurray (John Murray)
• @RedCMD (RedCMD)
• @tamuratak (Takashi Tamura)
• @IllusionMH (Andrii Dieiev)
• @albertosantini (Alberto Santini)

We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what's new.
If you'd like to read release notes for previous VS Code versions, go to Updates on code.visualstudio.com.

Original source Report a problem

Update 1.107.1: The update improves the agent sessions experience, adds an agent workflow tutorial, and addresses these issues. The key highlights include:
• Agent sessions view defaults to side-by-side and remembers your toggle state.
• Agent sessions that require your input are now clearly marked.
• Support for copying workspace changes when creating a background session.
• Chat prompt is not cleared when creating a new session.
• Tool calls in cloud sessions are now collapsed by default.

Downloads: Windows: x64 Arm64 | Mac: Universal Intel silicon | Linux: deb rpm tarball Arm snap

VS Code 1.107 introduces multi-agent orchestration - use GitHub Copilot and custom agents together to accelerate and parallelize development.
• Agent HQ gives you one place to manage all your agents, letting Copilot and custom agents collaborate across tasks.
• Background agents run in isolated workspaces to not interfere with your active work, and enabling multiple background tasks at once.
• Delegate work across local, background, or cloud agents to keep your workflow moving without interruptions.

Watch our VS Code 1.107 release highlights video to hear about these features from our engineers!
Happy Coding!

Read these release notes online at Updates on code.visualstudio.com.

Insiders: Download the nightly Insiders build to try the latest updates as soon as they're available.

Agents
• Manage your agents from chat (Show more).
• Share agents across your organization (Show more).
• Keep agents active while chat is closed (Show more).
• Move agent sessions from local to cloud (Show more).
• Run agents in dedicated Git worktrees (Show more).
• Attach context to background agents (Show more).
• Customize background agents (Show more).
• Reuse custom agents across environments (Show more).
• Run custom subagents (Show more).
• Reuse Claude skills (Show more).

Integrating agent sessions and chat
Setting: chat.viewSessions.enabled
Update 1.107.1: This update significantly improves the side-by-side sessions experience. Hiding the sessions with the toggle now remembers your choice, allowing you to resize the Chat view at will. Get started with the agent workflow tutorial.

Agents are key to autonomously performing coding tasks on your behalf. The chat interface is the main way to interact with agents, regardless of where they are running: locally in VS Code, in the background using a CLI, in the cloud, or from 3rd party extensions. Learn more about using agents in VS Code in our documentation.

This iteration, we integrated the agent sessions into the Chat view to give you a unified experience when working with agents. At a glance, you can see the session's status, progress, and file change statistics. You can archive or unarchive sessions to keep the sessions list manageable.

If you are working in a workspace, the session list only shows sessions related to the current workspace. If you are in an empty window, all sessions across workspaces are shown.

When you select a session from the list, it opens the session in the Chat view in the Side Bar, allowing you to see the full conversation history. If you prefer, you can also open a session as an editor tab or in a new window. Right-click a session to see the context menu with these options.

You can disable the sessions list in the Chat view by configuring chat.viewSessions.enabled.

As a consequence of this change, we're disabling the standalone Agent Sessions view by default. If you prefer to keep using the standalone view, you can re-enable it via chat.agentSessionsViewLocation. In a future release, we plan to remove the standalone view entirely.

Compact view
When the Chat view is narrow, the list of sessions is shown inside the Chat view when you start a new chat session. By default, the list shows the three most recent sessions that are not archived.

Select Show All Sessions to view the full list of sessions with options to search and filter.

You can use the action to toggle the agent sessions sidebar for a wider experience of all sessions.

Side-by-side view
Once the Chat view is wide enough (for example, when you maximize it), the list of agent sessions is automatically shown side-by-side with the Chat view. This view lets you quickly navigate between sessions without losing context. You can also manually toggle this side-by-side view using the corresponding control.

To limit the sessions list, you can filter sessions by provider or state. VS Code persists this filter.

Orientation setting
Setting: chat.viewSessions.orientation
By default, the sessions list appears side-by-side with the Chat view when it's wide enough or if you manually toggle the sessions list. You can change this behavior with the chat.viewSessions.orientation setting.
• auto (default): show the sessions side-by-side if the width allows it, otherwise show them above empty chats
• stacked: always show the sessions above empty chats
• sideBySide: show the session list side-by-side if the width allows it, otherwise hide the sessions list

Local agent sessions remain active when closed
Previously, when you closed a local chat session, a running agent request was cancelled. This limited the usefulness of local agents for long-running tasks or for running multiple tasks simultaneously.

Now, the local agent continues running in the background, even when not open in a chat editor or the Chat view. You are able to see the status of the running agent in the sessions list and can switch back to the session at any time to see the detailed progress.

Learn more about using local agent in chat.

Continue tasks in background or cloud agents
Local agents are great for interactive sessions inside VS Code where you can go back and forth with the agent. This can be useful for brainstorming, performing exploratory tasks, or to work out an implementation plan. Once you have a clear plan, you can then hand the task off to a background or cloud agent to execute it autonomously.

This iteration, we have improved the experience to continue a local chat with a background or cloud agent. Across the UI, you can now continue a task seamlessly using the new Continue in option.

When you continue a local chat to background or cloud agent, the current chat context is passed along and the original session is archived after handoff.
• Chat view: (Screenshot showing the 'Continue in' button in the Chat view.)
• Plan agent: (Screenshot showing the 'Start implementation' button when using the Plan agent.)
• Untitled prompt file: (Screenshot showing the 'Continue in' button in an untitled prompt file.)

Isolate background agents with Git worktrees
Background agents (previously called CLI agents) are designed to run autonomously in the background, allowing you to offload tasks while you focus on other work. Running multiple background agents simultaneously can lead to conflicts if they modify the same files in your workspace.

This iteration, we enhanced the isolation of background agents by introducing support for Git worktrees. When you create a new background agent, you can choose to either run it on the current workspace or to run it in a dedicated Git worktree.

When you run a background agent in a worktree, the agent automatically creates a new Git worktree for the session, isolating its changes in a separate folder. This lets you run multiple background agents simultaneously without conflicts.

You can easily review and merge the changes made by the background agent in the worktree back into your main workspace when the agent completes its task. We've also added a new action to directly apply the changes from a worktree directly into your workspace.

Learn more about using background agents in VS Code.

Adding context to background agents
Background agents now support multiple context attachment types. You can attach selections, problems, symbols, search results, git commits, and more to any prompt. This makes it possible to build richer, more precise prompts, unlocking more complex and flexible workflows. For example, attach a reported problem and ask the agent to fix it without manually specifying file paths and line numbers.

Share custom agents across your GitHub organization (Experimental)
Setting: github.copilot.chat.customAgents.showOrganizationAndEnterpriseAgents
Previously, you could only define custom agents at a workspace or user level. If you wanted to share custom agents across your organization, you had to manually distribute the agent files to each user.

In this release, you can now define custom agents at the organization level for your GitHub account. This experimental feature enables you to use organization-specific agents alongside your personal agents in chat.

To enable this feature, set github.copilot.chat.customAgents.showOrganizationAndEnterpriseAgents to true. Once enabled, custom agents created by your organization appear in the Agents dropdown in VS Code.

To learn more about creating custom agents for your organization, see Create custom agents in the GitHub documentation.

Use custom agents with background agents (Experimental)
Setting: github.copilot.chat.cli.customAgents.enabled
You can now bring your own custom agents into Background Agents. Once enabled, custom agents defined in your .github/agents folder will appear in your agent list, allowing you to leverage agents tailored to your workflows and requirements.

This experimental functionality can be enabled with the github.copilot.chat.cli.customAgents.enabled setting.

Learn more about defining custom agents in our documentation.

Agent tooling reorganization
We've reorganized the agent tooling structure to enable better compatibility with GitHub custom agents. This lets you more easily reuse custom agents across VS Code and GitHub environments without requiring separate configurations.

As part of this change, we've renamed certain existing tool references and the toolsets they belong to. Existing tool references in your agent files will continue to work, but you'll see a Code Action for renaming them to the latest recommended format. This ensures that your agent configurations follow the current best practices and maintain compatibility across platforms.

Run agents as subagents (Experimental)
Setting: chat.customAgentInSubagent.enabled
When an agent needs to solve a complex issue, it can delegate tasks to subagents. Subagents work independently from the main chat session and have their own context window. This helps the main conversation to stay focused on the high-level objective and helps to manage context window limitations.

With this release, you can customize subagents via custom agents. Custom agents let you define specialized personas for the AI, tailoring their behavior to specific tasks or domains. For example, a code reviewer agent focuses on reviewing code rather than make code changes.

To use custom agents as subagents, follow these steps:
• Enable chat.customAgentInSubagent.enabled
• Create a custom agent with the Chat: New Custom Agent command, if you don't have one yet.
• In chat, ask the model "what subagents can you use?" to see the list of available subagents. Your custom agent should appear in the list.
• Enter a prompt that meets the requirements for your custom agent. The language model uses the custom agent description and arguments to determine if it should be used for your request.

To prevent a custom agent from being used as a subagent, set the metadata property infer to false in the *.agent.md file.

Learn more about using subagents in chat.

Reuse your Claude skills (Experimental)
Setting: chat.useClaudeSkills
Skills were introduced by Claude Code and are capabilities that an agent can load on-demand. Each skill comes with a short description that advertizes the skill. If useful, the agent can decide to read the full skill instructions. Skill instructions can come with supporting files like scripts and templates. Once loaded, skills instructions and supporting files are part of the context of the main conversation.

VS Code can now reuse your existing skills. Enable the chat.useClaudeSkills setting to allow agents to discover and use your skills.

VS Code supports personal skills found at ~/.claude/skills/skill-name/SKILL.md and project skills found in workspace folders at ${workspaceFolder}.claude/skills/skill-name/SKILL.md.

Check that the SKILL.md file has a description attribute in the header that advertizes the skill. Note that the allowed-tools attribute is not supported in VS Code.

In agent mode, make sure you have the read-file tool enabled and ask "What skills do you have" to find out if skills are found. Next, make a request that can be answered with a skill. If the agent doesn't use the skill, improve the skill description or nudge the model to use skills.

Chat
• Inline chat is optimized for code edits (Show more).
• Manage your chat models (Show more).
• Review external web content (Show more).
• Fetch dynamic web content (Show more).
• Search ignored files (Show more).
• Access terminal output in chat (Show more).
• Automatically approve terminal commands for your session (Show more).
• More keyboard shortcuts are available (Show more).
• Use Entra ID for Azure-hosted models (Show more).
• Configure extended thinking budget for Anthropic models (Show more).
• Use chat more efficiently (Show more).
• View diffs for edits to sensitive files (Show more).
• Hide chat tool calls for reasoning models (Show more).

Inline chat UX
Setting: inlineChat.enableV2
We continue to improve the inline chat experience to align it with the other chat experiences in VS Code and to optimize it for quick, single-file code changes.

Previously, you could also use inline chat for general questions and discussions. Now, inline chat is optimized for code changes within the current file. For tasks that inline chat cannot handle, you are automatically upgraded to the Chat view where your prompt is being replayed, using the same model and the same context.

The inlineChat.enableV2 setting (preview) now only controls how the extension handles your prompt. This is still under development but can be tried with confidence.

Language Models editor
Chat in VS Code supports multiple language models, either provided by GitHub Copilot, third-party extensions, or via bring your own key (BYOK) providers. Managing all these models can be challenging, especially when you have access to many models across different providers. Learn more about using language models in VS Code.

The Language Models editor provides a centralized place to view and manage all available language models for chat in VS Code. You can open it from the model picker in chat or via the Command Palette with Chat: Manage Language Models.

The editor lists all models available to you, showing key information such as the model capabilities, context size, billing details, and visibility status. By default, models are grouped by provider, but you can also group them by visibility.

Hover over model names or context sizes to see detailed information including model ID, version, status, and token breakdown.

You can search and filter models using:
• Text search with highlighting
• Provider filter: @provider:"OpenAI"
• Capability filters: @capability:tools, @capability:vision, @capability:agent
• Visibility filter: @visible:true/false

Manage model visibility
As more models are available to you, the model picker can become overwhelming and difficult to navigate. In the Language Models editor, you can toggle the visibility of each model to control which models appear in the model picker. Hover over a model and select the eye icon to toggle its visibility.

Add models from installed providers
From the Language Models editor, you can add more models with Add Models.... This shows a dropdown list of all installed model providers. Select a provider to configure it and add its models to chat in VS Code.

This makes it easy to activate additional model providers you've installed without needing to navigate away from the Language Models editor. Access provider management by selecting the gear icon on provider rows.

URL and domain auto approval
This iteration, we enhanced the security and user experience of auto-approving URLs for the fetch tool. When the model decides to fetch content from a URL that you did not explicitly ask for, you'll see the new two-step approval experience:
• Approve the initial request to fetch the URL
This step ensures that you trust the domain being contacted and can prevent sensitive data to be sent to untrusted sites.
You have options for one-time approval or automatically approving future requests to the specific URL or domain.
The pre-approval respects the "Trusted Domains" feature. If a domain is listed there, you are automatically approved to make requests to that domain and are deferred to the response reviewing step.
• Approve to use the fetched content in chat and follow-up tool calls
This step ensures that you review the fetched content before it is added to the chat or passed to other tools, preventing potential prompt injection attacks.
For example, you might approve a request to fetch content from a well-known site, like GitHub.com. But because the content, such as issue description or comments, is user-generated, it could contain harmful content that might manipulate the model's behavior.

Learn more about URL and domain approval in VS Code chat.

More robust fetch tool
The #fetch agent tool now handles dynamic web content more effectively. It can retrieve dynamic content, in addition to static HTML. Websites that rely on JavaScript to load their content, such as Single-Page Applications (SPAs), modern documentation sites, or issue tracking systems like Jira, no longer return incomplete or empty results.

The fetch tool waits for JavaScript to execute and content to load before retrieving the page, ensuring that dynamically-rendered content is captured. This improvement makes the tool significantly more useful in real-life scenarios.

When you use #fetch followed by a URL, the model accesses the actual content you'd see in the browser, not just the initial HTML skeleton. This means more accurate and complete information when asking questions about web pages or requesting the model to analyze online content.

Text Search tool can search ignored files
The #textSearch tool now supports searching in ignored files/folders specified by files.exclude or search.exclude settings or .gitignore files, such as the node_modules folder. It also returns hints to the agent about the ignored files/folders when there are no results, allowing agents to turn around and enable searching in those ignored files/folders.

Rich terminal output in chat
Using Toggle Output on a Run in Terminal response now renders output in a full, read-only xterm.js terminal inside chat. A nice benefit of this approach is that VS Code preserves captured output even after the backing terminal has exited, so you can reopen previous runs at any time and see the terminal output as it was when the command ran.

The chat terminal now adopts the integrated terminal's color theme for improved ANSI color contrast. Screen reader users can open the accessible view Alt+F2 when the output has focus, enabling easy review and navigation.

Learn more about using terminal commands in chat.

Command status details in chat terminals
Chat terminal messages now display command start time, duration, and exit code on hover of the command decoration.

Allow all terminal commands in this session
To optimize your chat experience, while maintaining security and control, the terminal tool has a new auto approve option to allow all future commands for the session. When you start a new session, terminal commands will follow the existing approval configuration.

Keyboard shortcuts for chat terminal actions
You can now focus the most recent chat terminal Ctrl+Shift+Alt+T or toggle its expansion state Ctrl+Shift+Alt+O via dedicated keyboard shortcuts.

Keyboard shortcuts for custom agents
Each custom agent now has a separate action in the command list for them and you can bind keyboard shortcuts to them individually. For example, if you define a "Code Reviewer" custom agent, there will be a Chat: Open Chat (Code Reviewer Agent) command in the Command Palette to bind a keyboard shortcut to.

Azure model provider: Entra ID as the default authentication
Setting: github.copilot.chat.azureAuthType
By default, the Azure model provider now uses Entra ID authentication when connecting to Bring-Your-Own-Key (BYOK) models, providing improved security and a more streamlined sign-in experience.

If you prefer to authenticate using an API key, set github.copilot.chat.azureAuthType to apiKey instead of entraId (default).

Anthropic models: Extended thinking support
Setting: github.copilot.chat.anthropic.thinking.budgetTokens
Anthropic models now support extended thinking, which is enabled by default for all Anthropic extended thinking models. Extended thinking gives Claude enhanced reasoning capabilities for complex tasks by allowing it to spend additional tokens on its step-by-step thought process before generating a response, leading to more thoughtful and accurate outputs.

The default thinking budget is set to 4,000 tokens. You can customize this budget by modifying the github.copilot.chat.anthropic.thinking.budgetTokens setting to adjust how many tokens the model can use for extended thinking. To turn off extended thinking entirely, set the budget to 0.

Note: Interleaved thinking, which enables Claude to reason between tool calls, is only available when using Anthropic models via Bring-Your-Own-Key (BYOK). It uses the same thinking budget setting configured above.

Chat view appearance improvements
We've made several improvements to the Chat view's appearance to enhance readability and usability:
• Chat title:
When you open a chat, a new title control appears to the top showing you the title of the chat as well as giving you a quick way to get back to an empty chat. Configure this behavior via the chat.viewTitle.enabled setting.
• Welcome banner:
If you prefer a more minimal experience when opening a new chat, the new setting chat.viewWelcome.enabled lets you hide the icon and welcome text.
• Restore previous chat session:
When you open chat after restarting or opening a different workspace, the previous session is now restored by default. You can change this behavior via the chat.viewRestorePreviousSession setting and choose to always start with an empty chat.

Diffs for edits to sensitive files
When chat attempts to edit sensitive files, such as the settings.json or package.json, you get a notification and are asked to approve the changes before they are applied. You can configure which files are considered sensitive via the chat.tools.edits.autoApprove setting.

Previously, you would see the raw edit that the model proposed, which could be difficult to understand. Now, we show you a diff of the proposed changes, making it easier to review and approve the edits.

Collapsible reasoning and tools output (Experimental)
Setting: chat.agent.thinkingStyle, chat.agent.thinking.collapsedTools
With language model reasoning and agent tools output, a chat conversation can quickly become long and difficult to follow. Last iteration, we already worked on improving how we display thinking tokens in chat with the chat.agent.thinkingStyle setting.

This iteration, we're further optimizing the chat experience by introducing collapsible chat sections for non-reasoning chat output, such as tool calls. By default, successive tool calls are now collapsed to reduce visual noise.

Collapsible items (most tools and reasoning text) will be summarized and an AI-generated title will be given to each collapsible section.

MCP
• We added support for the latest MCP specification (Show more).
• Use the GitHub remote MCP server without extra setup (Show more).

Support for the latest MCP specification
VS Code supports the latest revision of the MCP specification, 2025-11-25. This includes, among other things:
• URL mode elicitation
• Tasks for long-running, resilient tool calls and client work.
• Enhancements to enum choices in elicitation

These improvements come in addition to the 2025-11-25 draft features VS Code already supported, such as WWW-Authenticate scope consent, the Client ID Metadata Document authentication flow, and icons for tools, resources, and servers. You can view the changelog for the 2025-11-25 draft on the MCP website.

Learn more about using MCP servers in VS Code.

GitHub MCP Server provided by GitHub Copilot Chat (Preview)
Setting: github.copilot.chat.githubMcpServer.enabled
The GitHub remote MCP Server is now provided as a built-in MCP server in the GitHub Copilot Chat extension, providing seamless integration with GitHub repositories and services. This integration offers several benefits:
• Alignment with other Copilot agent harnesses like Copilot CLI and Copilot Cloud Agent that already use the GitHub MCP Server
• Reuse of existing GitHub authentication state, eliminating additional authentication prompts
• Transparent support for different GitHub MCP endpoints including GHE.com

To enable the GitHub MCP Server, set github.copilot.chat.githubMcpServer.enabled setting to true. Once enabled, the server automatically appears in the tool picker when using agents. This enables you to ask questions about GitHub issues, pull requests, and other repository information without additional configuration and setup.

The GitHub MCP Server supports customization through several settings:
• github.copilot.chat.githubMcpServer.toolsets: Configure which tools are available. By default, the default toolset is used, but you can extend it by adding workflows or other toolsets as documented in the GitHub MCP Server documentation. Note: Adding certain toolsets may require additional permissions and re-authentication is not yet supported. Please see this GitHub issue to track progress.
• github.copilot.chat.githubMcpServer.readonly: Force the server to return only read-only tools, preventing any write operations.
• github.copilot.chat.githubMcpServer.lockdown: Additional security control for tool behavior.

Note: This feature is currently in Preview and requires explicit opt-in through the setting mentioned above. We are planning to enable it by default in a future release in a way that makes it available when wanted, but not intrusive when not needed.

Accessibility
Keyboard approval for chat confirmations
When an agent prompts for confirmation, you can now approve via keyboard using Ctrl+Enter.

Editor Experience
• More easily identify open projects (Show more).
• Swipe to navigate on macOS (Show more).
• Choose when to view hover popups (Show more).

More support to indicate opened windows in pickers
We added an indicator to the Open Recent picker for when a workspace is already open in a VS Code window.

The currently active window is indicated slightly differently from other opened windows to make that distinction clearer. Entries that are not opened in any window have no icon.

The indicator of which window is active has also been applied to the window picker.

macOS: Mouse swipe to navigate
Setting: workbench.editor.swipeToNavigate
On macOS you can now navigate between editors using 3-finger swipe gesture with the trackpad. Swiping left or right navigates across recently used editors in any editor group. Enable this with the workbench.editor.swipeToNavigate setting.

Note: We currently only support 3-finger swipe gesture. Make sure that your trackpad settings for swiping are configured like the following to make this work:
• Swipe between pages: Scroll left or right with three fingers.
• Swipe between full-screen apps: Swipe left or right with four fingers.

On demand editor hover popups
Setting: editor.hover.enabled
You can now disable automatic hover popups in the editor, while retaining the ability to trigger hover information on-demand using a keyboard modifier. The editor.hover.enabled setting now supports three values: on, off, and onKeyboardModifier.

When set to onKeyboardModifier, hover information only appears when you hold the opposite modifier key from your editor.multiCursorModifier setting while hovering over code. This reduces visual distractions during text selection while preserving quick access to contextual information when needed.

For example, if your editor.multiCursorModifier is set to ctrlCmd, hover appears when you hold Alt while hovering. If set to alt, hover appears when you hold Ctrl (or Cmd on macOS).

Code Editing
• TypeScript offers rename suggestions (Show more).
• Use a new model for next edit suggestions (Show more).
• Preview next edit suggestions outside your viewport (Show more).

Rename suggestions for TypeScript
Rename suggestions predict when a symbol rename should happen instead of a regular text suggestion. When predicted, an additional indicator is shown together with the normal textual edit. You can then apply the symbol rename by using Shift+Tab.

In the following video, property a is renamed to width. The rename suggestion then suggests to rename b to height, as well as renaming the two parameters a and b accordingly. Next rename suggestion works best when it predicts related renames to other symbols.

Note: this feature is currently rolled out to our user base using an experiment and is only available for TypeScript for now. Support for other programming languages is planned.

New model for next edit suggestions
We have released a new model for next edit suggestions that is smarter and more in-tune with your latest edits. It delivers significantly better acceptance and dismissal performance. Learn more about the model and its development in our GitHub blog post.

Preview next edit suggestions outside the viewport
When you receive a next edit suggestion that is outside the current viewport, it can be difficult to know what the suggestion is without scrolling away from your current position. We improved this experience by rendering a preview of the next edit suggestion where your cursor is currently located. This helps reduce the impact on your flow when reviewing suggestions.

Note: Our current language model focuses on next edit suggestions close to the cursor, so you might not often see suggestions outside the viewport. However, we are actively working on models which can give you suggestions much further away!

Learn more about inline suggestions in VS Code.

Source Control
Stashes in the Source Control Repositories view (Experimental)
Settings: scm.repositories.explorer, scm.repositories.selectionMode
This milestone, we continued to expand the list of repository artifacts shown in the Source Control Repositories view by adding a Stashes node. Under this node, you can see the complete list of stashes, view, apply, and pop each stash. The context menu also contains an action to drop each stash.

You can enable the experimental repository explorer by setting the scm.repositories.selectionMode and scm.repositories.explorer settings. Please give it a try and let us know what other repository artifacts you would like to see in the repositories explorer.

Learn more about using source control in VS Code.

Debugging
Attach variables to chat
You can now attach variables, scopes, and expressions to your chat context in VS Code. You can do this by right clicking on data in the Variables and Watch views, or by using the Add Context button in chat.

Terminal
Terminal suggest rolled out to stable
Terminal Suggest is now enabled for stable users, offering inline completions and contextual hints while you type shell commands. Suggestions now group related argument values together, so option flags and their parameters stay organized in the list.

Authentication
Cross-platform native broker support for Microsoft Authentication
Setting: microsoft-authentication.implementation
This milestone, we adopted the latest MSAL libraries, enabling you to sign in through a native experience on:
• Intel Macs
• Linux x64 (just certain distros that are Debian-based)

This is in addition to the existing support for:
• Windows x64
• macOS M-series (ARM)

macOS and Linux support requires your machine to be Intune enrolled and be opted in to using the native broker.

This enables nice single sign-on flows and is the recommended way of acquiring a Microsoft authentication session. The MSAL team will enable this up for the remaining platforms (Windows ARM, Linux ARM and additional distros) over time, so stay tuned!

NOTE: If you have trouble authenticating via the broker, you can change the microsoft-authentication.implementation to msal-no-broker, which will use your browser to authenticate instead.

classic Microsoft authentication no longer available
As mentioned last month, we have removed the classic option for microsoft-authentication.implementation due to low usage and it not being recommended by the Entra ID team.

Reminder: The microsoft-authentication.implementation setting has been around to let users opt-out of native brokered authentication for Microsoft accounts if they experienced issues. The values for this setting are:
• msal - Use MSAL with brokered authentication when available (default)
• msal-no-broker - Use MSAL without brokered authentication

Languages
TypeScript 7.0 preview
We continued to work with the TypeScript team to improve VS Code's support for the upcoming TypeScript 7 release. TypeScript 7 is a complete rewrite in native code and offers dramatically better performance.

The TypeScript 7 preview has almost complete type checking support, and the TypeScript team has been busy adding editor features too. Recent highlights include auto import completions, rename support, and references code lenses.

You can try out TypeScript 7.0 today by installing the TypeScript (Native Preview) extension. Then run the TypeScript (Native Preview): Enable (Experimental) command in a JavaScript or TypeScript file to switch all IntelliSense to use the native preview. Checkout the most recent TypeScript 7 blog post for a full update on TypeScript 7 and the general direction of the TypeScript project.

We plan to continue working closely with the TypeScript team to improve TypeScript 7's VS Code support. Once TypeScript 7 is ready, our longer term plan is to switch to it as the default experience powering VS Code's JavaScript and TypeScript IntelliSense. If you need to use an older TS version or need editor features like TypeScript service plugins that can't be easily ported to TypeScript 7, we're planning to continue supporting existing TypeScript versions for the foreseeable future alongside TypeScript 7.0+.

Remote Development
The Remote Development extensions, allow you to use a Dev Container, remote machine via SSH or Remote Tunnels, or the Windows Subsystem for Linux (WSL) as a full-featured development environment.

Highlights include:
• SSH reconnection grace time control

You can learn more about these features in the Remote Development release notes.

Enterprise
Learn more about the enterprise capabilities of VS Code in our documentation.

Control auto approval for agent tools
Setting: chat.tools.eligibleForAutoApproval
Specific agent tools can be risky to use without explicit user approval, especially those that can perform destructive actions, access sensitive data, or run arbitrary code in the background (for example, runTask).

You can now define which tools are eligible for auto-approval with the new chat.tools.eligibleForAutoApproval setting. When a tool is denied from auto-approval, users won't have the option to always approve this tool in chat and must explicitly approve each use.

Organizations can enforce this behavior via an enterprise policy across their users to enhance security when using agents.

Disable the use of agents by policy
When an enterprise policy disables the use of agents in chat, the Agents picker now better communicates why they're not available.

Support GitHub Enterprise policies in Codespaces
You can specify policies for your enterprise or organization in GitHub that are applied in VS Code. For example, you can configure the MCP registry URL to be used by developers in your organization.

In this release, we added support for these policies when using VS Code with GitHub Codespaces. When a developer opens a Codespace, the same policies are applied automatically, as they already are when using VS Code locally.

Contributions to extensions
GitHub Pull Requests
There has been more progress on the GitHub Pull Requests extension, which enables you to work on, create, and manage pull requests and issues. New features include:
• Pull request and issue implicit context when a pull request or issue webview is active.
• Pull requests and issues can be added explicitly as context to chat sessions through "Add Context".
• Copilot pull requests can be marked ready for review, approved, and auto-merge set with a single button.

Review the changelog for the 0.124.0 release of the extension to learn about everything in the release.

Proposed APIs
Contributed Chat Context
We have a new API proposal to let extensions contribute context providers for chat. This enables extensions to provide rich context from their own domain to be used in chat sessions. For example, the GitHub Pull Request extension provides the following context:
• Workspace context, with information about the current repository, branch, and pull request.
• Implicit pull request and issue context when a pull request or issue webview is active.
• Explicit pull request and issue context when the user adds them via "Add Context".

The API is still in the early stages, so expect changes to come. We'd love to get feedback on what parts of the proposal will solve extension authors' needs. You can find the proposal here: vscode.proposed.chatContextProvider.d.ts.

Engineering
Builds rollout
We've started progressively rolling out Insiders build releases over a 4-hour time window. This means that, as an Insiders user, you might receive the update notification a bit later than usual. If you're in a hurry, you can always run Check for Updates to force the update to be applied immediately.

We'll roll out the November 2025 (1.107) release to Stable users over a 24-hour time window. Just like Insiders, you can always run Check for Updates to force the update to be applied immediately.

Improved website search functionality
We've improved our website with fast, client-side search that allows you to easily and quickly navigate across our documentation.

We've open-sourced the library behind this functionality: you can download docfind and use it for your projects today! We'll follow up with a blog post on the innovations behind this tech.

Updated build scripts run directly as TypeScript
This iteration, we cleaned up our build scripts to make them easier to work with and maintain. These build scripts were a mix of compiled TypeScript, TypeScript files run using ts-node, and JavaScript. Many of these scripts were not type checked and were using commonjs (require) instead of modern modules with import and export. Even worse, many of the TypeScript build scripts required checking in the compiled JS output to our source control. What a mess!

Thankfully Node 22.18+ now allows running scripts directly as TypeScript. This lets us incrementally convert our build scripts to modern TypeScript. We used the follow tsconfig options to make sure our new TypeScript code could be run directly by Node:
{
"compilerOptions": {
"target": "esnext",
"module": "nodenext",
"noEmit": true, // Don't generate .js files
"erasableSyntaxOnly": true, // Only allow TypeScript syntax that node can strip out. Enums and namespaces for example are not allowed
"allowImportingTsExtensions": true, // Allow importing of .ts files
"verbatimModuleSyntax": true // Make sure imports will be valid when the script is run by node directly
}
}

GitHub Copilot helped automate many of the required changes, such as converting old commonjs files to modules and adding type annotations.

One thing to keep in mind is that while Node can run TypeScript code, it doesn't actually type check it. You still need to use tsc for that. For vscode, we're actually using ts-go, which can fully type check all of our build scripts in well under a second.

It's pretty amazing to be able to run node build/hygiene.ts directly. Switching fully to TypeScript also lets us modernize and bring type safety to our build scripts, which will make it much easier to understand and make changes to them. Plus it enabled us to delete around 15,000 lines of compiled JS code that we previously had to keep checked in!

Copilot extensions unification
Setting: chat.extensionUnification.enabled
We have fully rolled out inline suggestions to be served from the GitHub Copilot Chat extension. As part of this change, the GitHub Copilot extension will be disabled by default for all users.

If you run into any issues with inline suggestions, please report them. You can temporarily revert to the previous behavior by setting chat.extensionUnification.enabled to false, which reenables the GitHub Copilot extension.

Note that we are planning to fully deprecate the GitHub Copilot extension in January 2026, at which point the chat.extensionUnification.enabled setting will also be removed.

Notable fixes
• vscode#233635 - Add an action to close other windows
• vscode#262817 - Running "Move Editor into Previous Group" from the left-most group should create a new group to the left
• vscode#264569 - Setting and removing window.activeBorder color does not reset the window border color
• vscode#140186 - Cannot open local terminal when remote container is opened as a workspace
• vscode#228359 - Relaunching the terminal will often just close the terminal
• vscode#232420 - Terminal Cursor is at the wrong place with Python3.13
• vscode#247568 - Terminal Ctrl+Click on a file with colon in filename does not open the file, preceding zeroes are deleted
• vscode#275011 - Getting strange terminal message when opening VS Code in WSL on a trusted workspace
• vscode#275417 - Tasks with reveal:never, close:true no longer work on WSL
• vscode#277311 - Add "X" button to remove command from "recently used" list in Command Palette
• vscode#282222 - SCM - improve git blame/timeline/graph hover rendering. Thanks to Stanislav Fort (Aisle Research)
• vscode-python-environments#1000 - Environment activation is not working reliably with "Command Prompt"
• vscode-copilot-chat: multiple PRs fixing various issues
• vscode-js-debug: Dereferences of undefined at various places
• vscode-pull-request-github: multiple PRs adding features and fixes
• vscode-python: Fix Python REPL cursor drifting
• vscode-python-debugger: Update to latest debugpy
• vscode-python-environments: Support UvWorkspace envs too
• language-server-protocol: add slang-server
• node-native-keymap: Fix casing of msctf.h header
• node-pty: Add OpenBSD includes for termios and util
• python-environment-tools: Run commands without creating a console window on Windows

Thank you to all contributors listed in the release notes.

Original source Report a problem

Welcome to the October 2025 release of Visual Studio Code.

This release brings significant updates across three key areas:

• Agent HQ is your single view to kick off, monitor, and review agent sessions, whether they're local or remote, from Copilot or OpenAI Codex
• Security and trust help you stay in control and confidently delegate more tasks to AI
• A great editor experience to make your day-to-day coding smoother and more enjoyable

Watch our VS Code 1.106 release highlights video to hear about these features from our engineers!

Happy Coding!

If you'd like to read these release notes online, go to Updates on code.visualstudio.com.

Insiders: Want to try new features as soon as possible?
You can download the nightly Insiders build and try the latest updates as soon as they are available.

Agents

Agent Sessions view

Setting: chat.agentSessionsViewLocation

As you hand off tasks to various coding agents, it's important to have a clear overview of all your active sessions. The Agent Sessions view provides a centralized location for managing your active chat sessions. This includes both local sessions in VS Code and sessions created by background agents in other environments, such as Copilot coding agent, GitHub Copilot CLI, or OpenAI's Codex. The Agent Sessions view is now enabled by default, and can be managed via the chat.agentSessionsViewLocation setting.

By default, the Agent Sessions view lists all your active chat sessions organized by their source. The view is divided into sections for local chat sessions in VS Code and for background agent sessions.

If you prefer to have one consolidated view of your sessions across all providers, you can enable the single-view option for the chat.agentSessionsViewLocation setting. This option also moves the Agent Sessions view next to the Chat view in the Secondary Side Bar, making it easier to switch between chat and managing your sessions.

Note that not all functionality is available in the consolidated view yet. We are actively working on making this view the default in the near future.

The Agent Sessions view now also supports search (Ctrl+Alt+F) to help you easily find your sessions in the list.

Plan agent

A new plan agent helps developers break down complex tasks step-by-step before any code is written. Select Plan from the agents dropdown in the Chat view to get started. When tackling a multi-step implementation, VS Code prompts you with clarifying questions and generates a detailed implementation plan that you approve first, ensuring all requirements and context are captured upfront.

We recommend spending time iterating on the plan before implementation. You can refine requirements, adjust scope, and address open questions multiple times to build a solid foundation. Once you approve the plan, Copilot implements it either locally in VS Code or via cloud agents, giving you greater control and visibility into the development process. This helps you catch gaps or missing decisions early, reducing rework and improving code quality.

You can also create your own custom plan agent tailored to your team's specific workflow and tools. Use the Configure Custom Agent menu to copy the built-in plan agent as a starting point, then customize the planning style, tools, and prompts to match your development process. Learn more about planning in VS Code chat and creating custom agents.

Cloud agents

In this release, we have made quite a few updates to cloud agent sessions in the editor.

We migrated the Copilot coding agent integration from the GitHub Pull Request extension into the Copilot Chat extension to provide a more native cloud agent experience in VS Code. This integration paves the way for smoother transitions and interactions between VS Code and GitHub Mission Control, such as opening a cloud agent session directly from the Agent Sessions view in the browser and vice versa.

CLI agents

In this release, we have also shipped an initial integration with the Copilot CLI. You can create new and resume existing CLI agent sessions in a chat editor or an integrated terminal.

In a CLI agent editor, you can send messages to the Copilot CLI just as you would in a terminal, switch models, and attach context.

Agent delegation

We continue to improve the experience for delegating to cloud agents.

When you use the cloud button to delegate to an agent from the chat panel, you'll be provided a set of available agents to which you can delegate. You can also delegate to the Copilot coding agent from the CLI, via the /delegate command in a CLI editor or terminal instance.

CLI agent edit tracking

Chat edit sessions now track edits made by background agents, such as the Copilot CLI. When you create sessions from the Agent Sessions view, you can see edits tracked through both inline edit pills and the working set view, making it easier to understand what changes agents are making to your workspace.

Chat modes renamed to custom agents

Chat modes have been renamed to custom agents throughout VS Code to better align with terminology used in other environments.

When you create custom agents, the definition files are now located in .github/agents in your workspace. These files can use the .agents.md suffix and can also be used as GitHub Copilot Cloud Agents and CLI Agents.

Use Chat: New Custom Agent... to create a new agent and Chat: Configure Custom Agents... to manage them.

If you have existing custom chat modes (.chatmode.md files in .github/chatmodes), they continue to work and are automatically treated as custom agents. When you open a chat agent file in the editor, an info marker appears on the first line with a quick fix to migrate it to a custom agent file.

Custom agent metadata

Custom agent .agent.md files now accept an additional target frontmatter property to describe how an agent should run across environments:

• target: vscode: optimizes the agent for local chat and unlocks name, description, argument-hint, model, tools, and handoffs properties. Any tool installed in VS Code can be used.
• target: github-copilot: prepares the agent for Copilot cloud agents or the GitHub CLI with support for name, description, tools, mcp-servers, and target. Tools can be edit, search, shell, custom-agent, and tools from MCP servers.

All agents can be run in all environments. Each environment ignores unknown attributes and tools.

Additional properties:

• name: lets you override the agent label without renaming the file.
• argument-hint: surfaces guidance in the chat input so teammates know how to prompt the agent.
• handoffs: wires guided transitions to other agents, letting you chain multi-step workflows.

The agent file editor provides validation, code completions, hovers and code actions.

Learn more about custom agents and agent handoffs in our documentation.

Code Editing

Deleted code in diff editor is now selectable

Previously, when you deleted code and viewed the changes in the diff editor, you couldn't copy those deleted lines. In this release, you can now select and copy text from deleted lines in the diff editor when using the inline diff view.

Inline suggestions are open source

This release continues our journey to make VS Code an open source AI editor. Following our first milestone of open sourcing GitHub Copilot Chat, we've now open sourced inline suggestions by merging them into the vscode-copilot-chat repository.

As part of this milestone, we're consolidating the GitHub Copilot extension and GitHub Copilot Chat extension into a single extension experience. The Chat extension now serves all inline suggestions, providing the same intelligent code suggestions you're used to while maintaining all chat and agent functionality. The change should be transparent, you'll continue getting the same code suggestions as you type. If you encounter any issues, you can temporarily revert using the chat.extensionUnification.enabled setting.

The GitHub Copilot extension will be deprecated by early 2026. Learn more about this milestone and explore the open source code in our blog post.

Snooze inline suggestions from gutter

You can now snooze inline suggestions directly from the gutter icon. When you hover over the gutter icon, a control appears with a Snooze option. Select it and choose a duration to pause suggestions.

Go to line improvements

This iteration, we've made several enhancements to the Go to Line command (Ctrl+G), improving navigation within files.

The Go to Line command now supports navigating to a specific character position in a file by using the :: syntax. This is useful when tools report errors at specific character offsets, such as "error at position 599".

To navigate to a character offset, type :: followed by the character number in the Go to Line input box. For example:

• ::599 - Navigate to character 599 in the file
• ::-100 - Navigate 100 characters from the end of the file

Use the toggle in the input box to switch between 1-based (default) and 0-based offset calculations.

In addition, the Go to Line command also handles out-of-range values more gracefully and makes it easier to navigate to the start or end of files and lines:

• Line numbers: Typing a line number larger than the file's line count navigates to the last line.
• Column numbers: Using negative column numbers navigates from the end of a line. For example, :12:-1 takes you to the last character on line 12. Typing a column number larger than the length of the line takes you to the end of the line.

Editor Experience

Refreshed iconography

In this release, the codicon icon set has had a facelift. The new icons have been refined with curves, new modifier designs, and more accurate metaphors to make them feel modern, friendly and more legible.

Linux policy support

We've introduced support for managing VS Code policies on Linux systems using JSON files. This allows administrators to enforce specific settings and configurations across all users on a Linux machine.

For more details, see JSON Policies on Linux.

Navigate changes in multi file diff editor

Just like you can navigate to next or previous changes in a diff editor for a single file, you can now do so across files in the multi-file diff editor. Use keybindings or the navigation up and down arrow keys to review your changes across files.

Copy diagnostic hover text

A copy button now appears in diagnostic hovers (errors, warnings, info, and hints) to make copying error messages easier. When you hover over a diagnostic marker, move your mouse over the hover message to reveal a copy button in the top-right corner.

Accent-insensitive command filtering

The Command Palette now ignores character accents when searching for commands, making it easier to find what you need regardless of your keyboard layout or language preferences. For example, when searching for a command containing the word Générer (French for Generate), type generer without accents and matching commands appear in the results.

This is helpful when using different keyboard layouts or when mistyping while looking for a command. The filtering is based on Unicode Normalization Form D and supports all Unicode languages.

Advanced VS Code settings

VS Code now supports the concept of advanced settings. These settings are meant for configuring specialized scenarios and are intended for advanced users who need fine-grained control over their environment. By default, advanced settings are hidden in the Settings editor, keeping the interface streamlined while making these powerful options available when needed.

To view and configure advanced settings, select Advanced from the filter dropdown menu in the Settings editor, or type @tag:advanced in the search box.

When you search for a specific setting by its exact name or use the @id: filter, advanced settings appear in the results without having to apply the Advanced filter. This ensures you can always find the settings you're looking for.

Advanced settings can be combined with other filters such as @modified or @feature: to help you find exactly what you need. For example, @tag:advanced @feature:terminal shows only advanced settings related to the terminal.

Note: Extension authors can mark their settings as advanced by adding the advanced tag to the setting configuration.

Chat

Embeddings-based tool selection

In this release we've significantly improved how we filter and group tools for users that have many (over 100) tools enabled in chat. You should see the "Optimizing tool selection..." loading state less often and for a shorter period of time. We also improved tool selection with a lower probability of agent confusion to make sure the right tools are chosen.

Tool approvals and trust

Post-approval for external data

Agent tools that pull in external data now support post-approval. This helps protect against potential prompt injection attacks by letting you review the data before it's used in your chat session.

Post-approval is enabled for the #fetch tool and for Model Context Protocol (MCP) tools that declare openWorldHint.

Trust all tools for a server or extension

You can now trust MCP servers and extension tools at the source level through the Allow button dropdown. This means that you can approve all tools from a specific MCP server or extension at once, rather than having to approve each tool individually.

We have also updated the Chat: Manage Tool Approval command experience to let you manage both pre- and post-approval of tools.

Tool auto approval status moved

Auto approval status has moved from being inline inside the chat view to the tool call status/tick icon.

Terminal tool

Auto approve parser improvements

Previously, subcommand detection in the terminal tool used the naive approach of just splitting on certain strings such as | or &&. This failed in several ways but the bigger ones were when pipe was used inside strings like echo "a|b|c", which would detect the subcommands echo, b, and c". Another important one is that since we couldn't reliably pull subcommands, we outright banned parenthesis pairs, curly brace pairs, and backticks to be more on the safe side and prevent accidental execution.

This release, we integrated a parser into the feature and use a PowerShell grammar or a bash grammar for everything else*. So, even really complex cases should be correctly extracted.

• Note that this means it can fail to catch subcommands when the shell syntax differs from bash, such as ; in zsh.

File write/redirection detection (Experimental)

Thanks to the new parser, we're able to fairly reliably extract files being written to via redirection. There's the new experimental setting chat.tools.terminal.blockDetectedFileWrites that will prevent auto approval conditionally.

Disable default auto approve rules (Experimental)

The new experimental setting chat.tools.terminal.ignoreDefaultAutoApproveRules allows disabling the default rules (both allow and deny rules). This is useful if you want more control without needing to look up the defaults.

Shell specific prompts and command rewriting

The terminal tool now has shell-specific descriptions for PowerShell, bash, zsh and fish. This should make commands suggested by the agent more reliable and less likely to fail, especially for PowerShell.

In addition to this, for PowerShell we also re-write && to ; since the && chain operator is not supported in Windows PowerShell (v5). Note that this is temporarily also happening for PowerShell 7 until vscode#274548 is actioned.

Attach terminal commands to chat

You can now attach a terminal command to chat as context from the command decoration's context menu. The attachment shares the command line, captured output, and exit code so the agent understands precisely what happened. This applies to any command tracked by shell integration, making it easy to escalate troubleshooting without copying and pasting text.

View terminal output inside chat (Experimental)

The new chat.tools.terminal.outputLocation setting controls where the output is displayed. The default none value prevents the terminals from cluttering the panel.

Every chat terminal invocation now surfaces two actions on the progress element:

• Show Terminal reveals and focuses hidden sessions, and with rich shell integration, scrolls directly to the relevant command. With basic or no shell integration, the action still focuses the correct terminal tab.
• Show Output opens the terminal's final output inline within the chat view. The output view expands automatically when a command exits with a non-zero code.

When npm i fails, the output is automatically expanded. The terminal is revealed with the Show Terminal inline action.

Discover hidden chat terminals (Experimental)

When setting(chat.tools.terminal.outputLocation):none, a new X hidden terminal(s) button appears in the terminal tabs view when there is at least one hidden chat terminal. It opens a quick pick that lists each chat terminal alongside its chat session so you can immediately focus the right process. The same picker is available from the terminal overflow menu under View Hidden Chat Terminals, and it disappears once all chat terminals are visible again.

The agent runs ls -la, which succeeds, so the output is collapsed. The hidden terminal action is taken from the tabs view and the terminal is selected, revealed, and scrolled to highlight the command.

Save conversation as prompt

You can now save your chat conversations as reusable prompts with the /savePrompt command. When you invoke /savePrompt in an active chat session, VS Code generates a prompt file containing a generalized prompt based on your conversation. The editor displays a blue button that lets you save this prompt to a valid location, either at the user or workspace level.

This feature replaces the previous /save command and provides a more streamlined workflow for capturing and sharing useful conversation patterns. The generated prompts can be easily reused in future chat sessions or shared with your team. Learn more about custom prompt files.

Edit welcome prompts

You can now right-click on suggested prompts in the Chat welcome view to access additional actions. When you right-click a prompt (or press Shift+F10), a context menu appears with an Edit Prompt File option to open the corresponding prompt file directly in the editor.

Editing a prompt file works for prompts that have an associated file, including user-defined prompts and project-specific prompts configured through the chat.promptFilesRecommendations setting.

Learn more about custom prompt files.

Automatically open edited files

Setting: chat.openEditedFilesAutomatically

We changed the default behavior of the agent to no longer automatically open edited files in an editor. If you prefer the previous behavior, you can enable the setting accessibility.openChatEditedFiles.

Reasoning (Experimental)

Setting: chat.agent.thinkingStyle, chat.agent.thinking.collapsedTools

Last iteration, we added the chat.agent.thinkingStyle setting which enabled displaying thinking tokens in chat. This is now available in more models! As of this release, GPT-5-Codex, GPT-5, GPT-5 mini, and Gemini 2.5 Pro support this.

The chat.agent.thinkingStyle was adjusted to three more common styles, with fixedScrolling as the default to show the most recent chain of thoughts.

An additional setting, chat.agent.thinking.collapsedTools, adds tool calls into the collapsible thinking UI.

Inline chat v2 (Preview)

Setting: inlineChat.enableV2

We have ramped up our efforts to modernize inline chat. It's built to be

• single prompt,
• single file,
• and for code changes only

This makes the overall experience much lighter and allows for a simplified UI. For tasks it cannot handle, you'll be automatically upgraded to the Chat view.

Chat view UX improvements

We tweaked some parts of the Chat view to make it feel more pleasant to use:

• The action to create a new Chat is now a dropdown with options to create a chat session in the editor or in a new window
• The tools and MCP server actions moved right next to the model picker
• The configuration dropdown is cleaned up

It is now also possible to copy math source by right-clicking math expressions in the chat view.

MCP

MCP server access for your organization

Settings: chat.mcp.gallery.serviceUrl, chat.mcp.access

VS Code now supports MCP registry configured through GitHub organization policies. This enables organizations to set up a custom MCP registry and control which MCP servers can be installed and started.

When an MCP registry endpoint is configured in your organization's policies, VS Code will:

• Provide browsing and installing of MCP servers from the configured registry
• Restrict starting MCP servers to only those available in the registry when access restriction is enabled

When your organization has configured these policies, the chat.mcp.gallery.serviceUrl setting specifies the MCP registry endpoint URL, and the chat.mcp.access setting controls whether access is restricted to only the servers in that registry. These settings will be marked as "(Managed by organization)" in the Settings editor.

To learn more about configuring MCP server access for your organization or enterprise, see Configure MCP server access.

Install MCP servers to workspace configuration

When installing an MCP server, you can now choose whether to install it globally or to the workspace configuration. Right-click on an MCP server in the extensions view and select Install (Workspace) from the context menu, or use the Install (Workspace) action directly in the MCP server editor. This adds the MCP server to the .vscode/mcp.json file in your current workspace, making it easier to share MCP servers with your team.

Authentication: Client ID Metadata Document authentication flow

Authentication support for remote MCPs now supports the Client ID Metadata Document (CIMD) authentication flow, which is the future standard for OAuth in MCP. This flow enables a more secure and scalable solution to authentication over Dynamic Client Registration (DCR) because now authorization servers do not have to worry about issuing client IDs per-client.

When connecting to an MCP server that uses an authorization server that supports CIMD, VS Code will automatically use that flow over DCR.

For more information about CIMD, take a look at the resources on oauth.net.

Authentication: WWW-Authenticate scope step up

Authentication support for remote MCPs now supports dynamic scope escalation through the WWW-Authenticate header for remote MCP servers. This is called out in the OAuth 2.0 specification. This allows MCP servers to request additional permissions when needed, rather than requiring all scopes upfront. For example, connecting to a server might require a minimal set of scopes, but specific tool calls can request broader permissions only when necessary. This provides better security by following the principle of least privilege.

This is currently called out in the latest draft of the MCP specification which is expected to be finalized soon.

Accessibility

Speech timeout is disabled by default

The configuration accessibility.voice.speechTimeout has changed to be 0 by default. This means, a voice session no longer ends automatically after a certain delay (e.g. a Chat request would not be triggered automatically if you pause). We feel this is a better default experience, but you can always change back to the previous default (2500).

Chat input improvements

The chat input now announces the active agent and model in a clearer order so screen reader users hear the most relevant context first. The chat accessibility help also calls out that you can press Delete to remove attached context items, making attachment management fully keyboard-accessible.

Notebooks

Notebook search

Notebooks now support searching across cells. Use key bindings (F3 and Shift+F3) to navigate to the next and previous match, just like you would in the editor.

Source Control

Folding support in git commit messages

Settings: git.verboseCommit, git.useEditorAsCommitInput

When writing git commit messages in the editor, you can now fold sections of the commit message to keep things organized. To use this feature, enable the git.verboseCommit and git.useEditorAsCommitInput settings.

Graph incoming/outgoing changes

Settings: scm.graph.showIncomingChanges, scm.graph.showOutgoingChanges

This milestone, we are adding the capability to easily view incoming and outgoing changes in the Source Control Graph view. For active branches that have incoming or outgoing changes, the graph displays an "Incoming Changes" and "Outgoing Changes" node. Selecting each node displays the list of incoming or outgoing files.

You can hide this information from the Graph view by using the scm.graph.showIncomingChanges and scm.graph.showOutgoingChanges settings.

Graph compare references

We have added a new command to the Source Control Graph context menu, Compare with..., that enables you to compare a history item in the graph with an arbitrary branch or tag. This feature lets you view changes that are in the history item but not in the branch or tag.

In the context menu, there are shortcuts commands, Compare with Remote and Compare with Merge Base for comparing a history item with the remote branch and merge base respectively.

Repositories selection mode

Setting: scm.repositories.selectionMode

The Source Control Repositories view shows the list of opened repositories in the workspace and is used to control the repositories shown in the Source Control Changes view.

We are looking to expand the functionality of the Repositories view and in preparation for that, we are introducing a setting, scm.repositories.selectionMode, to control the selection mode in the Repositories view to either a single repository or multiple repositories.

Apart from the new functionality in the Repositories view, this also allows us to remove the repository picker in the Graph view's title and have a global repository picker across all source control views. You can toggle the selection mode using the setting, or from the "..." menu of the Repositories view.

New Repository menu

Users can use the scm/repository menu id to contribute commands to the inline source control provider rows in the new Source Control Repositories view. Commands contributed to the "inline" group will appear inline, while all other commands will appear in the ... menu.

Repositories explorer (experimental)

Settings: scm.repositories.explorer, scm.repositories.selectionMode

We are looking at enhancing the Repositories view and showing additional information for each repository. To try out this experimental feature, set scm.repositories.selectionMode and scm.repositories.explorer.

In this first iteration, we have focused on branches and tags. You can create new branches, tags, view the list of branches and tags, and take various actions of each branch/tag (ex: checkout, etc.). In the upcoming milestone, we will add more information (ex: stashes, remotes, etc). Give this experimental feature a try and let us know what you think.

Testing

Navigate uncovered lines in test coverage

When reviewing test coverage, you can now easily navigate between uncovered lines using new navigation commands. Two commands are available in the editor toolbar when viewing coverage information:

• Go to Next Uncovered Line - Jumps to the next line that is not covered by tests
• Go to Previous Uncovered Line - Jumps to the previous line that is not covered by tests

These commands help you quickly identify coverage gaps and focus on areas that need additional test coverage, making it easier to improve the overall test quality of your codebase.

Terminal

Terminal IntelliSense

Terminal IntelliSense has been in the product as an experimental/preview feature for around 1.5 years! This release we're removing the preview tag and will be doing a staged roll out as the default to all users on stable.

When enabled, typing in the terminal will bring up IntelliSense similar to the editor for PowerShell, bash, zsh and fish.

Some commands feature advanced specifications, like git which has the ability to pull in branch names.

If we learned anything when building this feature it's that no one size fits all, so there are many options to tweak the behavior to get what you're after:

• terminal.integrated.suggest.quickSuggestions - Show automatically depending on the content of the command line, as opposed to manually via Ctrl+Space.
• terminal.integrated.suggest.suggestOnTriggerCharacters - Show automatically after a "trigger character" such as - or /.
• terminal.integrated.suggest.runOnEnter - Optionally run the command when Enter is used (not Tab).
• terminal.integrated.suggest.windowsExecutableExtensions - The list of extensions that are treated as executables on Windows.
• terminal.integrated.suggest.providers - Provides the ability to disable specific providers, for example extensions may contribute completions you don't want.
• terminal.integrated.suggest.showStatusBar - Whether to show the status bar at the bottom of the IntelliSense popup.
• terminal.integrated.suggest.cdPath - Whether to enable $CDPATH integration.
• terminal.integrated.suggest.inlineSuggestion - Whether to integrate with shell "ghost text" and how to present it.
• terminal.integrated.suggest.upArrowNavigatesHistory - Whether up arrow is sent to the shell instead of browsing completions, this is particularly useful on zsh where you can filter and then press up to do a history search with that prefix.
• terminal.integrated.suggest.selectionMode - How the Intellisense popup is focused which determines what Enter and Tab do.
• (New!) terminal.integrated.suggest.insertTrailingSpace - Insert a trailing space and re-trigger completions after accepting.

If you don't see the feature yet, make sure you have shell integration enabled and enable IntelliSense explicitly in settings via terminal.integrated.suggest.enabled.

Apart from overall polish, this is what is coming to the feature this release:

• copilot and azd CLIs now have completions
• The extension API is close to finalization
• Git commit completions show the commit message

Consolidated shell integration timeout setting

We now have one unified configurable setting, terminal.integrated.shellIntegration.timeout, that controls how long VS Code waits for shell integration to become ready before executing commands in the terminal, including those triggered through the executeCommand API and by Copilot terminal tool.

chat.tools.terminal.shellIntegrationTimeout has been deprecated in favor of this consolidation.

Authentication

Manage extension account preferences discoverability

The Manage Extension Account Preferences command is now more discoverable. In addition to being available in the Command Palette and extension context menus, it now appears in the Account Menu alongside Manage Language Model Access. This makes it easier to find and configure which accounts extensions can access.

Last version of classic Microsoft authentication - use msal-no-broker if you experience issues

We will be removing the classic option for microsoft-authentication.implementation. This means that VS Code release 1.106 is the final version that has the classic option.

The microsoft-authentication.implementation setting has been around to let users opt-out of native brokered authentication for Microsoft accounts if they experienced issues. The values for this setting are:

• msal - Use MSAL with brokered authentication when available (default)
• msal-no-broker - Use MSAL without brokered authentication (introduced recently)
• classic - Use the classic Microsoft authentication flow without MSAL

We will remove the classic option since its usage is very low and most issues with the msal option are due to the brokering, which is remedied with msal-no-broker.

Device code flow for Microsoft authentication

Microsoft authentication now supports the device code flow in non-brokered scenarios, particularly useful for remote development environments. When other authentication methods fail, VS Code automatically falls back to device code flow, which displays a code that you can enter on another device to complete authentication.

Manage accounts command

Manage your authentication accounts directly from the Command Palette using the Accounts: Manage Accounts command. This command provides access to account management features when the Account menu is hidden or not easily accessible.

When you run the Manage Accounts command, you'll see a quick pick menu listing all your active accounts. You can select an account to view available actions, including:

• Manage Trusted Extensions - Control which extensions can access the selected account
• Manage Trusted MCP Servers - Manage MCP server access permissions for accounts that support this capability
• Sign Out - Sign out of the account

Languages

Python

Python Environments Extension: Support for python.poetryPath setting

The Python Environments Extension now respects the existing python.poetryPath user setting. This allows you to specify which Poetry executable to use. The provided path will be searched for and selected when managing Poetry environments.

Python Environments Extension: Improved venv creation: dev-requirements.txt detection

When creating a new virtual environment, the extension now detects both requirements.txt and dev-requirements.txt files and installs dependencies automatically.

Add Copilot Hover Summaries as docstring

You can now add your AI-generated documentation directly into your code as a docstring using the new Add as docstring command in Copilot Hover Summaries. When you generate a summary for a function or class, navigate to the symbol definition and hover over it to access the Add as docstring command, which inserts the summary below your cursor formatted as a proper docstring.

This streamlines the process of documenting your code, allowing you to quickly enhance readability and maintainability without retyping.

Localized Copilot Hover Summaries

GitHub Copilot Hover Summaries inside Pylance now respect your display language within VS Code. When you invoke an AI-generated summary, you'll get strings in the language you've set for your editor, making it easier to understand the generated documentation.

Convert wildcard imports Code Action

Wildcard imports (from module import *) are often discouraged in Python because they can clutter your namespace and make it unclear where names come from, reducing code clarity and maintainability. Pylance now helps you clean up modules that still rely on from module import * via a new Code Action. It replaces the wildcard with the explicit symbols, preserving aliases and keeping the import to a single statement. To try it out, you can click on the line with the wildcard import and press Ctrl+. (or Cmd+. on macOS) to select the Convert to explicit imports Code Action.

dotenv

There is built-in basic support for dotenv files (.env), which are commonly used to define environment variables for applications.

Contributions to extensions

GitHub Pull Requests

There has been more progress on the GitHub Pull Requests extension, which enables you to work on, create, and manage pull requests and issues. New features include:

• AI-generated PR descriptions (via githubPullRequests.pullRequestDescription) will respect the repository PR template if there is one.
• Drafts in the Pull Requests view now render in italics instead of having a [DRAFT] prefix.
• Pull requests can be opened from a URL, for example: vscode-insiders://github.vscode-pull-request-github/checkout-pull-request?uri=https://github.com/microsoft/vscode-css-languageservice/pull/460

Review the changelog for the 0.122.0 release of the extension to learn about everything in the release.

Preview Features

Language Models editor

A new Language Models editor provides a centralized place to view and manage all available language models for GitHub Copilot Chat. You can open it from the chat model picker or via the command Chat: Manage Language Models.

Note: This feature is only available in VS Code Insiders.

The editor displays:

• All available models organized by provider
• Model capabilities (tools, vision, agent)
• Context size and multiplier information
• Model visibility status

You can search and filter models using:

• Text search with highlighting
• Provider filter: @provider:"OpenAI"
• Capability filters: @capability:tools, @capability:vision, @capability:agent
• Visibility filter: @visible:true/false

Hover over model names or context sizes to see detailed information including model ID, version, status, and token breakdown.

Manage model visibility

Control which models appear in the chat model picker by toggling their visibility with the eye icon next to each model. When a model is visible, it appears in the model picker dropdown when you're using GitHub Copilot Chat, making it available for selection. Hidden models remain in the Language Models editor but won't appear in the model picker, helping you keep your model selection focused on the ones you use most frequently.

This is particularly useful when you have access to many models and want to streamline your workflow by showing only your preferred models in the picker.

Add models from installed providers

Use the Add Models... button to configure and add models from language model providers you've already installed. When you select this button, you'll see a dropdown list of all installed model providers, such as Copilot, Anthropic, Azure, Google, Groq, Ollama, OpenAI, and others. Select a provider from the list to configure it and start using its models in GitHub Copilot Chat.

This makes it easy to activate additional model providers you've installed without needing to navigate away from the Language Models editor. Access provider management by selecting the gear icon on provider rows.

Extension Authoring

ID token in authentication sessions

The AuthenticationSession interface now includes an optional idToken property. This allows authentication providers to return ID tokens in addition to access tokens, which is particularly useful for scenarios that require user identity information. The Microsoft authentication provider returns this field, while other providers like GitHub may not.

ID tokens contain claims about the authenticated user and are signed by the identity provider, making them useful for verifying user identity. For more information about the difference between ID tokens and access tokens, see https://oauth.net/id-tokens-vs-access-tokens/.

View containers in Secondary Side Bar

Extension authors can now register view containers in the Secondary Side Bar by using the new secondarySidebar contribution point. This lets extensions place their custom views alongside built-in views like Chat in the Secondary Side Bar and provide a better integration with VS Code's dual side bar layout.

Proposed APIs

Quick Pick and Quick Input improvements

The Quick Pick and Quick Input APIs include several new capabilities that give extension developers more flexibility in creating interactive user interfaces.

Extensions can add toggle buttons to Quick Pick and Quick Input interfaces through the toggles property on QuickInput. This enables scenarios like a password visibility toggle in the input box area, allowing users to interact with controls without leaving the quick pick interface.

Quick Pick supports a prompt property, similar to the one available in Input Box. The prompt displays persistent text beneath the input box that remains visible while users type, providing helpful guidance or instructions that doesn't disappear when the user starts entering text.

Quick Pick items can display file-type-specific icons through the resourceUri property on QuickPickItem. When you provide a resource URI, VS Code automatically derives the appropriate label, description, and icon based on the resource type, matching your current theme's file icon set. This is particularly useful when building file or folder selection interfaces, as users can quickly identify items by their familiar file type icons.

GitHub-style alerts in MarkdownStrings (#209652)

We have added support for rendering GitHub-style alert syntax in MarkdownString by setting a new property supportAlertSyntax.

This enables extensions to render alerts in various places in the UI, such as comments.

MarkdownString support in TreeItem labels (#115365)

Extension authors can now use MarkdownString in tree view item labels, enabling a subset of Markdown syntax including codicons and text formatting. This allows extensions to create more visually rich tree views.

Engineering

Exploration of automated UX PR testing

We've introduced a new automation workflow that helps reviewers understand UI changes in pull requests without manually checking out and running the code. By adding the ~copilot-video-please label to a pull request with UI changes, an automated process kicks off that:

• Builds VS Code from the PR branch
• Uses GitHub Copilot CLI to interact with the changes and record a video along the way - leveraging playwright-mcp
• Generates a Playwright trace for detailed inspection
• Posts the results as a comment on the PR

While it's still early, this workflow can reduce the manual effort required for code review, especially for small UI changes. The videos and traces help reviewers quickly verify that changes work as expected. Currently, the videos are only accessible to team members.

For more details about this automation, see https://github.com/microsoft/vscode/issues/272529.

macOS 11.0 support has ended

VS Code 1.106 is the last release that supports macOS 11.0 (macOS Big Sur). Refer to our FAQ for additional information.

Notable fixes

• Add setting for extensions request timeout used when installing extensions
• Tasks do not trigger onDidStartTerminalShellExecution
• /** is automatically closed with */ in .gitignore files
• First input gets ignored on pwsh/conpty
• Copilot 'configure instructions' quickpick doesn't show workspace-level agent instruction files (copilot-instructions.md, AGENTS.md)
• Network: Load intermediate certification authorities on Windows

Thank you

Issue tracking

Contributions to our issue tracking:

• @RedCMD (RedCMD)
• @gjsjohnmurray (John Murray)
• @IllusionMH (Andrii Dieiev)
• @albertosantini (Alberto Santini)
• @Accurio (Accurio)

Pull Requests

Contributions to vscode:

• @avarayr (avarayr): fix: Increase workbench border radius on macos tahoe
• @baptiste0928 (Baptiste Girardeau): fix: resolve renamed paths on merge editor
• @barroit (barroit): Fix tabstop calc in tokenizeLineToHTML()
• @Benimautner: Fix: don't apply inertial scrolling if input device is a mouse.
• @danielbayley (Daniel Bayley): Add TM_DIRECTORY_BASE snippets variable
• @dibarbet (David Barbet): Hookup semantic tokens range refresh notification to the viewport contribution
• @dnicolson (Dave Nicolson): Update activation event linter message
• @DrSergei (Sergei Druzhkov): Fix disassembly view
• @gjsjohnmurray (John Murray): Show the Learn How to Hide AI Features in more situations (fix #268450)
• @imbant (imbant): fix(chat): correct file icon rendering in Files & Folders picker
• @JeffreyCA: Add Fig spec for Azure Developer CLI (azd)
• @Selva-Ganesh-M (Selva Ganesh M): fix(editor)(#_261780): transform UPPER_CASE to PascalCase
• @SimonSiefke (Simon Siefke): fix: memory leak in gettingStarted, output view, notebook text model, InlayHints, chat session tracker, getTerminalActionBarArgs, sticky scroll, chat welcome
• @sinsincp: Fix AppUserModelID for code-workspace association
• @Skn0tt (Simon Knott): Testing - Uncompleted result should be marked as skipped
• @subin-chella (subin): fix the bug #209943
• @tamuratak (Takashi Tamura): chat: always apply prompt file and auto-attach instructions. Fix #271624, fix(chat): guard against undefined customModes.custom Fix #272223 and #272236
• @yavanosta (Dmitry Guketlev): Fix memory leak in InlineEditsGutterIndicator (#_273549)

Contributions to vscode-copilot-chat:

• @24anisha: Built-in toolsets for default tools
• @AbdelrahmanAbouelenin (ababouelenin): Custom vsc model prompt
• @devm33 (Devraj Mehta): Update repo URL in @vscode/chat-lib package
• @DGideas (Wanlin Wang 王万霖): Improve error handling for Copilot Chat when 404
• @IanMatthewHuff (Ian Huff): Fix issue with internal git repo telemetry collection
• @joelverhagen (Joel Verhagen): Allow latest server.json schema in assisted NuGet MCP install flow
• @phawrylak (Paweł Hawrylak): Add security-sensitive file extensions to workspace indexing exclusion list

Contributions to vscode-html-languageservice:

• @obrobrio2000 (Giovanni Magliocchetti): Add setting to disable end tag suggestions

Contributions to vscode-json-languageservice:

• @Legend-Master (Tony): Escape plain text description hover correctly

Contributions to vscode-languageserver-node:

• @dibarbet (David Barbet): Clear workspace pull state on document close to prevent stale diagnostics

Contributions to vscode-pull-request-github:

• @bendrucker (Ben Drucker): Enable all LLM tools in prompts (agent mode)
• @gerardbalaoro (Gerard Balaoro): Make branch list timeout configurable (#_2840)
• @wankun-tcj: Fix avatar display issue in Pull Request tree view

Contributions to vscode-test-cli:

• @bwateratmsft (Brandon Waterloo [MSFT]): Bump version ahead of release

Contributions to debug-adapter-protocol:

• @rsubtil (Ricardo Subtil): Add Godot to the list of DAP adapters

Contributions to language-server-protocol:

• @kristoff-it (Loris Cro): Update servers.md

Contributions to monaco-editor:

• @flofriday (Florian Freitag): Fix Kotlin number literals

Contributions to node-pty:

• @devm33 (Devraj Mehta): Load native addons directly from prebuilds directory

Contributions to python-environment-tools:

• @VictorColomb (Victor Colomb): fix(poetry): pep503 normalize package name

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

If you'd like to read release notes for previous VS Code versions, go to Updates on code.visualstudio.com.

Original source Report a problem

Version 1.107 is now available! Read about the new features and fixes from November.

Open sourcing AI in VS Code

We've open sourced the GitHub Copilot Chat extension under the MIT license and are bringing relevant components into VS Code core. Read all details in our announcement blog post and first milestone update.

Does this affect my current GitHub Copilot subscription? Is GitHub Copilot free now?

This change does not affect current GitHub Copilot subscriptions. To use GitHub Copilot, you'll continue to need both a GitHub account, and access to a GitHub Copilot subscription.

Individual developers who don't have access to Copilot through an organization or enterprise have access to the GitHub Copilot free plan (restrictions may apply). If that plan doesn't meet your needs, you can sign up for a Copilot paid plan or bring your own model keys.

Will the GitHub Copilot backend services also be open sourced?

The GitHub Copilot services are not affected and will remain closed source.

What is the timeline? When can I provide a contribution to the AI experience in VS Code?

We have completed the first step of this process by open sourcing the GitHub Copilot Chat extension. The source code is available in the microsoft/vscode-copilot-chat repository.

In the coming months, we will bring the relevant components of the Copilot Chat extension into the core VS Code repository. Check our plan item for details and updates about the timeline.

Our goal is to make the experience for contributing to our AI features as simple as contributing to any part of VS Code. As part of this, we want to make it possible to use the Copilot backend services for debugging and testing purposes when contributing. Check the CONTRIBUTING.md file for details on how to contribute.

Why integrate GitHub Copilot into the core VS Code repository?

In the time since GitHub Copilot was first released, it's become clear that AI-powered tools are core to how we write code. From usage telemetry, we can see that more users are actually using AI features in VS Code than some other features like debugging or testing.

Making AI functionality a core part of VS Code is a reaffirmation in our belief that working in the open leads to a better product for our users and fosters a diverse ecosystem of extensions.

I'm an extension author. How am I affected?

We maintain backwards compatibility for stable APIs. You should not expect any impact on your extension. We're continuously evolving and expanding the VS Code extension APIs based on feedback from extension authors. If you need additional APIs to make your extension successful, we would love to hear from you – please file an API request in the microsoft/vscode repo.

I already use other AI coding extensions in VS Code (Cline, Roo Code, ...). How does this affect me?

You can continue to use these extensions in VS Code! We love that the community is building extensions to make the developer experience in VS Code better. To improve the experience for other AI extensions, we're constantly adding APIs like the Language Model API for directly calling language models from an extension, the Tools API for interacting with language model tools and integrating with the built-in or your own agents, or the Shell Execution API for running and interacting with terminal commands (particularly useful for agentic experiences). Going forward, we are planning to add even more APIs to meet the needs of extension authors.

Will this change anything about how you collect data?

No, nothing is changing. By open sourcing GitHub Copilot Chat, we are making it fully transparent how we collect data and enable you to verify this in the source code. Learn more about telemetry in VS Code and the GitHub Copilot Trust Center.

How will the VS Code team prioritize between AI features and non-AI features in future releases?

We believe that AI-powered tools are core to how we write code. We invest in both AI features and improving the core editor experience. This is also reflected in a 50/50% split of the team working on AI versus other features. Many of the non-AI features might not always be as visible to the user, such as performance, security, accessibility, Electron updates, and more.

Will bringing AI features into the core VS Code repository affect the (startup) performance of VS Code?

Performance is our core priority and we are committed to maintaining the performance of VS Code as we integrate AI features. In addition, if you don't enable AI functionality in VS Code, no associated background processes will run that could affect performance.

Can I disable AI functionality in VS Code?

You can disable the built-in AI features in VS Code with the chat.disableAIFeatures setting, similar to how you configure other features in VS Code. This disables and hides features like chat or inline suggestions in VS Code and disables the Copilot extensions. You can configure the setting at the workspace or user level.

Alternatively, use the Learn How to Hide AI Features action from the Chat menu in the title bar to access the setting.

Note
If you have previously disabled the built-in AI features, your choice is respected upon updating to a new version of VS Code.

If I disable AI functionality in VS Code, is my data still sent to Microsoft?

No, if you disable AI functionality in VS Code or if you don't login to your Copilot subscription from VS Code, your data is not sent to the Copilot backend services. Learn more about telemetry in VS Code and the GitHub Copilot Trust Center.

Are the models that VS Code uses in the Copilot extension open source (OSS)?

No. The models used by GitHub Copilot are licensed separately, and that does not change. In fact, most of those models are from third parties such as OpenAI, Anthropic and Google...

What is the difference between Visual Studio Code and Visual Studio IDE?

Visual Studio Code is a streamlined code editor with support for development operations like debugging, task running, and version control. It aims to provide just the tools a developer needs for a quick code-build-debug cycle and leaves more complex workflows to fuller featured IDEs, such as Visual Studio IDE.

Is VS Code free?

Yes, VS Code is free for private or commercial use. See the product license for details.

If you don't yet have a Copilot subscription, you can use Copilot for free by signing up for the Copilot Free plan and get a monthly limit of inline suggestions and chat interactions.

Platform support

Which OSs are supported?

VS Code runs on macOS, Linux, and Windows. See the Requirements documentation for the supported versions. You can find more platform specific details in the Setup overview.

Can I run VS Code on older Windows versions?

Microsoft ended support and is no longer providing security updates for Windows 7, Windows 8, and Windows 8.1. VS Code desktop versions starting with 1.71 (August 2022) no longer run on Windows 7 and starting with 1.80 (June 2023) will no longer run on Windows 8 and 8.1. You will need to upgrade to a newer Windows version to use later versions of VS Code.

VS Code will no longer provide product updates or security fixes on old Windows versions. VS Code version 1.70.3 is the last available release for Windows 7 users and version 1.79 will be the last available release for Windows 8 and 8.1 users. You can learn more about upgrading your Windows version at support.microsoft.com.

Additionally, 32-bit OEM support has been dropped with Windows 10, version 2004. The last stable VS Code version to support Windows 32-bit is 1.83 (September 2023). You will need to update to the 64-bit release.

Can I run VS Code on old macOS versions?

VS Code desktop version starting with 1.105 (September 2025) is deprecating support for macOS Big Sur (version 11.0 and older). Starting with VS Code 1.107 (November 2025), we will stop updating VS Code on macOS Big Sur (version 11.0 and older). You will need to upgrade to a newer macOS version to use later versions of VS Code.

VS Code will no longer provide product updates or security fixes on macOS Big Sur (versions 11.0 and older) and VS Code version 1.106 will be the last available release for macOS Big Sur (11.0 and older). You can learn more about upgrading your macOS version at support.apple.com.

Can I run VS Code on older Linux distributions?

Starting with VS Code release 1.86.1 (January 2024), VS Code desktop is only compatible with Linux distributions based on glibc 2.28 or later, for example, Debian 10, RHEL 8, or Ubuntu 20.04.

If you are unable to upgrade your Linux distribution, the recommended alternative is to use our web client. If you would like to use the desktop version, then you can download the VS Code release 1.85 from here. Depending on your platform, make sure to disable updates to stay on that version. A good recommendation is to set up the installation with Portable Mode.

Can I run a portable version of VS Code?

Yes, VS Code has a Portable Mode that lets you keep settings and data in the same location as your installation, for example, on a USB drive.

Telemetry and crash reporting

How to disable telemetry reporting

VS Code collects usage data and sends it to Microsoft to help improve our products and services. Read our privacy statement and telemetry documentation to learn more.

If you don't want to send usage data to Microsoft, you can set the telemetry.telemetryLevel user setting to off.

From File > Preferences > Settings, search for telemetry, and set the Telemetry: Telemetry Level setting to off. This will silence all telemetry events from VS Code going forward.

Important Notice: VS Code gives you the option to install Microsoft and third party extensions. These extensions may be collecting their own usage data and are not controlled by the telemetry.telemetryLevel setting. Consult the specific extension's documentation to learn about its telemetry reporting.

How to disable experiments

VS Code uses experiments to try out new features or progressively roll them out. Our experimentation framework calls out to a Microsoft-owned service and is therefore disabled when telemetry is disabled. However, if you want to disable experiments regardless of your telemetry preferences, you may set the workbench.enableExperiments user setting to false.

From File > Preferences > Settings, search for experiments, and uncheck the Workbench: Enable Experiments setting. This will prevent VS Code from calling out to the service and opt out of any ongoing experiments.

How to disable crash reporting

VS Code collects data about any crashes that occur and sends it to Microsoft to help improve our products and services. Read our privacy statement and telemetry documentation to learn more.

If you don't want to send crash data to Microsoft, you can change the telemetry.telemetryLevel user setting to off.

From File > Preferences > Settings, search for telemetry, and set the Telemetry: Telemetry Level setting to off. This will silence all telemetry events including crash reporting from VS Code. You will need to restart VS Code for the setting change to take effect.

GDPR and VS Code

Now that the General Data Protection Regulation (GDPR) is in effect, we want to take this opportunity to reiterate that we take privacy very seriously. That's both for Microsoft as a company and specifically within the VS Code team.

To support GDPR:
• The VS Code product notifies all users that they can opt out of telemetry collection.
• The team actively reviews and classifies all telemetry sent (documented in our OSS codebase).
• There are valid data retention policies in place for any data collected, for example crash dumps.

You can learn more about VS Code's GDPR compliance in the telemetry documentation.

What online services does VS Code use?

Beyond crash reporting and telemetry, VS Code uses online services for various other purposes such as downloading product updates, finding, installing, and updating extensions, or providing Natural Language Search within the Settings editor. You can learn more in Managing online services.

You can choose to turn on/off features that use these services. From File > Preferences > Settings, and type the tag @tag:usesOnlineServices. This will display all settings that control the usage of online services and you can individually switch them on or off.

Licensing

Location

You can find the VS Code licenses, third party notices and Chromium Open Source credit list under your VS Code installation location resources\app folder. VS Code's ThirdPartyNotices.txt, Chromium's Credits_*.html, and VS Code's English language LICENSE.txt are available under resources\app. Localized versions of LICENSE.txt by language ID are under resources\app\licenses.

Why does Visual Studio Code have a different license than the vscode GitHub repository?

To learn why Visual Studio Code, the product, has a different license than the open-source vscode GitHub repository, see issue #60 for a detailed explanation.

What is the difference between the vscode repository and the Microsoft Visual Studio Code distribution?

The github.com/microsoft/vscode repository (Code - OSS) is where we develop the Visual Studio Code product. Not only do we write code and work on issues there, we also publish our roadmap and monthly iteration and endgame plans. The source code is available to everyone under a standard MIT license.

Visual Studio Code is a distribution of the Code - OSS repository with Microsoft specific customizations (including source code), released under a traditional Microsoft product license.

See the Visual Studio Code and 'Code - OSS' Differences article for more details.

What does "Built on Open Source" mean?

Microsoft Visual Studio Code is a Microsoft licensed distribution of 'Code - OSS' that includes Microsoft proprietary assets (such as icons) and features (Visual Studio Marketplace integration, small aspects of enabling Remote Development). While these additions make up a very small percentage of the overall distribution code base, it is more accurate to say that Visual Studio Code is "built" on open source, rather than "is" open source, because of these differences. More information on what each distribution includes can be found in the Visual Studio Code and 'Code - OSS' Differences article.

Extensions

Are all VS Code extensions open source?

Extension authors are free to choose a license that fits their business needs. While many extension authors have opted to release their source code under an open-source license, some extensions like Wallaby.js, Google Cloud Code, and the VS Code Remote Development extensions use proprietary licenses.

At Microsoft, we have a mix of open and closed source extensions. Reliance on existing proprietary source code or libraries, source code that crosses into Microsoft licensed tools or services (e.g., the C# DevKit extension uses the Visual Studio subscription license model, see License), and business model differences across the entirety of Microsoft may result in extensions choosing a proprietary license. You can find a list of Microsoft contributed Visual Studio Code extensions and their source code licenses in the Microsoft Extension Licenses article.

How do I find the license for an extension?

Most extensions will have a link to their license on the Marketplace page (their "Read Me" document), found on the right column under Resources. If you don't find a link, you may find the license in the extension's repository if it is public, or you can contact the extension author through the Q & A section of the Marketplace.

Can I use a Microsoft extension outside of VS Code?

No. While the source code for an extension from Microsoft may be open source, we do not license extensions from Microsoft or its affiliates that are published to and acquired from the Visual Studio Marketplace for use outside of the Visual Studio family of products: Microsoft Visual Studio, Visual Studio Code, GitHub Codespaces, Azure DevOps, Azure DevOps Server, and successor products and services offered by us and Microsoft affiliates, such as GitHub, Inc. We build, test, deploy, and support these extensions and services only in the Visual Studio family of products, to ensure they meet our security and quality standards. We do not do this for extensions elsewhere, including those built on a fork of the Code - OSS Repository. Please see Conditions: Use Rights for Marketplace/NuGet Offerings in the Visual Studio Marketplace Terms of Service for more information.

I can't access the Visual Studio Marketplace from product << fill in the blank >>, why not?

We provide the Visual Studio Marketplace for use only by the Visual Studio family of products: Microsoft Visual Studio, Visual Studio Code, GitHub Codespaces, Azure DevOps, Azure DevOps Server, and successor products and services offered by us and Microsoft affiliates, such as GitHub, Inc. Therefore, alternative products including those built on a fork of the Code - OSS Repository, are not permitted to access the Visual Studio Marketplace. We do this to protect the security and quality of the ecosystem, including the following measures:
• Extensions run in the context and with the permissions of the product, and they might contain executable code. The Marketplace vets every extension for security and to prevent them from performing malicious activity. When you install an extension with a product in the Visual Studio family, you know that it has been vetted to run in that context.
• When a malicious extension is reported and verified, or a vulnerability is found in an extension dependency, the extension is removed from the Marketplace, added to a block list, and automatically uninstalled by VS Code.
• Microsoft spends considerable resources in running, maintaining, and securing this global online service. Products in the Visual Studio family are designed to access the Marketplace in a secure and reliable manner, so that the Marketplace is available when you need it.
• Extensions might integrate deeply with the product. The Marketplace ensures that we maintain API compatibility and that extensions use the product's extensions APIs correctly. This helps ensure that extensions you install work correctly across version updates.

See #31168 for additional details on this topic.

Why should I install extensions from the Visual Studio Marketplace?

Installing extensions from the Visual Studio Marketplace has many advantages over installing them from other sources.
• The Visual Studio Marketplace employs several mechanisms to protect you from installing malicious extensions, including malware scanning, dynamic detection, publisher verification, and more. When you install extensions from a different source, there is no guarantee that the extension is safe to run in your context.
• When a malicious extension is reported and verified, or a vulnerability is found in an extension dependency, the extension is removed from the Marketplace, added to a block list, and automatically uninstalled by VS Code.
• The Marketplace enables you to easily find, install, and update extensions. When an update is available, for example because of a security fix, VS Code automatically installs the updated version.
• Extensions might integrate deeply with the product. The Marketplace ensures that we maintain API compatibility and that extensions use the product's extensions APIs correctly. This helps ensure that extensions you install work correctly across version updates.

Report an issue with a VS Code extension

For bugs, feature requests or to contact an extension author, you should use the links available in the Visual Studio Code Marketplace or use Help: Report Issue from the Command Palette. However, if there is an issue where an extension does not follow our code of conduct, for example it includes profanity, pornography or presents a risk to the user, then we have an email alias to report the issue. Once the mail is received, our Marketplace team will look into an appropriate course of action, up to and including unpublishing the extension.

VS Code versions

How do I find my current VS Code version?

You can find the VS Code version information in the About dialog box.

On macOS, go to Code > About Visual Studio Code.

On Windows and Linux, go to Help > About.

The VS Code version is the first Version number listed and has the version format 'major.minor.release', for example '1.100.0'.

Previous release versions

You can find links to some release downloads at the top of a version's release notes:

If you need a type of installation not listed there, you can manually download via the following URLs:

Substitute the specific release you want in the {version} placeholder. For example, to download the Linux Arm64 debian version for 1.83.1, you would use

https://update.code.visualstudio.com/1.83.1/linux-deb-arm64/stable

You can use the version string latest, if you'd like to always download the latest VS Code stable version.

Windows 32-bit versions

Windows x86 32-bit versions are no longer actively supported after release 1.83 and could pose a security risk.

Prerelease versions

Want an early peek at new VS Code features? You can try prerelease versions of VS Code by installing the "Insiders" build. The Insiders build installs side by side to your stable VS Code install and has isolated settings, configurations, and extensions. The Insiders build is updated nightly so you'll get the latest bug fixes and feature updates from the day before.

To install the Insiders build, go to the Insiders download page.

How do I opt out of VS Code auto-updates?

By default, VS Code is set up to auto-update for macOS and Windows users when we release new updates. If you do not want to get automatic updates, you can set the Update: Mode setting from default to none.

To modify the update mode, go to File > Preferences > Settings, search for update mode and change the setting to none.

If you use the JSON editor for your settings, add the following line:

"update.mode": "none"

You can install a previous release of VS Code by uninstalling your current version and then installing the download provided at the top of a specific release notes page.

Note: On Linux: If the VS Code repository was installed correctly then your system package manager should handle auto-updating in the same way as other packages on the system. See Installing VS Code on Linux.

Opt out of extension updates

By default, VS Code will also auto-update extensions as new versions become available. If you do not want extensions to automatically update, you can clear the Extensions: Auto Update check box in the Settings editor (Ctrl+,).

If you use the JSON editor to modify your settings, add the following line:

"extensions.autoUpdate": false

Where can I find the Visual Studio Code icons?

Are there guidelines for using the icons and names?

You can download the official Visual Studio Code icons and read the usage guidelines at Icons and names usage guidelines.

What is a VS Code "workspace"?

A VS Code "workspace" is usually just your project root folder. VS Code uses the "workspace" concept in order to scope project configurations such as project-specific settings as well as config files for debugging and tasks. Workspace files are stored at the project root in a .vscode folder. You can also have more than one root folder in a VS Code workspace through a feature called Multi-root workspaces.

You can learn more in the What is a VS Code "workspace"? article.

Problems and issues

Installation appears to be corrupt [Unsupported]

VS Code does a background check to detect if the installation has been changed on disk and if so, you will see the text [Unsupported] in the title bar. This is done since some extensions directly modify (patch) the VS Code product in such a way that is semi-permanent (until the next update) and this can cause hard to reproduce issues. We are not trying to block VS Code patching, but we want to raise awareness that patching VS Code means you are running an unsupported version. Reinstalling VS Code will replace the modified files and silence the warning.

You may also see the [Unsupported] message if VS Code files have been mistakenly quarantined or removed by anti-virus software (see issue #94858 for an example). Check your anti-virus software settings and reinstall VS Code to repair the missing files.

Resolving shell environment fails

When VS Code is launched from a terminal (for example, via code .), it has access to environment settings defined in your .bashrc or .zshrc files. This means features like tasks or debug targets also have access to those settings.

However, when launching from your platform's user interface (for example, the VS Code icon in the macOS dock), you normally are not running in the context of a shell and you don't have access to those environment settings. This means that depending on how you launch VS Code, you may not have the same environment.

To work around this, when launched via a UI gesture, VS Code will start a small process to run (or "resolve") the shell environment defined in your, .bashrc, .zshrc, or PowerShell profile files. If, after a configurable timeout (via application.shellEnvironmentResolutionTimeout, defaults to 10 seconds), the shell environment has still not been resolved or resolving failed for any other reason, VS Code will abort the "resolve" process, launch without your shell's environment settings, and you will see an error like the following:

If the error message indicates that resolving your shell environment took too long, the steps below can help you investigate what might be causing slowness. You can also increase the timeout by configuring the application.shellEnvironmentResolutionTimeout setting. But keep in mind that increasing this value means you will have to wait longer to use some of the features in VS Code, such as extensions.

If you see other errors, please create an issue to get help.

Investigate slow shell initialization

The process outlined below may help you identify which parts of your shell initialization are taking the most time:
• Open your shell's startup file (for example, in VS Code by typing ~/.bashrc or ~/.zshrc in Quick Open (Ctrl+P)).
• Selectively comment out potentially long running operations (such as nvm if you find that).
• Save and fully restart VS Code.
• Continue commenting out operations until the error disappears.

Note: While nvm is a powerful and useful Node.js package manager, it can cause slow shell startup times, if being run during shell initialization. You might consider package manager alternatives such as asdf or search on the internet for nvm performance suggestions.

Launch VS Code from a terminal

If modifying your shell environment isn't practical, you can avoid VS Code's resolving shell environment phase by launching VS Code directly from a fully initialized terminal.
• Typing code from an open terminal will launch VS Code with your last workspace.
• Typing code . will launch VS Code open to the current folder.

VS Code is blank?

The Electron shell used by Visual Studio Code has trouble with some GPU (graphics processing unit) hardware acceleration. If VS Code is displaying a blank (empty) main window, you can try disabling GPU acceleration when launching VS Code by adding the Electron --disable-gpu command-line switch.

If this happened after an update, deleting the GPUCache directory can resolve the issue.

VS Code gets unresponsive right after opening a folder

When you open a folder, VS Code will search for typical project files to offer you additional tooling (for example, the solution picker in the Status bar to open a solution). If you open a folder with lots of files, the search can take a large amount of time and CPU resources during which VS Code might be slow to respond. We plan to improve this in the future but for now you can exclude folders from the explorer via the files.exclude setting and they will not be searched for project files:

"files.exclude": {
"**/largeFolder": true
}

Technical support channels

You can ask questions and search for answers on Stack Overflow and enter issues and feature requests directly in our GitHub repository.

If you'd like to contact a professional support engineer, you can open a ticket with the Microsoft assisted support team.

12/10/2025

Original source Report a problem

Version 1.107 is now available!

Read about the new features and fixes from November.

Extension API

Visual Studio Code is built with extensibility in mind. From the UI to the editing experience, almost every part of VS Code can be customized and enhanced through the Extension API. In fact, many core features of VS Code are built as extensions and use the same Extension API.

This documentation describes:

• How to build, run, debug, test, and publish an extension
• How to take advantage of VS Code's rich Extension API
• Where to find guides and code samples to help get you started
• Following our UX guidelines for best practices

Code samples are available at Microsoft/vscode-extension-samples.
If you are looking for published extensions, head to the VS Code Extension Marketplace.

What can extensions do?

Here are some examples of what you can achieve with the Extension API:

• Change the look of VS Code with a color or file icon theme - Theming
• Add custom components & views in the UI - Extending the Workbench
• Create a Webview to display a custom webpage built with HTML/CSS/JS - Webview Guide
• Support a new programming language - Language Extensions Overview
• Support debugging a specific runtime - Debugger Extension Guide

If you'd like to have a more comprehensive overview of the Extension API, refer to the Extension Capabilities Overview page.
Extension Guides Overview also includes a list of code samples and guides that illustrate various Extension API usage.

How to build extensions?

Building a good extension can take a lot of time and effort. Here is what each section of the API docs can help you with:

• Get Started teaches fundamental concepts for building extensions with the Hello World sample.
• Extension Capabilities dissects VS Code's vast API into smaller categories and points you to more detailed topics.
• Extension Guides includes guides and code samples that explain specific usages of VS Code Extension API.
• UX Guidelines showcases best practices for providing a great user experience in an extension.
• Language Extensions illustrates how to add support for a programming language with guides and code samples.
• Testing and Publishing includes in-depth guides on various extension development topics, such as testing and publishing extensions.
• Advanced Topics explains advanced concepts such as Extension Host, Supporting Remote Development and GitHub Codespaces, and Proposed API.
• References contains exhaustive references for the VS Code API, Contribution Points, and many other topics.

What's new?

VS Code updates on a monthly cadence, and that applies to the Extension API as well. New features and APIs become available every month to increase the power and scope of VS Code extensions.
To stay current with the Extension API, you can review the monthly release notes, which have dedicated sections covering:

• Extension authoring - Learn what new extension APIs are available in the latest release.
• Proposed extension APIs - Review and give feedback on upcoming proposed APIs.

Looking for help

If you have questions for extension development, try asking on:

• VS Code Discussions: GitHub community to discuss VS Code's extension platform, ask questions, help other members of the community, and get answers.
• Stack Overflow: There are thousands of questions tagged vscode-extensions, and over half of them already have answers. Search for your issue, ask questions, or help your fellow developers by answering VS Code extension development questions!
• VS Code Dev Slack: Public chatroom for extension developers. VS Code team members often join in the conversations.

To provide feedback on the documentation, create new issues at Microsoft/vscode-docs. If you have extension questions that you cannot find an answer for, or issues with the VS Code Extension API, please open new issues at Microsoft/vscode.

Help and support

Was this documentation helpful?
Yes, this page was helpful
No, this page was not helpful

Still need help?
Ask the community
Request features
Report issues
Help us improve
All VS Code docs are open source. See something that's wrong or unclear? Submit a pull request.

12/10/2025

Original source Report a problem