Microsoft Visual Studio Code Changelog

What's new in Microsoft Visual Studio Code 1.88.1

Apr 12, 2024

March 2024 Endgame Recovery 1
Pick up TS 5.4.5
Inline chat sessions show up in chat history
nvm can prevent JS debugging when console: integratedTerminal
Diff editor left side context menu is covered by right editor
Outline trying to reveal activeEntry when entry is filtered out

New in Microsoft Visual Studio Code 1.88.0 (Apr 6, 2024)

New in Microsoft Visual Studio Code 1.87.2 (Mar 13, 2024)

New in Microsoft Visual Studio Code 1.87.1 (Mar 13, 2024)

New in Microsoft Visual Studio Code 1.87.0 (Feb 28, 2024)

New in Microsoft Visual Studio Code 1.86.2 (Feb 20, 2024)

New in Microsoft Visual Studio Code 1.86.1 (Feb 9, 2024)

New in Microsoft Visual Studio Code 1.86.0 (Feb 2, 2024)

New in Microsoft Visual Studio Code 1.85.2 (Jan 19, 2024)

New in Microsoft Visual Studio Code 1.85.1 (Dec 15, 2023)

New in Microsoft Visual Studio Code 1.85.0 (Dec 9, 2023)

Welcome to the November 2023 release of Visual Studio Code. There are many updates in this version that we hope you'll like, some of the key highlights include:
Floating editor windows - Drag and drop editors onto your desktop.
Accessible View workflow - Smoother transitions to and from the Accessible View.
Finer extension update control - Choose which extensions to auto update.
Source Control incoming and outgoing view - Easily review pending repository changes.
JavaScript heap snapshots - Visualize heap snapshots including memory object graphs.
TypeScript Go to Definition from inlay hints - Jump to definition from inlay hint hovers.
Python type hierarchy display - Quickly review and navigate complex type relationships.
GitHub Copilot updates - Inline chat improvements, Rust code explanation.
Preview: expanded Sticky Scroll support - Sticky Scroll in tree views and the terminal.
GitHub Universe, Copilot, and VS Code:
If you were able to watch or attend GitHub Universe this year, you saw that GitHub Copilot was center stage. Copilot was featured in the Opening Keynote and breakout sessions such as GitHub Copilot: the AI pair programmer for today and tomorrow.
The VS Code team has been working hard to integrate Copilot into the editor and you can learn more about the team's progress leading up to GitHub Universe in the recent Pursuit of "wicked smartness" in VS Code blog post. The post details the development of Copilot Chat agents, that behave as subject matter experts on code bases and technologies, and describes how extension authors will be able to contribute their own custom agents to VS Code.
Accessibility:
Accessible View:
Last iteration, we introduced automatic closing of the Accessible View when a key is pressed for a seamless flow between a UI component and its Accessible View. In some cases, this behavior might not be desirable and can now be disabled via the accessibility.accessibleView.closeOnKeyPress setting.
If you find yourself toggling between the terminal and the terminal's Accessible View, you might want to enable terminal.integrated.accessibleViewFocusOnCommandExecution, which automatically opens the Accessible View after a command is executed in the terminal.
Tooltips shown on keyboard focus:
To improve the experience for keyboard users, tooltips are now shown on keyboard focus for items with custom hovers such as Activity Bar and Status Bar items.
Speech detection timeout:
A new setting accessibility.voice.speechTimeout controls how long to wait during silence before accepting speech input, for example to Copilot Chat. By default, voice input is automatically submitted after 1.2 seconds of silence. You can set this to 0 to disable accepting speech input entirely.
Workbench:
Floating editor windows:
We are happy to announce that with this release you can move editors out of the main window into their own lightweight windows. Changes to an editor in one window apply immediately to all other windows where the editor is open.
The easiest way to create a floating editor window is to drag an editor out of the current window and drop it on an empty space on your desktop:
The new workbench.editor.dragToOpenWindow setting can disable this behavior.
There are also new global and contextual commands to move or copy editors and editor groups into their own windows:
View: Copy Editor into New Window (workbench.action.editor.copyWithSyntaxHighlightingAction)
View: Move Editor into New Window (workbench.action.editor.moveEditorToNextWindow)
View: Copy Editor Group into New Window (workbench.action.editor.copyGroupToNextWindow)
View: Move Editor Group into New Window (workbench.action.editor.moveGroupToNextWindow)
View: New Empty Editor Window (workbench.action.newWindow)
The editor area in floating windows can be arranged with any complex layout that you want. And since both terminals and search results can be opened as editors, you can now have these features in separate windows as well!
Native paste support in the File Explorer:
VS Code now supports natively pasting files from your operating system's Explorer into the VS Code File Explorer.
Extension auto update control:
You can now choose which extensions to auto update. This is helpful if you do not want to auto update all extensions but selectively choose which ones to auto update. You can either select an extension or all extensions from a publisher. If you choose to auto update all extensions from a publisher, you can then unselect individual extensions from that publisher.
You should have auto updates either disabled (None) or enabled for selected extensions (Selected Extensions) to use this feature.
New Profile icons:
The following new Profile icons are available to add to your profiles.
Settings editor search improvements and bug fixes:
The Settings editor is back to sorting search results by match type first, rather than only by the table of contents. In other words, title and keyword matches show up at the top, so you don't have to scroll down to find a setting with a matching title.
Settings editor showing the windows.titleBarStyle setting appearing first when searching "title bar style"
The Settings editor still orders settings by the table of contents for tie-breakers, meaning that extension authors' order keys are respected for search queries such as @ext:.
Many Settings editor regressions were also fixed this iteration, including the Settings editor failing to load due to network issues and hanging on certain search queries.
Editor:
Code Actions on Save and Auto:
You can now enable Code Actions on Auto Save in the editor, and Editor: Code Actions On Save (editor.codeActionsOnSave) settings have been migrated over to corresponding enum values. When set to always, Code Actions can be run when you save or Auto Save with window change (onWindowChange) or focus change (onFocusChange). To enable this feature, check Editor: Code Actions On Save (editor.codeActionsOnSave) and change each Code Action's setting to always.
The setting value updates are as follows, with the previous boolean values to be deprecated in favor of the string equivalent.
Multi document highlighting:
Multi document highlighting has additional support from a new proposed MultiDocumentHighlightProvider API. There is now built-in support for semantic occurrence highlighting for the TypeScript language that can be enabled by changing the Editor: Occurrences Highlight (editor.occurrencesHighlight) setting value from singleFile to multiFile. For languages besides TypeScript, multi document occurrences are highlighted based off of textual occurrences rather than semantic occurrences until more language-specific providers are implemented.
Source Control:
Incoming/Outgoing changes:
This milestone we have introduced a new Incoming/Outgoing section in the Source Control view to display incoming and outgoing changes for the current branch compared to its remote. The new section displays both the individual changes with the number of resources changed along with insertions and deletions, as well as an All Changes entry that summarizes all resources across all changes. The visibility of the new section can be controlled using the scm.showIncomingChanges, and scm.showOutgoingChanges settings. Both settings support the following values: always, auto (default), and never.
Input maximum lines:
Previously, Source Control input would auto-grow to display at most 6 lines of text, which was sufficient space for most commit messages. However there were cases where more space would be helpful, and there is a new setting, scm.inputMaxLines, that controls the maximum number of Source Control input lines.
Terminal:
Sticky scroll:
Sticky scroll has landed in the terminal! Using knowledge provided by shell integration, the prompt of the command at the top of the viewport sticks to the top of the terminal, similar to how Sticky Scroll works in the editor.
Clicking a Sticky Scroll element will scroll to that part of the terminal buffer.
This is currently disabled by default but can be enabled by setting:
"terminal.integrated.stickyScroll.enabled": true. We plan on enabling this by default in the future, at which point you will be able to opt out by right-clicking and toggling it off.
Command highlighting:
Hovering a command in the terminal now shows a highlight bar to its left. This is useful for plain terminal prompts where it's not clear where one command starts and another ends.
Shell integration and command navigation improvements:
With the introduction of Sticky Scroll, many improvements were made to shell integration. In particular to terminals running on Windows, where the markers received from shell integration aren't totally reliable. There is now logic that intelligently scans the terminal contents and adjusts the markers before making the terminal command available.
Shell integration is also now capable of detecting the distinct parts of a prompt; the prompt and its input. This determines what part of the command displays when using Sticky Scroll. This will also trim empty lines from the top of the prompt, commonly used to split up output and make the terminal easier to read.
The existing command navigation feature also benefits as you can navigate to the more reliable prompt used for Sticky Scroll, rather than the less reliable prompt line.
Improved underline rendering:
Dashed and dotted underlines in the terminal are now rendered in a pixel perfect pattern:
Git pull Quick Fix:
If a Git branch checkout can be fast forwarded, a new terminal Quick Fix provides the option to run git pull.
Tasks:
The npm.packageManager setting can now be set to bun to enable detection and running of Bun scripts defined in package.json.
Debug:
JavaScript Debugger:
Visualize heap snapshots:
V8 heap snapshots, saved as .heapsnapshot, can now be visualized in VS Code. There is both a traditional tabular view as well as a graphical representation of the retainers of a given memory object.
Testing:
The Find control is now supported in the Test Results view terminal.
Languages
TypeScript 5.3:
This release includes TypeScript 5.3. This major update adds support for import attributes, better type narrowing, and more. It also includes new language tooling features and bug fixes.
You can read more about TypeScript 5.3 in the TypeScript blog.
node_module symbols excluded from workspace symbol search
Go to Symbol in Workspace now excludes symbols from node_modules by default. This makes it easier to find symbols in your code without getting overwhelmed by symbols from installed packages.
You can revert to the previous behavior that included all symbols in the project by setting "typescript.workspaceSymbols.excludeLibrarySymbols": false.
Jump to definition for inlay hints
Types in JavaScript and TypeScript inlay hints are now interactive. Quickly jump to a type's definition by hovering over the type and clicking while holding Ctrl on Windows and Linux or Cmd on macOS:
Inlay hint hover showing Go to Definition by using Ctrl/Cmd + click
Prefer using 'type' for auto imports:
Type-only imports let you import a type while ensuring the import gets fully erased at runtime. If you prefer to always default to type imports, you can now set "typescript.preferences.preferTypeOnlyAutoImports": true and auto imports will use type-only import. This setting is off by default.
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:
Automatically install the GitHub Copilot and Pull Requests and Issues extensions in Dev Containers.
Finer control over which extensions are installed in Dev Containers.
Reuse local machine certificates in local Dev Containers and WSL sessions.
Contributions to extensions:
GitHub Copilot:
Inline chat UI improvements:
The inline chat prompt history is now persisted across VS Code sessions. The keyboard shortcuts to see the previous and next prompts were also changed to be Up and Down to align with other previous and next item shortcuts in VS Code.
When inline chat proposes creating new files, such as when using the /test slash command, you can now choose the file name and location by selecting Create As from the
Create drop down:
Create and Create As actions for newly suggested files from inline chat
Last, there is a new experimental lightweight UI mode for inline chat. It provides a smoother streaming experience and renders diffs only on demand. You can enable it via the "inlineChat.mode": "live3" setting.
Inline chat lightweight mode with diff on demand:
Inline chat for fixes shows summary and follow-up action
When using inline chat for fixes (/fix), you now also get a short summary what the fix does. If there are remaining errors, you can refine the fix by clicking on the offered follow-up action.
Inline chat with summary:
Progressive message rendering in inline chat
Inline chat now uses the same progressive rendering as the Chat view:
Inline chat progressive rendering:
Terminal generate commit message Quick Fix:
Last release, a Copilot Generate Commit Message "sparkle" was added to the Source Control view input box. For terminal users, there is now a Quick Fix to generate an editable commit message in the terminal after running the git add... command.
Terminal agent and command suggestion improvements:
All terminal related features have moved to the @terminal agent. This was done to make it clear that the terminal agent might not pull in workspace information, to consolidate the functionality, and make it more convenient to use.
Here are the mappings from the old to new prompts:
In addition, command suggestions saw significant improvements this release. Terminal command suggestions now know about the operating system and the shell used. Workspace information is also conditionally pulled in, based on whether Copilot thinks the question is related to the workspace. The workspace context collection should see further improvements, both in terms of speed and what exactly gets referenced.
Progress is displayed while fetching workspace details:
Notice in this example how the @terminal agent knows how file paths are formed when used in the microsoft/vscode repository:
The terminal agent is capable of answering questions that need knowledge about file naming standards in the repository
There are also convenient follow-ups to explain suggested commands, which are presented as blue sparkle links just above the chat input box:
The blue sparkle link just before the input box explains the suggestion
Activating the Explain follow-up gives a detailed explanation of the suggested command:
The detailed explanation typically explains the command and each argument
Authentication upgrade dialog when using GitHub remote search capabilities on private repos
If enabled for your user account, when you use the @workspace agent, Copilot Chat searches your workspace using remote search capabilities. In order to use remote search with private repositories, an authentication token with more permission is required. If there isn't a token with the needed permissions already, you are prompted for additional permission:
Authentication dialog when searching the workspace:
You'll only see this dialog one time and future queries to the @workspace agent will use the cached token.
Send a request to @workspace more easily
Since the @workspace agent is used in many Copilot queries, we wanted to make sure it's as easy as possible to activate. You can now type a question in the chat input, then press Ctrl+Enter to send the question and automatically prepend @workspace.
Explain Rust code with Copilot:
Copilot Chat now collects cross-file context from your codebase when you ask it to explain Rust code and have a Rust language service extension installed such as rust-analyzer. To view a Copilot explanation, select some code in your active editor, then use the Copilot > Explain This from the context menu or /explain from inline chat or the Chat view.
Copilot > Explain This action in the editor context menu
Potential vulnerability detection in code blocks
We want to make sure that you are aware of any possible issues with Copilot generated source code, so we are now running code in Chat view codeblocks through a code vulnerability detection model and flagging any detected issues. You might not see this feature at first, but we will be gradually rolling it out to Copilot Chat users, and also tuning the types of vulnerabilities that are detected.
When a codeblock is determined to contain a possible vulnerability, it will be annotated at the bottom of the codeblock. The vulnerability detection model is one we're piloting, so be sure to make your best determination when reviewing Copilot's suggestions and any potential vulnerabilities.
Copilot code vulnerability warning displayed in the Chat view
Copilot videos and livestream sessions:
Don't miss the recent VS Code Copilot videos on YouTube. Learn about the latest Copilot Chat features and how Copilot "just got a whole lot smarter".
And if you haven't been tuning in to the VS Code livestreams, you'll want to watch the Copilot demos featured in the 1.84 release party.
Python:
Show Type Hierarchy with Pylance:
You can now more conveniently explore and navigate through your Python projects' types relationships when using Pylance. This can be helpful when working with large codebases with complex type relationships.
When you right-click on a symbol, you can select Show Type Hierarchy to open the type hierarchy view. From there you can navigate through the symbols' subtypes as well as supertypes.
Theme: Catppuccin Macchiato (preview on vscode.dev)
Configurable debugging option under the Run button menu:
The Python Debugger extension now has a configurable debug option under the Run button menu. When you select Python Debugger: Debug using launch.json and there is an existing launch.json in your workspace, it shows all the available debug configurations that you can pick to start the debugger. If there aren't any configurations, you are prompted to select a debug configuration template to use to create a launch.json file for your Python application.
Python Debugger: Debug using launch.json option under the Run button menu:
Deactivate command supported when activated using environment variables
The Python extension has a new activation mechanism that activates the selected environment in your default terminal without running any explicit activation commands. This is currently behind an experimental flag and can be enabled through the following User setting: "python.experiments.optInto": ["pythonTerminalEnvVarActivation"].
However, one initial drawback with this activation mechanism is that it didn't support the deactivate command. We received feedback that this is an important part of some users' workflow, so we have added support for deactivate when the selected default terminal is PowerShell or Command Prompt. We have plans to add support for additional terminals in the future.
Warning message and setting for REPL Smart Send:
When attempting to use Smart Send via Shift+Enter on a Python file that contains invalid or deprecated code, there is now a warning message and an option to deactivate REPL Smart Send. Users can change their user and workspace specific behavior for REPL Smart Send via the Python.REPL: Enable REPLSmart Send (python.REPL.enableREPLSmartSend) setting.
Settings editor entry for Python REPL Smart Send:
Testing architecture rewrite:
The Python test adapter rewrite experiment has been rolled out to 100% of users. Currently, you can opt out by adding "python.experiments.optOutFrom" : "pythonTestAdapter" in your settings.json, but we will soon drop this experimental flag and adopt this new architecture.
GitHub Pull Requests and Issues:
There has been more progress on the GitHub Pull Requests and Issues extension, which allows you to work on, create, and manage pull requests and issues.
Merge queues are now supported in the PR description and Create view.
A new setting "githubPullRequests.allowFetch": false prevents fetch from being run.
Submodule support was improved.
Review the changelog for the 0.78.0 release of the extension to learn about the other highlights.
Preview Features:
Sticky Scroll in trees:
Building on the success of Sticky Scroll in the editor, we've extended this feature to all tree views, enabling users to more easily navigate project trees. Sticky Scroll for trees can be enabled by setting workbench.tree.enableStickyScroll: true. To ensure Sticky Scroll does not take too much space, it can only take up to 40% of the view height. Additionally, users can customize the maximum number of sticky elements by configuring workbench.tree.stickyScrollMaxItemCount, which is set to 7 by default.
For an improved tree navigation experience, you can select a sticky element to jump directly to it within the tree, or press the chevron of a parent element to hide all its child elements. Additionally, accessing checkboxes and action items is easier when Sticky Scroll is enabled.
Multi-file diff editor:
This release ships a preview of the multi diff editor. The multi diff editor lets you view changes in multiple files in one scrollable view:
To enable the multi diff editor, set "multiDiffEditor.experimental.enabled": true. Currently, the multi diff editor can be used to review local changes, staged changes, incoming/outgoing changes, and changes from pull requests. Note that the multi diff editor is not yet feature complete and might not work in all scenarios.
Alternate character filtering for Korean:
For various features across the workbench that use filtering, VS Code will now also search the QWERTY keyboard equivalent as it's common to accidentally forget to switch the language Input Method Editor (IME). This works similar to search engines but in real time. For example, debug when typed in a Korean IME is ㅇ듀ㅕㅎ, which is nonsensical:
Searching for a "ㅇ듀ㅕㅎ" command will now present results for "debug"
Currently this does not work when filtering from the middle of the word.
Hide Problem decorations:
There is a new setting to hide Problem decorations in the editor and throughout the workbench (excluding the Problems view). The setting Problems: Visibility (problems.visibility) is enabled by default to show all problems.
Some Problems UI settings are disabled when Problems: Visibility is off:
Outline > Problems: Badges (outline.problems.badges)
Outline > Problems: Colors (outline.problems.colors)
Outline > Problems: Enabled (outline.problems.enabled)
Problems > Decorations: Enabled (problems.decorations.enabled)
A warning is shown in the Status Bar when Problems: Visibility is off.
Problems: Visibility off Status Bar item and hover
Proposed APIs:
Every milestone comes with new proposed APIs and extension authors can try them out. As always, we want your feedback. Here are the steps to try out a proposed API:
Find a proposal that you want to try and add its name to package.json#enabledApiProposals.
Use the latest @vscode/dts and run npx @vscode/dts dev. It will download the corresponding d.ts files into your workspace.
You can now program against the proposal.
You cannot publish an extension that uses a proposed API. There may be breaking changes in the next release and we never want to break existing extensions.
Test coverage:
This iteration we revived work on test coverage, with initial UI integration and some minor updates to the longstanding proposal. While the API is too lengthy to include here, we believe it to be fairly straightforward, and would welcome your input on the proposal in issue #123713.
Chat Agents:
As mentioned in our recent blog post, Pursuit of "wicked smartness" in VS Code, we are developing a model for extensions to contribute chat agents to the Copilot Chat view. The chat agent API is proposed, but you can experiment with adding your own chat agent now. Subscribe to issue #199908 for updates.
Multi document highlighting API:
As introduced in the previous release, there is now support for multi document highlighting within VS Code. This iteration, we added a proposed MultiDocumentHighlightProvider API to register multi document highlight providers. This adds the ability to provide semantic occurrence highlighting for specific programming languages. Providers return a new MultiDocumentHighlight structure with a Map of URI to DocumentHighlight. Feedback and further updates can be tracked via issue #196354.
Engineering:
New CDN:
We're rolling out the deployment to a new CDN endpoint: vscode.download.prss.microsoft.com. For system administrators, make sure to configure network rules to allow traffic from this endpoint.
macOS 10.13 and 10.14 support has ended
VS Code 1.85 is the last release that supports macOS 10.13 (macOS High Sierra) and 10.14 (macOS Mojave). Refer to our FAQ for additional information.
Notable fixes:
195796 Searching for text after localization is not supported in the Settings editor
197319 vscode://file// links no longer working
194094 Do not dismiss Profiles Icon picker when moving mouse outside of the picker
197070 Support positioning debug toolbar on custom title bar

New in Microsoft Visual Studio Code 1.84.2 (Nov 10, 2023)

New in Microsoft Visual Studio Code 1.84.1 (Nov 8, 2023)

New in Microsoft Visual Studio Code 1.84.0 (Nov 2, 2023)

Welcome to the October 2023 release of Visual Studio Code. There are many updates in this version that we hope you'll like, some of the key highlights include:
More audio cues - New audio cues to indicate clear, save, and format activity.
Activity bar position - Move Activity bar to the top for compact display.
Hide editor tabs - Show multiple, single, or no editor tabs.
Maximize Editor Groups - Quickly expand the active Editor Group.
Python improvements - Better run code in terminal, easier virtual environment creation.
FastAPI tutorial - Learn about developing Python FastAPI apps with VS Code.
Gradle for Java - Improved support for Java Gradle projects.
Preview: GitHub Copilot - Chat "agents", generate commit messages, terminal support.
ACCESSIBILITY:
Clear, format, and save opt-in audio cues:
When audioCues.clear is enabled, a sound indicates that the terminal, a notification, or the chat responses have been cleared.
In files and notebooks, audioCues.save and audioCues.format can be set to play on user gesture or always for each event. While disabled, an ARIA alert is used instead and can be customized with accessibility.alert.format and accessibility.alert.save.
Windows magnifier synced:
The winows magnifier now follows the cursor in VS Code properly.
Accessible View improvements:
By default, a user's cursor is positioned at the bottom of the terminal Accessible View; to preserve the position instead, you can set terminal.integrated.accessibleViewPreserveCursorPosition to true.
The Accessible View can be hidden with accessibility.hideAccessibleView, useful if sharing one's screen with an audience of sighted users.
The Accessible View now closes when a user starts typing and focuses the prior element for a smoother work flow.
Text editor in window title focused view:
Last iteration, we added a ${focusedView} variable to window.title. We now also indicate when a Text Editor is focused.
WORKBENCH:
Customize Activity bar position:
You can now move the Activity bar to top of the Side Bar as shown in the following video.
When the Activity bar is placed on the top, the Accounts and Manage buttons are moved to the title bar to the far right.
Note: This is supported only when the custom title bar is enabled ("window.titleBarStyle": "custom").
Hide Editor Tabs:
Users are now able to hide editor tabs by setting workbench.editor.showTabs to none. Other showTabs options are multiple (default) and single to show a single editor tab for the active editor.
Maximize Editor Group:
There is a new command View: Toggle Maximize Editor Group (Ctrl+K Ctrl+M) to maximize an editor group. This will hide all other groups and adds a button to the tab bar, allowing the user to restore the previous layout. If the setting workbench.editor.doubleClickTabToToggleEditorGroupSizes is set to maximize, users can double-click on an editor tab to maximize and unmaximize the editor group.
Similar settings search in the Settings editor:
Like the Command Palette, the Settings editor now runs a similar settings search to gather more relevant results for a given query.
The implementation is currently in an early stage, and can expect improvements over the next few iterations.
Confirmation for opening protocol links:
When a protocol link for a file or workspace opens in VS Code, a dialog will now ask for confirmation:
Confirm protocol links dialog display for a local file
Protocol links can either point to a local file (for example vscode://file/path/to/file) or to a remote file (for example vscode://vscode-remote/ssh-remote+[USER@]HOST[:PORT]/path/to/file). For each case, there are new settings to disable this behavior:
security.promptForLocalFileProtocolHandling - For local protocol links
security.promptForRemoteFileProtocolHandling- For remote protocol links
EDITOR:
Nearest Quick Fix keyboard shortcut:
There is a new setting to activate the nearest Quick Fix in a line from Ctrl+. (command ID editor.action.quickFix), no matter where your cursor is in that line. Previously a preview feature, Code Action Widget: Include Nearby Quick Fixes (editor.codeActionWidget.includeNearbyQuickFixes) is now enabled by default.
The command highlights the source code that will be refactored or fixed with Quick Fixes. Normal Code Actions and non-fix refactorings can still be activated at the cursor location.
Multi-document highlighting:
Initial support for code highlighting across multiple documents was added via the setting Editor: Multi Document Occurrences (editor.multiDocumentOccurrencesHighlight). This initial implementation features only textual occurrences, with support for semantic highlighting coming in the future.
SOURCE CONTROL:
Force push using --force-if-includes:
This milestone there is now support for the --force-if-includes option, which is an auxiliary option to --force-with-lease added in Git 2.30. The new option ensures that commits that are being force-pushed were created after examining the commit at the tip of the remote reference, and reduces the chance of losing commits when auto fetch is enabled. You can disable the use of --force-if-includes by disabling the git.useForcePushIfIncludes setting.
NOTEBOOKS:
Scroll on Execute improvements:
How the next cells are revealed when executing through notebooks with Shift+Enter was improved to help focus on the output. This also reduces the amount of cell movement when re-executing cells that already have output.
IPython stack trace rendering:
Exception stack traces from IPython now render clickable links to help navigate to the error. This will only apply if the Jupyter extension does not alter the stack trace first: "jupyter.formatStackTraces": false.
DEBUG:
JavaScript Debugger:
Improved Event Listener Breakpoints view
The Event Listener Breakpoints view is friendlier and is now presented as a tree with checkboxes:
Event Listener Breakpoints view shown as a tree with the Canvas WebGL Error Fired event checked
Better handling of sourcemap renames:
When code is compiled with a bundler, variables can be renamed. This is especially common with imports in all bundlers, and certain local identifiers in esbuild. The debugger is now aware of scopes each rename applies to, which fixes many snags users historically hit.
This requires the debugger to parse the syntax tree of compiled modules. This is done in a background thread and only when renames are detected, but the behavior can be disabled by setting "sourceMapRenames": false in your launch.json to avoid any performance impact.
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:
You can now log into Tunnels using your Microsoft account.
Connect to Dev Containers over SSH and Tunnels now supported on Windows.
You can learn more about these features in the Remote Development release notes.
CONTRIBUTIONS TO EXTENSIONS:
GitHub Copilot:
Streaming inline chat
The GitHub Copilot Chat extension's inline chat can now make progressive text edits and "types" at the rate at which a response being received. This is a more natural experience than the previous behavior of waiting for the entire chat response to be received before applying it to the editor.
Not all edits are insertions, and for replacements Copilot sometimes has a hard time figuring out where to start. In those cases, streaming might not yet work as expected. Stay tuned for improvements in this area.
Chat agents
This iteration, we built a new way to interact with Copilot Chat: agents. Agents are like experts who have a specialty that they can help you with, and you can talk to them in the chat by mentioning them with the @ symbol. Currently, there are two agents:
@workspace has context about the code in your workspace and can help you navigate it, finding relevant files or classes.
@vscode knows about commands and features in the VS Code editor itself, and can help you use them.
Each agent also supports a few slash commands, and the slash commands that you may have used before should now be used with an agent. For example, /explain is now @workspace /explain. But as a shortcut, you can also just type / for a list of completions that will automatically expand to the full agent and command.
@workspace
The @workspace agent uses a meta prompt to determine what information to collect from the workspace to help answer your question. One approach used by the meta prompt is to look back at your conversation history to resolve ambiguous words/phrases in a question. For example, if you ask @workspace What does it do?, the meta prompt will now consider the history to figure out what it actually is and what information to collect to answer the question. The meta prompt also uses a wide set of terms, including more synonyms, to generate a list of potentially relevant terms.
File paths and symbols in @workspace responses are clickable links. This makes it easy to navigate to the code that Copilot is referring to.
The @workspace agent respects the .gitignore and .copilotignore when deciding which files from the workspace to index.
Agents replace slash commands
The new agents replace the functionality of slash commands such as /createWorkspace and /createNotebook with added slash modifiers:
/createWorkspace --> @workspace /new
/createNotebook --> @workspace /newNotebook
/explain --> @workspace /explain
/fix --> @workspace /fix
/test --> @workspace /test
/vscode --> @vscode /api
Commit message generation:
Copilot Chat can now generate commit messages based on the pending changes using the new "sparkle" action in the Source Control input box.
Import grouping:
Generated imports are now always put to the top of the file or below existing import blocks. This is supported for most common programming languages.
Improved /explain context:
You can ask Copilot Chat to explain a code selection in your active editor either through the @workspace /explain command or through the Explain with Copilot action in the context menu. Copilot Chat now includes the implementations of referenced symbols such as functions and classes, leading to more accurate and useful explanations. This works best across files when you have an extension contributing language services installed for one of the following languages: TypeScript/JavaScript, Python, Java, C#, C++, Go, or Ruby.
Persistent chat view state:
Previously, the Copilot Chat view was initially hidden and then later shown. The Copilot Chat view now remains active between window reloads so you don't have to manually reopen it. Additionally, the Chat view now guides you through the process of signing into GitHub and activating your free trial of GitHub Copilot.
Chat using configured display language:
By default, Copilot Chat now initially responds using your configured display language in VS Code. You can override this automatic behavior by configuring github.copilot.chat.localeOverride.
Reduce welcome message verbosity:
You can now control whether Copilot Chat greets you with a verbose welcome message when you first start a conversation by configuring github.copilot.chat.welcomeMessage. The options are first (default), always, and never.
Terminal Quick Fixes:
When a failed command is run in the terminal, Copilot will now offer a Quick Fix to explain what happened.
A sparkle icon shows up that offers to explain a command
This can be triggered via the sparkle icon (Ctrl+.) next to the current terminal prompt.
Terminal command suggestions
Copilot can now offer CLI command suggestions via the Ctrl+I keybinding when the terminal is focused. This brings up Quick Chat with @workspace /terminal pre-filled:
This /terminal slash command is optimized for suggesting shell commands using the current shell. The quality of suggestions and UX will see more improvements next release.
Improved surfacing of Run in Terminal action:
When a code block has a shell language type, the Run in Terminal action is now surfaced on hover of the code block:
Inline chat can reply with terminal commands
The inline chat can now reply with commands to be run in the terminal:
Python:
Improvements to run line in the terminal:
The Python extension has improved the behavior of sending lines to the Python REPL (Shift+Enter) when no code has been selected to run. Previously, when you placed the cursor on a line of Python code and pressed Shift+Enter, the Python extension would send the exact line content to the REPL, even if it would fail, for example, due to being part of a multi-line command.
With the new experimental Smart Send feature, the Python extension sends the smallest block of runnable code surrounding the cursor position to the REPL for execution. This ensures that only complete and executable sections of code are sent to the REPL. The cursor will also be automatically moved to the next executable line, to provide a smooth experience when executing multiple chunks iteratively.
To try it out, you can add the following User setting: "python.experiments.optInto: ["pythonREPLSmartSend"]. While this feature is currently behind an experiment, we expect it to be the default behavior in the future. If you have feedback or suggestions on how we can further improve this feature, please let us know!
Improvements to Python linting extensions:
We have made several improvements to our supported linting extensions to allow for a more configurable and flexible experience with your favorite Python tools.
The Pylint, Mypy and Flake8 extensions now offer settings that allow you to specify glob patterns for files that you wish to exclude from linting. This can be useful if you are working with a large codebase with many subprojects, and want to exclude certain folders from being linted. These settings are "pylint.ignorePatterns", "mypy-type-checker.ignorePatterns" and "flake8.ignorePatterns".
These extensions also support cwd settings, which allows you to specify the working directory for the linter. This setting has been updated to support the variable ${fileDirname}, so the working directory can be dynamically set to the parent folder of the file you have open in the editor. This is useful if you are working with mono repos, and want the linter working directory to be dynamically updated as you open files from different subprojects. These settings are "pylint.cwd", "mypy-type-checker.cwd" and "flake8.cwd".
The default value of the "mypy-type-checker.preferDaemon"setting was changed (only applicable to the Mypy extension). Previously, it was set to true, which meant that the Mypy daemon would be used by default. After receiving feedback, we changed the default value to false. If you are wondering which value would best for you, our recommendation is to use the Mypy daemon if you enabled the Mypy reporting scope to be the entire workspace ("mypy-type-checker.reportingScope": "workspace") for performance reasons. Otherwise, if the reporting scope is set to the current file, we recommend you use the Mypy executable that shipped with the extension.
Deprecated built-in linting and formatting features:
With all the work and improvements made to the linting and formatting extensions in VS Code, we have deprecated the built-in linting and formatting features that are shipped in the Python extension. This includes all the linting and formatting commands as well as settings (python.linting.* and python.formatting.*). We recommend you remove these deprecated settings if you are still using them, and use the supported linting and formatting extensions instead.
If you are using a linter without a supported extension, check out the community-contributed Ruff extension. Ruff is a Python linter written in Rust and supports various linters such as pyflakes, pycodestyle, pydocstyle, and more. Recently support was added for using Ruff as a formatter in VS Code ("[python]": { "editor.defaultFormatter": "charliermarsh.ruff" }).
You can also create your own linter or formatter VS Code extension for your favorite Python tool. Check out our Python Tools Extension Template for a quick start.
Create environment notification:
Virtual environments are a recommended way to work with Python projects with dependencies that need to be installed. They offer isolation and reproducibility and are very popular in Python projects.
For this reason, the Python extension now displays a notification when you attempt to run or debug a Python file or project with listed dependencies when you don't have a virtual environment selected on your workspace. This notification provides a quick way to create a new virtual environment through the Python: Create Environment command.
If you already have a virtual environment on your workspace, you have the option to select it, or delete and recreate it.
This notification can be disabled by setting python.python.createEnvironment.trigger to off.
Notification stating that a virtual environment is not currently selected with an option to Create the environment or disable the notification
Virtual environment deactivation helper:
A couple of months ago we announced a new experimental feature for terminal activation using environment variables, to enhance your development workflow by automatically activating the selected environment in the terminal without the need for explicit activation commands. However, since there are no explicit activation scripts working, the deactivate command was no longer working when this experiment was enabled.
The Python extension will now detect when you attempt to run the deactivate command and show a helper notification to guide you on how to add scripts for your shell so the command will work again when the environment is activated through environment variables. It also offers a button to open your shell profile file for you to add the necessary scripts.
Notification stating that the deactivate command is not working and offering a button to open the shell profile file
You can find the full documentation on how to add the necessary scripts for your shell on the vscode-python wiki.
If you are not in the experiment and would like to try out this feature, you can add the following User setting: "python.experiments.optInto: ["pythonTerminalEnvVarActivation"].
Improvements to test output:
We've made significant improvements to how you can view and interact with the test output in the Python extension when the pythonTestAdapter experiment is enabled, announced a few months ago. Previously, output from test discovery and execution was inconsistently scattered across the Python Test Log output channel and the Test Results panel, with some information being duplicated in both. To consolidate the experience, output related to test execution is displayed in the Test Results panel, and test discovery in the Python output channel. To learn more, read our related vscode-python wiki.
This new approach also supports colorization in the output if you are using Pytest and set "python.testing.pytestArgs": ["--color=yes"] in your settings.json. Colorization only works for test execution in the Test Results panel and will not work for discovery or for output in the Python Test Log panel.
Test execution output displayed in Test Results panel with colors, while test discovery output is displayed in the Python output channel
There is also a new button Show output to easily open the Test Logs from the Test Explorer view when errors on test discovery occur.
"Show output" button to open the Test Logs in the Test Explorer view
Platform-specific versions of the Python Debugger extension
The Python Debugger extension now ships platform-specific versions, so that only the necessary platform-specific files are installed on every update. This reduces the size of the extension and helps improve startup time.
Tensorboard extension:
The Tensorboard functionality has moved out of the Python extension into a standalone Tensorboard extension.
If you have any issues with this new extension or wish to provide feedback, you can file an issue in the Tensorboard extension GitHub repo.
Jupyter
Execute with Precedent/Dependent Cells:
With the Jupyter extension, you can now run all precedent or dependent cells of a target cell from the dropdown menu next to the Cell Run button. This is still a preview feature and can be enabled with the jupyter.executionAnalysis.enabled setting and the notebook.consolidatedRunButton setting.
This feature is currently powered by the Pylance extension so you will need to install the latest Prerelease version of Pylance to use this feature.
VS Code Speech:
We are introducing a new extension to bring voice support to VS Code! The new VS Code Speech extension integrates into GitHub Copilot Chat to enable voice-to-text transcription services for Chat input.
Once installed, a microphone icon appears and when selected, begins filling Chat input with text based on the transcribed results of your voice. The transcription is computed locally on your machine and does not require a connection to the internet.
GitHub Pull Requests and Issues:
There has been more progress on the GitHub Pull Requests and Issues extension, which allows you to work on, create, and manage pull requests and issues.
Projects are displayed and can be added from the Pull Request description webview.
Integrated with GitHub Copilot to generate the PR title and description from the PR Create view.
PRs checked out with the GitHub CLI (gh pr checkout) are recognized by the extension.
Preview Features:
Floating editor windows:
We continued exploring how to pull editors out of the workbench window into their own windows and now want to invite the VS Code Insiders community to play with this exciting new feature and provide feedback.
Make sure to install VS Code Insiders and run the new View: Move Active Editor into a New Window command on editors to open them in a floating window.
We still have to figure out many issues and provide missing features, but we are optimistic that we can enable this feature in Stable in the near future.
WASM-WASI support for Language Servers:
Support for language servers in WASM/WASI was added to the experimental wasm-wasi-core extension.
There is also an extension showcasing a simple language server written in Rust and compiled to WASM in the vscode-wasm repo. The extension depends on the language server crate maintained by the Rust analyzer team.
Extension authoring:
Improved test runner:
There is now a command-line runner and extension for VS Code to make running tests for extensions easier. Extensions using the new approach can run in VS Code's testing UI. While some migration is required, this usually only takes a few minutes. Read the VS Code Testing Extensions documentation for more information.
Finalized TestMessage.contextValue API:
You can provide a contextValue on TestMessages to be shown when users take actions on those messages. Additionally, two new menu contributions points are available, testing/message/context and testing/message/content. The former is displayed on the message in the Test Results tree view, and the latter is displayed over the message in the editor. For example, this might be used to provide an action to update a fixture in snapshot testing:
Failed test result with Update Snapshot action displayed
Updated codicons:
The following new icons were added to our codicon library:
copilot
git-fetch
mic
mic-filled
coffee
snake
game
chip
piano
music
thumbsup-filled
thumbsdown-filled
New theme colors:
textPreformat.background: Background color for preformatted text segments
Root folder icons per name
Proposed APIs:
Every milestone comes with new proposed APIs and extension authors can try them out. As always, we want your feedback. Here are the steps to try out a proposed API:
Find a proposal that you want to try and add its name to package.json#enabledApiProposals.
Use the latest @vscode/dts and run npx @vscode/dts dev. It will download the corresponding d.ts files into your workspace.
You can now program against the proposal.
You cannot publish an extension that uses a proposed API. There may be breaking changes in the next release and we never want to break existing extensions.
Support configuring data sent to extensions via Issue Reporter:
A new proposed API lets extension authors send additional data via the Issue Reporter.
Engineering:
Windows 32-bit support ends:
There is no longer support for Windows 32-bit VS Code. If you're still on 32-bit build of VS Code, you should update to the 64-bit version
Extensions and documentation:
Gradle for Java:
Java development in VS Code just got easier with the improved Gradle for Java extension. The pre-release version has better support for building Gradle projects thanks to adopting the Build Server Protocol (BSP). Similar to other protocols used in VS Code, for example the Language Server Protocol (LSP), the BSP provides an abstraction layer between development environments and build tools such as Gradle.
To try out the new Gradle support, install both the Extension Pack for Java and pre-release version of the Gradle for Java extension. You can learn more about Gradle and the BSP in this recent blog post from the Java extension team.
FastAPI tutorial:
FastAPI is a modern and fast web framework for building Python APIs, and has become more and more popular thanks to its simplicity and performance.
You can now learn how you can get the best out of VS Code and the Python extension to create and debug FastAPI applications through our new FastAPI Tutorial!
Custom Layout user guide:
There is a new Custom Layout article describing layout customization for the workbench and editors. There you'll learn how to modify VS Code's main UI elements such as views, panels, and editors to fit your preferred workflow.
Topics include:
Primary and Secondary Side Bars
Panel position and alignment
Pinned editor tabs
Editor group layout
and more
Notable fixes:
ToC shows up while doing search while workbench.settings.settingsSearchTocBehavior set to hide
Blank settings editor when having network issues

New in Microsoft Visual Studio Code 1.83.1 (Oct 13, 2023)

New in Microsoft Visual Studio Code 1.83.0 (Oct 5, 2023)

New in Microsoft Visual Studio Code 1.82.3 (Oct 3, 2023)

New in Microsoft Visual Studio Code 1.82.2 (Sep 17, 2023)

New in Microsoft Visual Studio Code 1.82.1 (Sep 13, 2023)

New in Microsoft Visual Studio Code 1.82.0 (Sep 8, 2023)

Accessibility improvements - Accessible View support for inline completions, updated keybindings.
Built-in port forwarding - Forward local server ports from within VS Code.
Sticky Scroll updates - Scrolls horizontally with editor, display last line in scope, folding UI.
New diff editor features - Detect moved code, dynamically switch inline and side-by-side view.
Command Center displayed by default - Quickly open files or run commands from the title bar.
Copy Notebook output - Easily copy cell output as well as generated images.
WebAssembly debugging - Decompile WASM code to step through and set breakpoints.
New TypeScript refactorings - Move to File and Inline Variables refactorings.
New Python Formatting topic - Learn how to integrate formatters such as autopep8 and Black.
Preview: GitHub Copilot - CreateWorkspace command previews file structure of proposed code.
ACCESSIBILITY:
Focused view in window title:
The window.title setting now has a ${focusedView} variable that displays the name of the view in the title bar, if a view is currently focused.
Accessible View for inline completions:
Inline completions, like those coming from the GitHub Copilot extension, for example, can now be inspected in the Accessible View.
Improved navigation consistency across the workbench:
Last iteration, we made the experience when navigating between an input control (for example, search or filter input) and its results consistent across components like the Extensions view, the Keyboard Shortcuts editor, and more using Ctrl+Down and Ctrl+Up. This has been extended to the Settings editor and GitHub Pull Request comment control.
This also works for navigating between the terminal and the terminal accessible buffer.
Updated terminal accessible buffer keybindings:
Previously, the terminal accessible buffer was opened via Shift+Tab. This conflicted with an existing keyboard shortcut in some shells. As such, we've removed that keybinding in favor of Ctrl+Down and Alt+F2, to align with the other Accessible Views.
Actions in the Accessible View:
Actions in the Accessible View allow screen reader users to go to next/previous, disable accessibility verbosity, and more for a given feature. These actions exist within a convenient toolbar on the view so that the current context can be preserved.
Go to Symbol in the Accessible View:
Accessibility help dialogs and some Accessible Views now have a Go to Symbol (Ctrl+Shift+O) action to allow for swifter navigation through content.
Focus terminal accessible buffer after run
The terminal now has a terminal.integrated.focusAfterRun setting so that users can specify if the terminal's accessible buffer (accessible-buffer), the terminal itself (terminal), or nothing (none) should be focused when Terminal: Run Selected Text In Active Terminal is invoked.
WORKBENCH:
Built-in port forwarding:
VS Code now has a built-in port forwarding system. This feature allows you to share locally running services over the internet to other people and devices. To use it, select the Forward a Port button in the Ports view available in the Panel region (Ports: Focus on Ports View).
Forward a Port button displayed in the Ports view:
Theme: Codesong (preview on vscode.dev)
Read more about port forwarding in the Port Forwarding user guide.
Command Center now on by default:
The Command Center was introduced several months ago as a quick way to both discover and interact with VS Code. You can use it as a launch pad for finding a command in the Command Palette, running a task, and other quick experiences. We've been running an experiment displaying the Command Center in the title bar and have gotten positive feedback, so we felt it was time to enable it by default.
Here is a video using the Command Center, and the back and forward buttons as well.
We see immense potential for the Command Center to be the center for finding anything in VS Code, so watch for more improvements in the future!
NOTE: If you would rather not have the Command Center visible, you can right-click on the title bar and uncheck the Command Center entry in the dropdown to hide it.
Control how pinned editors close from keyboard or mouse:
There is a new setting workbench.editor.preventPinnedEditorClose for more control on how pinned tabs respond to keyboard shortcuts or mouse middle-click for closing an editor. By default, a pinned tab will not close from keyboard or mouse interactions (default value keyboardAndMouse). You can change this setting accordingly:
keyboardAndMouse - A pinned tab will not close from keyboard shortcut or mouse middle-click (default since 1.82.x).
keyboard - A pinned tab will not close via keyboard shortcut (default until 1.81.x).
mouse - A pinned tab will not close via mouse middle-click.
never - A pinned tab will always close from keyboard shortcut or mouse middle-click.
New and updated themable colors for the Status bar:
The Status bar already provides many themable colors for its items. There are now more colors to allow for theming hover foreground and background colors:
statusBarItem.errorHoverBackground
statusBarItem.errorHoverForeground
statusBarItem.warningHoverBackground
statusBarItem.warningHoverForeground
statusBarItem.remoteHoverBackground
statusBarItem.remoteHoverForeground
statusBarItem.offlineHoverBackground
statusBarItem.offlineHoverForeground
The following two color names were updated because the color no longer applies to the entire Status bar, but only to the remote indicator:
statusBar.offlineBackground renamed to statusBarItem.offlineBackground
statusBar.offlineForeground renamed to statusBarItem.offlineForeground
EDITOR:
Sticky Scroll:
This iteration there have been several improvements to the Sticky Scroll UI, available at the top of the editor (View: Toggle Sticky Scroll).
Now by default Sticky Scroll is scrolled sideways when the editor horizontal scrollbar is scrolled. This feature can be turned off by disabling editor.stickyScroll.scrollWithEditor.
It is possible to view the last line of a scope by holding the Shift key and hovering over a Sticky Scroll line. Clicking on a line while holding Shift moves the editor cursor to the last line of the scope.
Folding icons have been added to the Sticky Scroll gutter. The rendering of these icons follows the setting editor.showFoldingControls that controls the rendering of the folding icons in the editor gutter.
Sort JSON on save:
It is now possible to sort JSON or JSONC (JSON with comments) files on save. Use the setting json.sortOnSave.enable to enable this feature.
Code Actions and Quick Fix navigation via keyboard
You can now quickly navigate through the Quick Fix, Code Actions, or Source Control menus (they use the "Action" control) by typing any keyword or letter corresponding with available menu options. The filter utilizes fuzzy matching and searches are not limited to the first letter or prefix but includes the entire label text as well.
Diff Editor:
In this release, we enabled the new diff editor by default. We also improved some of the new diff editor features and fixed many bugs.
Moved code detection:
This iteration we polished the moved code detection feature. It can be enabled with "diffEditor.experimental.showMoves": true or in the diff editor context menu. When enabled, code blocks that are moved from one location to a different location in the same file are detected and arrows are drawn to indicate where the code blocks moved to.
Code moves are also detected when they are slightly modified. The Compare button can be used to compare the block before and after the move.
Collapsed unchanged code headers:
Use "diffEditor.hideUnchangedRegions.enabled": true or select the map icon in the editor context menu to enable collapsing unchanged code blocks.
With this release, there are now breadcrumbs for collapsed code blocks to indicate which symbols are collapsed. Clicking on a breadcrumb item reveals the selected item:
Collapsed code headers:
Dynamic layout:
If the width of the diff editor is too small, the editor automatically switches to inline view. If the editor is wide enough again, the previous layout is restored. Set "diffEditor.useInlineViewWhenSpaceIsLimited": false to disable this behavior.
Button toggle states
We updated the toggle style of buttons in the diff editor to be more visible.
Old toggle style (untoggled and toggled) with dim untoggled buttons
New toggle style (untoggled and toggled) with shaded toggled background
TERMINAL:
Control how terminals restore on startup:
The new setting terminal.integrated.hideOnStartup controls whether a terminal is automatically created when the application starts up. The following options are available:
never (default): Never hide the terminal view on startup.
whenEmpty: Only hide the terminal when there are no persistent sessions restored.
always: Always hide the terminal, even when there are persistent sessions restored.
Disable bracketed paste mode:
Bracketed paste mode is a feature in the terminal that wraps pasted text in special sequences so the shell can use that information. Shells that turn on this feature are meant to properly support this but there may be reasons it falls over at which point you might see text like [201~ unexpectedly when pasting. This feature can now be disabled explicitly, which disables the feature even if shells request it.
Terminal focus after run setting:
The terminal now has a terminal.integrated.focusAfterRun setting so that users can specify if the terminal should be focused when Terminal: Run Selected Text In Active Terminal is invoked. The other options are to focus the terminal's accessible buffer (accessible-buffer) or leave nothing focused (none).
Resizable Find:
Faster rendering when GPU acceleration is disabled:
The performance of the "DOM renderer", which is used when GPU acceleration is disabled, has been significantly improved thanks to a rewrite of the component. The rewrite focused on reducing the number of DOM elements used and the savings scale much better the larger the terminal is.
When testing a typical render call on a terminal with 117 columns and 36 rows, it took ~10 ms before and ~2 ms after. Increasing the terminal size to 300x100 on the test machine recorded a render taking ~25-35 ms before and ~4-5 ms after.
Better selection rendering:
When GPU acceleration is off, selection rendering is now the same as the webgl renderer and all backgrounds are changed into the theme's selection background color to ensure good contrast and consistency.
Respect half minimum contrast ratio for dimmed text:
The minimum contrast ratio feature allows the terminal to take more control over the foreground colors in the terminal to ensure they appear at a particular contrast ratio. One problem with this feature in the past was that dimmed text (CSI 2 m) would also respect the contrast ratio, meaning it could appear just as prominent as regular text. PowerShell's auto complete ghost text is an example where this didn't play nicely.
Dimmed text will now have half the contrast requirements. While this means that the text may no longer meet the minimum contrast ratio, it's now obviously different from regular text, which is more important.
Now dimmed text should be visually different for typical minimum contrast ratios
Configure the cursor appearance when unfocused:
The look of the cursor in the terminal when it is not focused can now be configured with terminal.integrated.cursorStyleInactive. This supports all styles of the existing terminal.integrated.cursorStyle, plus outline (default) and none.
Improved Terminal: Open Detected Link behavior:
The Open Detected Link command (Ctrl+Shift+O) behavior has been changed to maintain high performance while making it much easier to search the whole terminal buffer for links. Previously, it would provide links for just the viewport and a little above with a cumbersome Show more links button at the end to search the rest of the buffer:
Previously the last entry must have been selected to search everything:
Notice that CodeQL.yml was not included until a filter was typed as it was outside the viewport.
New link formats:
The following GNU-style link formats are now detected in terminals:
sourcefile:lineno.column
sourcefile:line1-column1.column2
sourcefile:line1.column1-line2.column2
DEBUG:
JavaScript Debugger:
WebAssembly debugging:
The JavaScript debugger will now automatically decompile WebAssembly modules to the WebAssembly Text Format, and allow you to step through and set breakpoints in the decompiled modules.
Breakpoint hit during a WebAssembly debug session
Theme: Codesong (preview on vscode.dev)
Source map loading improvements
We made many improvements to the way source maps are loaded in this release:
Source maps in some common cases, like in applications compiled with the tsc command line, are loaded 3-5x faster.
Hot module reloading from the Vite dev server is now supported.
Source maps can now be automatically loaded from authenticated endpoints.
Testing:
Improved status area:
The 'status area' below the filter box in the Testing view is now more concise, and also provides a clickable action to rerun the most recently run tests. Holding Alt while clicking on the rerun button will debug those tests instead.
Support for link detection in test output:
Link detection now runs in the terminal where Test Output is shown. File names, paths, and URIs are now clickable.
Improved experience for test-correlated output:
Test extensions can correlate console output with specific tests or locations. Previously, each output created in this way would appear as its own item in the Test Results view, and open in a text editor when selected.
Now, they are shown in a proper terminal, and navigating to an output message opens a terminal of that test's output with the message selected.
Notebooks:
Copy cell output:
The cell output menu now includes an option to copy the output to the system clipboard. The context menu can also be used for image output by right-clicking the image and selecting the Copy Output command.
LANGUAGES:
TypeScript 5.2:
VS Code now ships with TypeScript 5.2.2. This major update brings new TypeScript language features, better performance, and many important improvements and bug fixes. You can read about TypeScript 5.2 on the TypeScript blog.
Move to file refactoring:
The Move to file refactoring for JavaScript and TypeScript lets you move a class, function, or constant into an existing file. This will also automatically update all references to the symbol and update imports as needed:
When you select Move to file, VS Code shows you a list of all files in the current TypeScript or JavaScript project. You can start typings to quickly filter to the file you want.
Alternatively, you can use Select existing file... to select a file using the normal file picker or Enter new file path... to specify a new file that should be created.
Inline variable refactoring:
The Inline variable refactoring for JavaScript and TypeScript replaces all occurrences of a variable with its constant value.
This refactoring is often most useful when rewriting existing code. For example, when a variable ends up being declared and then immediately returned, you can use inline variable to remove the extra declaration and return the value directly:
function add(a, b) {
const result = a + b;
return result;
After running inline variable on result:
function add(a, b) {
return a + b;
Clickable parameter hints:
You can now click on parameter hints to quickly jump to the parameter declaration. After turning on inlay hints using:
"editor.inlayHints.enabled": "on",
"typescript.inlayHints.parameterNames.enabled": "all",
"javascript.inlayHints.parameterNames.enabled": "all"
hold down Ctrl/Cmd and click on the parameter name to jump to that parameter's declaration:
We plan to enable Go to Definition for other JavaScript and TypeScript inlay hints in upcoming releases.
REMOTE DEVELOPMENTS:
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:
Better Remote - Tunnels connection reliability.
New Install Docker in WSL command.
Prebuild Dev Containers instructional guide.
You can learn about new extension features and bug fixes in the Remote Development release notes.
CONTRIBUTIONS TO EXTENSIONS:
GitHub Copilot:
Create workspaces from the Chat view:
You can now use /createWorkspace to create workspaces from a natural language description in the stable build of the GitHub Copilot Chat extension.
We've also made the following improvements:
Proposed workspaces are now rendered as file trees in the chat response.
You can click into files to open a readonly preview in the editor.
If Copilot's initial proposal wasn't quite right, you can ask follow-up questions to help Copilot iterate and improve.
Start coding in untitled editor with inline chat:
There is now a hint for how to start an inline chat session via Ctrl+I when you open an untitled text editor. Screen reader users can hear this hint and choose to disable it with the accessibility.verbosity.untitledHint setting.
Improvements to Quick Chat:
We introduced Quick Chat a couple of months ago and have been iterating quickly to provide an experience that feels made for VS Code.
Highlights this iteration:
More compact UX.
Quick Chat now stays open when focus is lost.
Sash and "scroll-to-grow" behavior to resize window.
Open Quick Chat now in the Command Center.
Overall, the UX is more compact to align with other "Quick Open" experiences like the Command Palette (less padding everywhere, user and Copilot icons are smaller, buttons are inline instead of being in a title bar).
By default, when you ask a question, the Quick Chat resizes to focus on that question and answer to minimize screen real estate. We also think it helps focus on those quick questions that you might want to ask Copilot. The history of your conversation is still available and you can scroll up to go back in time.
Because of this dynamic height, we also wanted to provide a way to resize the window if you need more or less space. There are two options to adjust the window size. The first is what we call "scroll-to-grow." If your Quick Chat window is small from a small answer, but you'd like to see a previous long answer, as you scroll up, the Quick Chat grows to a max height.
The height of the Quick Chat can be reset back to showing only the last question and answer by doing one of the following:
Closing the Quick Chat and waiting 30 seconds.
Asking another question or running /clear (keep in mind, /clear clears your chat history for good).
Double-clicking on the bottom sash.
Speaking of the sash... we also have a sash at the bottom of the Quick Chat that can be used for manually adjusting the height of the Quick Chat. When you use the sash, you're opting out of the default dynamic behavior and are saying "I want this height to be fixed here until reset."
Explain terminal selection:
Copilot now has the ability to explain the current terminal selection by selecting Copilot: Explain This in the terminal's context menu (Right-click or Shift + Right-click depending on the platform).
The Copilot: Explain This command will bring up the Chat view, where Copilot will return a detailed explanation.
Natural language search for settings:
The Settings editor now allows natural language search with GitHub Copilot Chat.
The natural language search results are currently placed below keyword-matching results and ordered by descending similarity score, but we plan to fix the ordering next month so that the search results continue to be arranged by their table of contents group.
Natural language search currently relies on Copilot embeddings. Consequently, natural language search results will not show up in the Settings editor for searches made before the embeddings become available, that is a few seconds after the GitHub Copilot Chat extension activates.
PYTHON:
New Python Formatting article:
There is a new dedicated topic on Python Formatting, where you'll learn how to set a default formatter such as autopep8 or Black and customize it through various settings.
Terminal activation using environment variables:
The Python extension now has a new activation mechanism that activates the selected environment in the terminal without running any explicit activation commands. This month, we are beginning to roll this out as an experiment, making it the default experience. With the new approach, we use environment variables to activate terminals, which is done implicitly on terminal launch and can thus be quicker, especially for conda environments. You can add the following User setting: "python.experiments.optInto": ["pythonTerminalEnvVarActivation"] to try it out.
If you have any comments or suggestions regarding this experiment, feel free to share them in vscode-python issue #11039.
Recreate or use existing .venv environment:
When working within a workspace that already contains a .venv folder, the Python: Create Environment command has been updated with options to either recreate or use the existing environment. If you decide to recreate the environment, your current .venv is deleted, allowing you to recreate a new environment named .venv. You can then customize this new environment by following the Python: Create Environment flow to select your preferred interpreter and specify any dependency files for installation. In the case the environment cannot be deleted, for example, due to it being active, you are prompted to delete the environment manually.
Alternatively, if you choose to use the existing environment, the environment is selected for your workspace.
PREVIEW FEATURES:
Quick Access text search:
We are experimenting with showing workspace search results in a Quick Access menu. To try this, run Search: Quick Text Search (Experimental). This command sets up the Quick Open to accept search queries. Type some text to see matches from different workspace files.
Dim unfocused editors and terminals:
There's a new experimental feature to dim editors and terminals that are not currently focused. The goal of this feature is to make it much clearer where text will go compared to the typical blinking cursor.
The image above shows the dim unfocused feature enabled with opacity set to 0.5 so that it is clearer that the editor for terminalService.ts has focus.
This can be enabled using accessibility.dimUnfocused.enabled and the amount of dimming is controlled with accessibility.dimUnfocused.opacity.
The feature only covers editors and terminals currently but the plan is to expand this to allow a user to configure what views they want to dim themselves.
EXTENSION AUTHORING:
Support for batch range formatting:
The DocumentRangeFormattingEditProvider API now supports batch formatting. This means that an extension can optionally signal to the editor that it supports being called with multiple ranges at once. This helps reduce the number of calls to the formatting provider and thus improves performance.
To opt in to batch formatting, providers must implement a new optional function: provideDocumentRangesFormattingEdits.
EnvironmentVariableCollection's scoped to a workspace folder
The EnvironmentVariableCollection API now supports creating a new collection that is scoped to a particular workspace folder and will apply in addition to the "global" collection.
// Get a scoped collection for the first workspace folder
const scoped = context.environmentVariableCollection.getScoped({
workspaceFolder: workpsace.workspaceFolders[0]
});
scoped.replace('SCOPED', '1');
// Only terminals created in the first workspace folder will have SCOPED=1 set
The Python extension uses this mechanism to set up different virtual environments depending on which folder a terminal belongs to in a multi-root workspace.
Configure when a EnvironmentVariableMutator is applied
The EnvironmentVariableCollection API now has the ability to apply changes inside the shell integration script that will run after shell initialization scripts. This will only work when shell integration is enabled so the change can be applied both at shell creation and inside shell integration if it's critical
This feature is useful when the variable in question could be mutated by a shell initialization script.
PROPOSED APIS:
Every milestone comes with new proposed APIs and extension authors can try them out. As always, we want your feedback. Here are the steps to try out a proposed API:
Find a proposal that you want to try and add its name to package.json#enabledApiProposals.
Use the latest @vscode/dts and run npx @vscode/dts dev. It will download the corresponding d.ts files into your workspace.
You can now program against the proposal.
You cannot publish an extension that uses a proposed API. There may be breaking changes in the next release and we never want to break existing extensions.
A contextValue on TestMessage's and contribution points
You can provide a contextValue on TestMessages to be shown when users take actions on those messages. Additionally, two new menu contributions points are available, testing/message/context and testing/message/content. The former is displayed on the message in the Test Results tree view, and the latter is displayed over the message in the editor.
Read more about contextValue in issue #190277.
Terminal context menu contributions
Two new menus are being proposed that allow extensions to integrate their own context menu actions into the terminal
Listen to terminal command execution:
An early proposal for the long requested ability for extensions to listen to the terminal command execution API is available for testing. This API is implemented using shell integration and will only fire on terminals that have it enabled and working.
The shape of this API is not final but the basic idea will remain the same.
Here's an example usage that listens for any successful git push command and triggers a refresh in the extension
This API will likely include a corresponding change event before it's finalized and the API name may change to make it clearer that it's a simple string and not Range-based like TextEditor.selection.
TERMINAL QUICK FIX PROGRESS:
The terminal Quick Fix proposal can now trigger a regular VS Code command, as opposed to a terminal command. This change necessitated also changing the terminal command interface name.
ENGINEERING:
Electron 25 update:
In this milestone, we are promoting the Electron 25 update to our stable users. This update comes with Chromium 114.0.5735.289 and Node.js 18.15.0. We want to thank everyone who self-hosted on Insiders builds and provided early feedback.
Update highlights for Node.js:
Node.js bundled in our desktop application and standalone executable bundled with our servers are updated from v16 -> v18. Given that this is a major version bump, there are a couple of behavior and compatibility changes:
DNS result orders from the OS are no longer sorted. We have added --dns-result-order=ipv4first to our extension host in both local and server scenarios to avoid breaking extensions that might not have yet adopted this change. Moving forward, we recommend that extensions use the autoSelectFamily option in socket.connect API to accommodate the result order changes.
Prebuilt binaries from the official Node.js repo for Linux are now compatible with Linux distributions based on glibc 2.28 or later. This would mean dropping support from our servers for Ubuntu 18, CentOS 7, RHEL 7, etc. We are now shipping a custom build of Node.js for our Linux servers to maintain glibc 2.17 or later compatibility. This support will change in future updates when we are no longer capable of building newer Node.js versions on CentOS 7 images, so we advice our server users to update their OS versions if they are affected by this change.
Update highlights for Chromium:
Certain Mesa version updates cause broken shader compilation leading to artifacts in application UI. The issue is tracked in issue #190437, which also contains the link to the Chromium bug report. You can identify this issue by running with --verbose and looking for the following line ERROR:shared_context_state.cc(81)] Skia shader compilation error in the logs. If you are affected by this issue, the current workaround is to delete the GPU cache located at ~/.config/Code/GPUCache.
When Chromium uses the SwiftShader backend for webgl, it seems to have regressed performance on both Windows and Linux for our integrated terminal. As a workaround, we detect the affected users based on the GL_RENDERER string and switch to the DOM backend for the terminal. Additional details can be found in issue #190195, which also contains link to the Chromium bug report

New in Microsoft Visual Studio Code 1.81.1 (Aug 10, 2023)

New in Microsoft Visual Studio Code 1.81.0 (Aug 7, 2023)

New in Microsoft Visual Studio Code 1.80.1 (Jul 14, 2023)

New in Microsoft Visual Studio Code 1.80.0 (Jul 6, 2023)

New in Microsoft Visual Studio Code 1.79.2 (Jun 16, 2023)

New in Microsoft Visual Studio Code 1.79.1 (Jun 14, 2023)

New in Microsoft Visual Studio Code 1.79.0 (Jun 8, 2023)

New in Microsoft Visual Studio Code 1.78.2 (May 13, 2023)

New in Microsoft Visual Studio Code 1.78.1 (May 10, 2023)

New in Microsoft Visual Studio Code 1.78.0 (May 4, 2023)

New in Microsoft Visual Studio Code 1.77.3 (Apr 18, 2023)

New in Microsoft Visual Studio Code 1.77.2 (Apr 12, 2023)

New in Microsoft Visual Studio Code 1.77.1 (Apr 6, 2023)

New in Microsoft Visual Studio Code 1.77.0 (Apr 2, 2023)

New in Microsoft Visual Studio Code 1.76.2 (Mar 19, 2023)

New in Microsoft Visual Studio Code 1.76.1 (Mar 13, 2023)

New in Microsoft Visual Studio Code 1.76.0 (Mar 2, 2023)

New in Microsoft Visual Studio Code 1.75.1 (Feb 10, 2023)

New in Microsoft Visual Studio Code 1.75.0 (Feb 3, 2023)

New in Microsoft Visual Studio Code 1.74.2 (Dec 22, 2022)

New in Microsoft Visual Studio Code 1.74.1 (Dec 14, 2022)

New in Microsoft Visual Studio Code 1.74.0 (Dec 8, 2022)

New in Microsoft Visual Studio Code 1.73.1 (Nov 10, 2022)

New in Microsoft Visual Studio Code 1.73.0 (Nov 3, 2022)

New in Microsoft Visual Studio Code 1.72.2 (Oct 14, 2022)

New in Microsoft Visual Studio Code 1.72.1 (Oct 12, 2022)

New in Microsoft Visual Studio Code 1.72.0 (Oct 7, 2022)

New in Microsoft Visual Studio Code 1.71.2 (Sep 19, 2022)

New in Microsoft Visual Studio Code 1.71.1 (Sep 14, 2022)

New in Microsoft Visual Studio Code 1.71.0 (Sep 5, 2022)

New in Microsoft Visual Studio Code 1.70.2 (Aug 20, 2022)

New in Microsoft Visual Studio Code 1.70.1 (Aug 11, 2022)

New in Microsoft Visual Studio Code 1.70.0 (Aug 6, 2022)

New in Microsoft Visual Studio Code 1.69.2 (Aug 3, 2022)

New in Microsoft Visual Studio Code 1.69.1 (Jul 12, 2022)

New in Microsoft Visual Studio Code 1.69.0 (Jul 8, 2022)

New in Microsoft Visual Studio Code 1.68.1 (Jun 15, 2022)

New in Microsoft Visual Studio Code 1.68.0 (Jun 9, 2022)

Welcome to the May 2022 release of Visual Studio Code. There are many updates in this version that we hope you'll like, some of the key highlights include:
Configure Display Language - See installed and available Language Packs in their language.
Problems panel table view - View errors and warnings as a table to quickly filter on their source.
Deprecated extensions - Learn whether an extension is deprecated or should be replaced.
Extension sponsorship - Support the developers who build your favorite extensions.
Hide Explorer files using .gitignore - Reuse your existing .gitignore to hide files in the Explorer.
Terminal color and contrast enhancements - Find match background color, min contrast ratio.
Git branch protection - Branch protection available right inside VS Code.
TypeScript Go to Source Definition - Jump directly to a symbol's JavaScript implementation.
VS Code for the Web localization - vscode.dev now matches your chosen browser language.
Development Container specification - Learn more about the evolving dev container spec.
Preview: Markdown link validation - Detects broken links to headers, images, and files.
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.
WORKBENCH:
Configure Display Language improvements:
The Configure Display Language command has been refreshed to include:
The name of the language in that language.
An Available languages section that shows what languages aren't installed on your machine and selecting one will automatically install it and apply that language.
Configure Display Language dropdown with installed and available Language Packs in their language
Theme: Panda Theme:
This should help with the discovery of available Language Packs. Please let us know what you think!
Problems panel table view:
This milestone we added a new capability for users to toggle the view mode of the Problems panel between a tree and a table. Compared to the tree view, the table surfaces the source (language service or extension) of each problem, which allows users to filter the problems by their source.
Problems panel table view:
Theme: GitHub Dark Dimmed Theme
You can toggle the view UI with the View as Table/View as Tree button in the upper right of the Problems panel or change the default view mode with the Problems: Default View Mode setting (problems.defaultViewMode)
Problems panel View at Table button
Deprecated extensions:
In this milestone, we have added support for deprecated extensions in VS Code. An extension can be simply deprecated or deprecated in favor of another extension or when its functionality is built into VS Code. VS Code will render extensions as deprecated in the Extensions view, as shown below.
A deprecated extension that is no longer being maintained.
Deprecated extension with no maintenance
An extension deprecated in favor of another extension. In this case, VS Code does not allow users to install this extension.
Deprecated extension with alternative:
A deprecated extension with its functionality built-in to VS Code that can be enabled by configuring settings.
Deprecated extension with builtin to VS Code:
VS Code will not automatically migrate or uninstall a deprecated extension. There will be a Migrate button to guide you to switch over to the recommended extension.
Migrate deprecated extension
Theme: GitHub Dark Dimmed Theme
Note: The list of deprecated extensions is maintained by the VS Code. If you have an extension that you believe should be deprecated, reach out to us by commenting in this discussion.
Sponsoring extensions:
VS Code now allow users to sponsor their favorite extensions. When an extension can be sponsored, VS Code will render a Sponsor button in the Extensions view Details page like below:
Sponsor extension button on Extensions view Details page
Theme: GitHub Dark Dimmed Theme
The Sponsor button will direct you to the extension's sponsorship URL, where you can provide your support. Refer to Extension sponsorship to learn how to opt into this feature for your extension.
Hide files in Explorer based on .gitignore:
The File Explorer now supports parsing and hiding files that are excluded by your .gitignore file. This can be enabled via the Explorer: Exclude Git Ignore (explorer.excludeGitIgnore) setting. This setting works alongside files.exclude to hide unwanted files from the Explorer.
Note: At this time, negated globs such as !package.json are not parseable.
Lock hover position:
Some custom hovers are difficult or impossible to mouse over due to the presence of other UI elements (for example, a scroll bar). Holding Alt while a hover is active will now "lock" it, giving it a wider border and preventing mouse movement outside of the hover from hiding it. This is primarily an accessibility feature to make hovers play nicely with screen magnifiers but it is also useful for copying text from hovers. Note that this feature only applies outside of the editor because editor hovers can always be moused over unless specified otherwise via the editor.hover.sticky setting.
Holding the Alt key while hovering an item in the Extensions view will add a 2 pixel border around it and allow mousing over it and selecting text
Settings editor improvements:
The Settings editor now shows a default value override indicator for language-specific settings. You can view language-specific settings by adding a language filter in the Settings editor search bar, either by typing it out explicitly (@lang:javascript), or by clicking the filter button on the right of the search bar, and selecting the Language option.
When the default value override indicator shows up, it indicates that the default value of the language-specific setting has been overridden by an extension. The indicator also indicates which extension overrode the default value.
Settings editor default override indicator showing up for the editor wordwrap setting when there is a Markdown language filter in place. The default override indicator indicates that the default value of the language-specific setting was overridden by the Markdown
Language Features extension:
Theme: Light Pink
This iteration also fixes a behavior where some links in the Settings editor were not redirecting properly when there was already a search query in the Settings editor search bar. The links also now have proper styling so that it is clearer when one is hovering over them.
After searching for the word "font" in the Settings editor, and selecting the terminal category in the table of contents, the setting terminal.integrated.fontFamily shows up, and its description contains a link to the editor.fontFamily setting. Clicking on the link now brings you correctly to the setting.
Theme: Light Pink:
Comments widget primary button:
The comments widget uses the primary button color for the first (rightmost) action:
Add Comment has the primary button color
Terminal:
Find match background color:
Last release find in the terminal was implemented to show a border around all matches, but this was a temporary solution until support for changing the background of cells dynamically was possible. A colored background is now the default for themes when highlighting matches and the overall experience should look similar to the editor.
Find now uses the blue from the editor's find for the active match and the orange for highlights
If you're a theme author that adopted terminal.findMatchBorder or terminal.findMatchHighlightBorder, we recommend migrating to terminal.findMatchBackground and terminal.findMatchHighlightBackground if that would fit the theme better or help contrast.
Improvements to contrast and the minimum contrast ratio#
The find match background work added a lot more flexibility in how the terminal works with background and foreground colors. Because of this, improvements were made around contrast in the terminal, aligning the terminal visuals closer to the editor. In addition, there is now the minimum contrast ratio feature that changes the foreground of text dynamically to help with visibility.
Luminance will now go in the other direction if contrast isn't met. For example, if contrast isn't met for dark grey text on a lighter grey background with pure black (#_000000), the color will also try to move towards white and the value that best meets the desired contrast ratio will be used.
Darker grey on lighter dark can now use a light foreground color if needed
Selection is now drawn below the text when GPU acceleration is disabled and supports opaque colors. Previously, this had to be partially transparent and it would wash out the foreground color. Thanks to this change, the selection color now uses the same color as in the editor.
Foreground color are retained in selections
Nerd font symbols should now apply minimum contrast ratio to blend in with nearby text while Powerline symbols and box drawing characters will not apply minimum contrast ratio as they are often adjacent to inverted cells without any foreground characters.
Powerlines no longer have odd colors between the colored sections
Themes can now specify a fixed selection foreground color to be used by default in the high contrast themes.
The dark high contrast theme now uses black as its selection foreground
Several bugs were fixed to make the resulting foreground color more correct.
As a reminder, minimum contrast ratio can be disabled if you would prefer original colors by setting "terminal.integrated.minimumContrastRatio": 1.
Source Control:
There have been a few updates to the Git extension that align with our new pull request flow.
Git: Branch prefix:
To make the process of creating a new branch smoother, there is a new setting, git.branchPrefix, that specifies a string to use as a prefix when creating a new branch.
Git: Branch name generation:
generate branch with random name:
A new setting git.branchRandomName.enable will make VS Code suggest random branch names whenever creating a new branch. The random names are generated from dictionaries, which you can control via the git.branchRandomName.dictionary setting. The supported dictionaries are: adjectives (default), animals (default), colors, and numbers.
Git: Branch protection:
With the new git.branchProtection setting, you can configure specific branches to be protected. VS Code will avoid committing directly on protected branches and will offer you the chance to create a new branch to commit to instead. You can fine tune this behavior with the git.branchProtectionPrompt setting.
GitHub: Pull request template support:
The GitHub extension now understands pull request templates and will use them as a base whenever creating a PR from a newly forked repository.
Notebooks:
Cell revealing changes:
We have tuned how cells outside of the viewport are revealed in a couple scenarios.
When you click a cell in the Outline view, if that cell is outside of the viewport, the notebook will now scroll to reveal that cell at about the top 1/5th of the viewport. This matches the Outline's behavior in the text editor.
When the cursor is in a cell editor, you can move the cursor past the first or last line of the editor to move it into the next cell editor. Now, when moving the cursor into an editor whose cell is out of the viewport, the notebook will scroll just enough to reveal that line in the editor, instead of jumping up to reveal the cell in the middle of the viewport.
Find and Replace supports seeding query from cursor/selection:
The Find control in notebook editor now supports seeding the search string from the editor selection. The behavior is controlled by the editor setting editor.find.seedSearchStringFromSelection.
Seed search string from editor selection in notebook
Debugging:
Run and Debug without a launch.json:
When you haven't set up a launch.json configuration file and press F5, or select the Run and Debug button in the Debug view, VS Code picks a debugger based on the programming language in the currently active file. If you don't have a file open, you will be asked which debugger you want to use. This experience can be a little confusing, so we've made a couple improvements.
Select debugger prompt before (alphabetical) and after (activated debugger at the top)
If an extension was already activated before you tried to start debugging, then that extension's debugger will be sorted to the top. This can be useful, for example, when the extension was activated by previously running a command from that extension, or opening a file of a language that activates that extension, or by a workspaceContains pattern that your workspace matches. If you have used the debugger in this session, it will also be sorted to the top.
The Chrome/Edge debuggers have been renamed to Web App (Chrome) and Web App (Edge) to try to avoid confusion with other debuggers such as the Flutter extension that also run apps in a browser.
Languages:
TypeScript 4.7:
VS Code now bundles TypeScript 4.7.3. This major TypeScript brings new language features including improved Control-Flow Analysis and support for ECMAScript Module Support in Node.js. It also includes new tooling features and fixes a number of important bugs!
Go to Source Definition:
One of VS Code's longest standing and most upvoted feature requests is to make VS Code navigate to the JavaScript implementation of functions and symbols from external libraries. Currently, Go to Definition jumps to the type definition file (the .d.ts file) that defines the types for the target function or symbol. This is useful if you need to inspect the types or the documentation for these symbols but hides the actual implementation of the code. The current behavior also confuses many JavaScript users who may not understand the TypeScript type from the .d.ts.
While changing Go to Definition to navigate to the JavaScript implementation of a symbol may sound simple, there's a reason why this feature request has been open for so long. JavaScript (and especially the compiled JavaScript shipped by many libraries) is much more difficult to analyze than a .d.ts. Trying to analyze all the JavaScript code under node_modules would be both slow and would also dramatically increase memory usage. There are also many JavaScript patterns that the VS Code IntelliSense engine is not able to understand.
That's where the new Go to Source Definition command comes in. When you run this command from either the editor context menu or from the Command Palette, TypeScript will attempt to track down the JavaScript implementation of the symbol and navigate to it. This may take a few seconds and we may not always get the correct result, but it should be useful in many cases.
Jumping to the implementation of the 'render' method from the react-dom library.
We're actively working on improving this feature so give it a try in your codebase and share your feedback.
Object method snippets:
Object method snippets help you quickly add methods to object literals that implement a given interface:
Completing a method signature inside an object literal
When inside an object literal, you should see two suggestions for each possible method: one that inserts just the method name and one that inserts the full signature of the method. You can also fully disable object method snippets by setting "typescript.suggest.classMemberSnippets.enabled": false or "javascript.suggest.classMemberSnippets.enabled": false.
Group aware Organize Imports:
The Organize Imports command for JavaScript and TypeScript lets you quickly clean up your list of imports. When run, it both removes unused imports and also sorts the imports alphabetically.
Go to Definition for Markdown reference links:
You can now use Go to Definition on reference links in Markdown files. This will jump from the reference to the link definition in the current file.
Expanded JSON Schema support:
The built-in JSON language service has improved the support for JSON Schema Draft 2019-09 and JSON Schema Draft 2020-12. There's no longer a warning shown when such a schema is used.
There are still some features that are not fully supported. A warning is shown when they are used by a schema. The unsupported properties are:
Subschemas with $id
$recursiveRef/Anchor (Draft 2019-09)
$dynamicRef/Anchor (Draft 2020-12)
VS Code for the Web:
Core localization support:
We've introduced the initial localization support of VS Code for the Web. VS Code is used all over the world and for many users, English is not their first language (or a language they're familiar with at all!). For years, VS Code users have been installing Language Packs from the Marketplace in order to use VS Code in a language other than English. For VS Code for the Web, we decided to take a different approach, one that is more aligned with how the web works today.
For users who set their browser to one of our core supported languages, vscode.dev will automatically apply translations in that language. The languages we support are documented in the vscode-loc repository.
Microsoft Edge Settings Languages page:
Once that is set, when you go to vscode.dev (or insiders.vscode.dev), it will be displayed in German:
vscode.dev in a browser displayed in German
Theme: Panda Theme
In the next few months, we will enable localization for extensions (both ones that ship with VS Code and ones that don't) so that extension authors can also support non-English speaking users. Stay tuned!
Remote Repositories:
When using the Remote Repositories > Continue Working On... command to clone a GitHub or Azure Repos repository locally and open it in desktop VS Code, you can now configure remoteHub.gitProtocol to always clone using http or ssh URLs.
Development Container specification:
Our development container teams across Microsoft and GitHub continue active development on the new Dev Container Specification, and this iteration had several exciting highlights.
Reference implementation:
We released an open source command-line interface (CLI) as the reference implementation for the specification. The CLI builds and starts a dev container from a devcontainer.json, and it can either be used directly or integrated into product experiences.
The CLI is available in a new devcontainers/cli repository. You can learn how to get started in its README, and read more in this blog post.
The CLI is under active development and will continue evolving to better support more scenarios, such as greater support for individual users. We'd love to hear your feedback along the way, so we've opened an issue specifically for feedback on the CLI and welcome additional issues and PRs in the repo.
Dev Container in CI:
A GitHub Action and an Azure DevOps Task are available for running a repository's dev container in continuous integration (CI) builds. This allows you to reuse the same setup that you are using for local development to also build and test your code in CI. See the devcontainers/ci README for more details.
Specification:
Active development continues on the specification, and we've published an initial version in the devcontainers/spec repository.
As with the CLI, stay tuned for further updates and progress, and we'd love to hear your feedback.
Further reading:
You can read all about development containers and the specification at https://containers.dev.
Contributions to extensions:
Python:
No interpreter discovery at startup
The Python extension now auto-triggers discovery only when:
Using Python: Select Interpreter command to choose a different interpreter.
A particular scope (workspace or global) is opened for the first time.
No Python is installed.
Since discovery isn't triggered automatically at startup, this leads to instantaneous load, and faster startup of other features like the language server. However, if the Jupyter extension is installed/enabled, discovery is still triggered by Jupyter at startup.
Enable localization
The Python extension now supports translations in all the languages that VS Code supports. We have updated the way we get the translations of our commands, notifications, titles, etc. using vscode-nls. These translations are maintained by a localization team to ensure that they are up to date and correct.
Jupyter:
Web extension:
We've made progress on supporting more of the core functionality in the web version of the Jupyter extension.
This month the following features were ported to the web extension:
https support
kernel completions
ipywidgets
notebook debugging
variable viewing
exporting
interactive window
If you'd like to experiment with the functionality, launch Jupyter from your local machine with:
jupyter notebook --no-browser --NotebookApp.allow_origin_pat=https://.*.vscode-cdn.net
And then connect to it using the command Jupyter: Specify Jupyter server for connections from within vscode.dev.
For more information (and to comment), see this discussion item.
Remote Development:
Work continues on the Remote Development extensions, which allow you to use a container, remote machine, or the Windows Subsystem for Linux (WSL) as a full-featured development environment.
You can learn about new extension features and bug fixes in the Remote Development release notes.
GitHub Pull Requests and Issues:
There has been more progress on the GitHub Pull Requests and Issues extension, which allows you to work on, create, and manage pull requests and issues. Highlights of this release include:
Auto-merge checkbox in Create Pull Request view
Check out the changelog for the 0.44.0 release of the extension to see the other highlights.
Remote Repositories extensions:
Both the GitHub Repositories and Azure Repos extensions support translations in all languages that VS Code supports.
Preview features:
Markdown link validation:
While working with Markdown, it's easy to mistakenly add an invalid file link or image reference. Perhaps you forgot that the filename used a - (dash) instead of an _ (underline), or perhaps the file you are linking to was moved to a different directory. Often you only catch these mistakes after viewing the Markdown preview or even after publishing. VS Code's new experimental Markdown link validation can help catch these mistakes.
With link validation, VS Code will analyze Markdown links to headers, images, and other local files. Invalid links will be reported as either warnings or errors.
A warning shown in the editor when linking to a file that does not exist
VS Code can even catch invalid links to specific headers in other Markdown files!
Link validation is off by default. You can try link validation by setting "markdown.experimental.validate.enabled": true.
There are a few settings you can use to customize link validation:
markdown.experimental.validate.fileLinks.enabled - Enable/disable validation of links to local files: [link](/path/to/file.md)
markdown.experimental.validate.headerLinks.enabled - Enable/disable validation of links to headers in the current file: [link](#_some-header)
markdown.experimental.validate.referenceLinks.enabled - Enable/disable validation of reference links: [link][ref].
markdown.experimental.validate.ignoreLinks - A list of links that skip validation. This is useful if you link to files that don't exist on disk but do exist once the Markdown has been published.
Paste files to insert Markdown links:
We've added experimental support for pasting to insert images or file links in Markdown.
Pasting to insert an image into a Markdown file:
This requires enabling both markdown.experimental.editor.pasteLinks.enabled and "editor.experimental.pasteActions.enabled". You can currently copy files from the VS Code File Explorer. Pasting image files inserts image references while pasting normal text files inserts links to those files.
Terminal shell integration:
Shell integration (enabled with the terminal.integrated.shellIntegration.enabled setting) and command decorations have been polished and improved upon this iteration.
A few of the updates include:
146377 Persist shell status such that bash-git-prompt and other programs work
148635 Allow the use of a custom ZDOTDIR for zsh
145801 Fix decorations getting out of sync on slower machines
146873 Improve handling of existing debug traps in bash
148839 Polish messaging with How does this work? command and activation status in the tab hover
151223 After buffer clear, ensure commands are tracked correctly
Window Controls Overlay on Windows:
We've adopted the API provided by Electron to support Window Controls Overlay on Windows. The major user-facing benefit of this change is access to the Snap Layouts feature in Windows 11. Due to some persistent issues, the Window Controls Overlay is off by default, but you can turn them on with the experimental setting window.experimental.windowControlsOverlay.enabled.
Hover over the maximize/restore window control to see Windows 11 Snap layouts
Command Center:
We are adding Command Center - a simpler way to trigger Quick Pick for files, commands, and more.
Command Center in the VS Code title bar:
This can be enabled via the window.experimental.commandCenter setting and let us know what you think.
Merge editor:
We have started to work on a better merge experience. It is still early days and we aren't yet ready for feedback but you can give it a try via git.experimental.mergeEditor. With this enabled, files with merge conflicts open in a new merge editor to make resolving conflicts simpler.
We will continue to work on this. Use Insiders to follow our progress. We would like to sincerely thank Mingpan and our friends at Google who are helping us with this effort. ❤️
Extension authoring:
Inline Completions Finalization:
We have finalized the Inline Completions API. This allows extensions to provide inline completions that are decoupled from the suggestion widget. An inline completion is rendered as if it was already accepted, but with a gray color. Users can cycle through suggestions and accept them with the Tab key. An example extension that uses Inline Completions is GitHub Copilot. More information can be found in the vscode.d.ts file with the entrypoint into the API being languages.registerInlineCompletionItemProvider.
InputBox validation message severity finalization:
Our InputBox APIs (via window.showInputBox and window.createInputBox) to provide severity in validation of user's input has been finalized.
Notebook Editor API:
The new notebook editor API introduces a new NotebookEditor type that is similar to TextEditor but for notebooks instead of normal text editors.
const editor = vscode.window.activeNotebookEditor;
if (editor) {
// Access the underlying notebook document associated with the editor
console.log(editor.notebook.uri);
// Change the selection in the current notebook
editor.selection = new vscode.NotebookRange(1, 3);
You can use window.activeNotebookEditor to get the current notebook editor and events such as window.onDidChangeActiveNotebookEditor to observe when the user switches to the new notebook editor.
Extension activation based on Timeline view:
A new activation event has been added for when the Timeline view is visible. This event onView:timeline can be used by any extension but is most useful to extensions implementing the proposed Timeline API.
UX Guidelines:
The UX Guidelines for extension authors has been updated and expanded to cover more VS Code user interface elements.
UX Guideline example image pointing to View Actions elements
A revised Overview page steps through the VS Code UI to give a visual tour of the interface and common UI elements.
Links to relevant guides, API references, and extension samples have been added to each area's dedicated page. Additionally, all example images have been updated across the guidelines to showcase an up-to-date version of the UI.
You can now read about the recommended Do's and Don't's for extensions that add to or contribute these UI elements:
Activity Bar
Sidebars
Panel
Walkthroughs
Extension sponsorship:
In this milestone, we have introduced a sponsor field in the extension's package.json to allow extensions to opt into sponsorship. The sponsor object has a url field for the extension author's sponsorship link.
If an extension opts-in to this, VS Code will render a Sponsor button in the Extensions view Details page as shown in the Sponsoring extensions section above.
Note: Make sure to use the latest vsce command line tool (>=2.9.1) to publish your extension with sponsorship enabled.
Proposed APIs:
Every milestone comes with new proposed APIs and extension authors can try them out. As always, we want your feedback. Here are the steps to try out a proposed API:
Find a proposal that you want to try and add its name to package.json#enabledApiProposals.
Use the latest vscode-dts and run vscode-dts dev. It will download the corresponding d.ts files into your workspace.
You can now program against the proposal.
You cannot publish an extension that uses a proposed API. There may be breaking changes in the next release and we never want to break existing extensions.
Read files from DataTransfer:
The new dataTransferFiles API proposal lets extensions read files from a vscode.DataTransfer object. The DataTransfer type is used by the tree drag and drop API, as well as the drop into editor and copy paste API proposals.
Files data transfer items are currently only added to the DataTransfer when they come from outside of VS Code (such as when you drag and drop from the desktop into a tree view or into the editor).
Copy paste API:
The new documentPaste API proposal lets extensions hook into copy and paste inside text editors. This can be used to modify the text that is inserted on paste. Your extension can also store metadata when copying text and use this metadata when pasting (for example, to bring along imports when pasting between two code files).
The document paste extension sample shows this API in action:
New Notebook Workspace edit proposal:
The new notebookWorkspaceEdit API proposal allows extensions to edit the contents of a notebook. It replaces the previous notebookEditorEdit proposal.
With the proposal, you can create workspace edits that insert, replace, or modify cells in a notebook:
Engineering:
Using pull requests:
We have moved away from pushing changes directly to the vscode repository main branch and are now pushing all changes to VS Code exclusively using pull requests (PR). We require that each PR gets at least one approval from another team member. Taking advantage of this, we now also require that some basic checks pass before a PR can be merged. These are tasks like TypeScript compilation, formatting rules, unit tests and integration tests, which typically don't take longer than 10 minutes. Switching to this flow has reduced the number of times our Insiders build was broken due to a programming mistake.
VS Code OSS build:
We have a new public Code OSS build that is reusing the same build definitions as our production builds. This build now runs in under 30 minutes on each PR and we plan to continue investing in speeding it up.
Documentation:
Updated version control video:
The Using Git with Visual Studio introductory video has been redone to help you get started using the Git integration built into VS Code.
You can also find other great videos on the VS Code YouTube channel.
vscode.dev on code.visualstudio.com
Want to use VS Code for the Web but forgot the URL? vscode.dev is now displayed prominently on the VS Code Download page so you can quickly start VS Code running in your browser.
vscode.dev on the code.visualstudio.com download page
Notable fixes:
141157 Clicking F11 while not in debug mode turns on debug instead of going full screen
148864 Unbound breakpoint for TypeScript files
149638 Lazy variable evaluation button causes problematic gaps and misalignments between nodes

New in Microsoft Visual Studio Code 1.67.2 (May 18, 2022)

New in Microsoft Visual Studio Code 1.67.1 (May 10, 2022)

New in Microsoft Visual Studio Code 1.67.0 (May 5, 2022)

New in Microsoft Visual Studio Code 1.66.2 (Apr 13, 2022)

New in Microsoft Visual Studio Code 1.66.1 (Apr 10, 2022)

New in Microsoft Visual Studio Code 1.66.0 (Mar 31, 2022)

Welcome to the March 2022 release of Visual Studio Code. There are many updates in this version that we hope you will like, some of the key highlights include:
Local history - Keep track of local file changes independent of source control.
Settings editor language filter - Displays available language-specific settings.
Terminal find improvements - Matches are highlighted in the terminal panel and scroll bar.
Built-in CSS/LESS/SCSS formatters - Code formatting for CSS, LESS, and SCSS.
JavaScript heap profiles - Collect and view JS memory allocations while debugging.
VS Code for the Web - Drag and drop files and folders into vscode.dev.
Remote - SSH support for Mac - Connect via SSH to Apple Silicon/M1/ARM64 machines.
New R language topic - Learn how to use R for data science in VS Code.
ACCESSIBILITY:
The team works hard to make VS Code one of the most accessible editors available. This release contains several improvements to help usability and accessibility:
Reduce motion mode - Limit animations used in the VS Code UI.
More visible source control decorators - Higher visibility using patterns and color contrast.
Audio cues volume control - You can now adjust the editor audio cue volume.
Comment UI accessibility - New commands and keyboard shortcuts.
High Contrast Light color theme - Theme authors can now contribute colors to High Contrast Light.
WORKBENCH:
Local history:
Local history of files is now available in the Timeline view. Depending on the configured settings, every time you save an editor, a new entry is added to the list:
Each local history entry contains the full contents of the file at the time the entry was created and in certain cases, can provide more semantic information (for example, indicate a refactoring).
From an entry you can:
Compare the changes to the local file or previous entry.
Restore the contents.
Delete or rename the entry.
There are new global commands to work with local history:
workbench.action.localHistory.create - Create a new history entry for the active file with a custom name.
workbench.action.localHistory.deleteAll - Delete all history entries across all files.
workbench.action.localHistory.restoreViaPicker - Find a history entry to restore across all files.
These commands don't have default keybindings but you can add your own keyboard shortcuts.
There are also new settings to work with local history:
workbench.localHistory.enabled - Enable or disable local history (default: true).
workbench.localHistory.maxFileSize - File size limit when creating a local history entry (default: 256 KB).
workbench.localHistory.maxFileEntries - Local history entries limit per file (default: 50).
workbench.localHistory.exclude - Glob patterns for excluding certain files from local history.
workbench.localHistory.mergeWindow - Interval in seconds during which further changes are added to the last entry in local file history (default 10s).
A new filter action in the Timeline view toolbar allows you to enable or disable individual providers:
Timeline filter drop down with Git History unchecked and Local History checked
Note: Local history entries are stored in different locations depending on your use of VS Code. When opening local files, the entries are persisted in the local user data folder and when opening remote files, they will be stored on the remote user data folder. When no file system is available (for example, in certain cases when using VS Code for Web), entries are stored into IndexedDB.
Settings editor:
Language filter:
Users can now type @lang:languageId in the Settings editor search box to view and edit all settings that can be configured for the language with ID languageId. This way, users can view language-specific settings, also known as language overrides.
Note that these overrides remain configured until explicitly reset by clicking in the gear icon and resetting the setting.
The short video below has the language filter set to @lang:css to display all possible CSS language override settings.
Modification of a boolean CSS language-specific setting to turn off CodeLens in the Diff editor
Workspace and Folder settings preservation:
Workspace and folder settings in the Settings editor are now preserved until manually reset by the user. This change helps the case where the user wants to explicitly specify a workspace setting value that is equal to the default value of a setting, but is different from the user setting value. Previously, users had to open the workspace settings JSON file to set this value.
Below the editor tab size is set in Settings editor Workspace tab and it is automatically added to the workspace's settings.json file.
The editor tab size being set and reset via the Settings editor Workspace tab item
Primary notification buttons:
The first button of a notification now appears with a primary color to distinguish from other buttons. This follows the same patterns as dialogs.
Notification where first button is displayed as green primary color
New context keys for editors:
There are new context keys indicating whether an editor is the first or last in an editor group:
activeEditorIsFirstInGroup- Whether the active editor is the first one in its group.
activeEditorIsLastInGroup- Whether the active editor is the last one in its group.
These context keys can be used to conditionally enable keyboard shortcuts using when clauses.
Default binary editor:
A new setting, workbench.editor.defaultBinaryEditor, lets you circumvent the binary file warning and automatically open the editor type of your choosing when a binary file is detected. You can select the default binary editor ID from a dropdown in the Settings editor or via IntelliSense in settings.json.
Smoother authentication experiences:
You may notice smoother authentication flows of both GitHub and Microsoft.
For GitHub authentication, we've removed the initial Continue page so your log in experience requires one less step.
For Microsoft authentication, we try to minimize the number of times you are sent out of VS Code to log in, if you've already logged in with Microsoft for Settings Sync or another extension.
Install pre-release and normal extensions together from CLI:
VS Code now supports installing pre-release and normal extensions together from the command line. For example, the following command line instruction will install the pre-release version of GitHub.vscode-pull-request-github extension and release version of GitHub.remotehub extension:
code --install-extension GitHub.vscode-pull-request-github@prerelease --install-extension GitHub.remotehub
Improved platform specific extension updates:
VS Code now supports updating a platform specific extension to a more specific target platform version. For example, if you are on Windows 64-bit and have installed the C/C++ extension for Windows 32-bit and the Marketplace has the extension with same version for Windows 64-bit, VS Code will automatically update the extension to the 64-bit version.
Audio cue improvements:
The new setting audioCues.volume (0-100, default is 50) can be used to control the volume of audio cues. There is also an updated audio cue for folded regions.
New names for Side Panel and Side Bar#
Two releases ago, we introduced the Side Panel. At that time, we removed the capability to move the bottom panel that contains the terminal to the side in favor of new coherent commands. After listening to user feedback, we determined that there were important workflows that this decision broke and we decided to revert that change.
This left us with two panels, the panel and side panel, both of which could live on the side of the workbench. To account for this and better reflect the direction of the new side panel, we have decided to update the naming of both the Side Bar and Side Panel. The Side Bar will now be referred to as the Primary Side Bar in the UI, while the Side Panel will now be referred to as the Secondary Side Bar.
Side Bar -> Primary Side Bar
Side Panel -> Secondary Side Bar
These names will be reflected in menus and commands throughout the editor; however, no command IDs have been changed to prevent breaking existing keybindings.
Command Palette drop down displaying both primary and secondary focus side bar commands
Reduce motion mode:
The workbench now supports rendering with reduced animations when the OS reduced motion setting is enabled. This can be overridden or disabled with the workbench.reduceMotion setting (values are on, off, or the default auto).
Comments:
The Comments UI is used extensively by the GitHub Pull Requests and Issues extension to add comments to issues and pull requests but can be adopted by any extension.
Comments view discoverability:
When you open a file that has comments in it, the Comments view will show. This can be controlled with the setting comments.openView.
Add a comment discoverability:
Now, when you hover over any part of a line where a comment can be added on, the "+" symbol is shown in the left gutter.
Line hover showing comment plus button
Comment accessibility improvements:
There are several comments accessibility improvements:
A command Add Comment on Current Line for creating a comment if you're in a commentable range.
An aria label for comment threads, which includes the number of comments and the label of the thread.
The Go to Next Comment Thread command focuses into the comment thread control.
A new Go to Previous Comment Thread command.
Keyboard shortcuts for the next and previous commands: Alt+F9 and Shift+Alt+F9.
TERMINAL:
Display all find matches:
When searching in the terminal, all instances of the search term will now be highlighted. The currently selected match also has a specific highlight, which can be customized separately.
You can fine tune the appearance of highlight colors via the color customizations prefixed by terminal.findMatch.
A yellow border is shown around all matches except for the currently selected one, which has a red border.
Scroll bar annotations:
Annotations now appear in the scroll bar of the terminal to indicate points of interest in the buffer.
For example, find results have corresponding annotations in the scroll bar.
The terminal scroll bar displaying brown annotations for find matches within a file
When the preview feature of shell integration is enabled, an annotation is displayed in the scroll bar for each command that gets run.
Commands are run and corresponding annotations appear in the scroll bar
Command navigation improvements:
A little known feature that's been around for a while is the ability to quickly navigate between commands in the terminal. Originally this was based on when Enter was pressed but now when shell integration is enabled, it will be upgraded to use the shell integration knowledge to more reliably identify the correct lines. Additionally, UI feedback is now shown when jumping between commands.
A rectangle is briefly displayed around the command being navigated to
This feature can be accessed via the following keybindings:
macOS: Cmd+Up/Down
Linux/Windows: Ctrl+Up/Down (new)
The Shift key can be held down to make selections between commands in the terminal.
Copied text retains HTML styling#
To copy rich text from the terminal, run the Terminal: Copy text as HTML command or use the terminal context menu entry Copy text as HTML.
SOURCE CONTROL:
Source Control Repositories view:
Previously, the repositories in the Source Control Repositories view have been sorted as they were being discovered when opening a folder/workspace with multiple repositories. This was problematic as the discovery order can vary and repositories appeared to be in random order. This milestone, repositories are always sorted by name in the Source Control Repositories view.
EDITOR:
Quick suggestions as inline completions:
The editor.quickSuggestions setting now accepts inline as configuration value. When set to inline, quick suggestions (IntelliSense) don't display the suggestions widget when you type but show completions as ghosted text.
Inline completions show and update as you type
Theme: GitHub Light
Snippet variables for cursor index:
There are new snippet variables: $CURSOR_INDEX and $CURSOR_NUMBER. They evaluate to the index of the respective cursor. The latter starts at 1, the former at 0. The power of these variables is in its combination with multiple cursors.
For example, the snippet below will add an ordered list item for each cursor:
"ordered_list": {
"scope": "markdown",
"prefix": "ol",
"body": [
"$CURSOR_NUMBER. $0"
"description": "Add ordered list"
Updated source control decorators:
In order to make the source control decorators more visible for accessibility, we've added a new pattern for modified lines and increased the contrast for all decorators.
Example of the modified decorator for source control
Bracket pair colorization:
There is a new setting editor.bracketPairColorization.independentColorPoolPerBracketType. When set to true, each bracket type ({ ... } or ( ... )) will use its own color pool for colorization. Thus, nested brackets of different types will have the same color.
Improved language detection:
Last iteration we added the setting workbench.editor.historyBasedLanguageDetection to configure whether to make use of a new language detection strategy that takes into consideration the file types you have opened. This setting is now enabled by default, and a new setting workbench.editor.preferHistoryBasedLanguageDetection was added to give more priority to the results from this strategy.
VS Code for the Web:
Drag and drop folders:
You can now drag and drop local files and folders into a browser window opened on vscode.dev or insiders.vscode.dev with a browser that supports the web file system access API to access the contents. This works both when dropping over the editor area as well as the File Explorer.
Drop folder into vscode.dev
Remote Repositories:
Extension refactoring:
Previously, the Azure Repos extension depended directly on the GitHub Repositories extension. Azure Repos and GitHub Repositories now depend on a common extension, Remote Repositories, which supports common workflows across GitHub and Azure Repos. All APIs previously exposed by the GitHub Repositories extension are now exposed by Remote Repositories.
Reminder to sync repository
When you reopen a repository with uncommitted changes, by default Remote Repositories does not display the latest version of your repository. We now display a dialog to manually sync your repository so that your repository stays up to date with what's on GitHub or Azure Repos. You can control this dialog using the remoteHub.uncommittedChangesOnEntry setting.
Reminder to sync your repository
Azure Repos:
This milestone we are enabling the capability to edit and commit changes to repositories that are hosted in Azure Repos. We have also added basic functionality to create, update, and open pull requests for Azure Repos.
Notebooks:
Find decorations on scroll bar:
The Find results in notebooks will now be rendered in the scroll bar:
Find decorations rendered in the scroll bar
Move focus to the interactive window:
There are two new commands for placing focus in the interactive window.
interactive.input.focus - Move focus to the input editor in the interactive window.
interactive.history.focus - Move focus to history in interactive window.
These commands don't have default keybindings but you can add your own keyboard shortcuts.
Debugging:
JavaScript debugging:
The JavaScript debugger now supports collecting and visualizing heap profiles. Heap profiles allow you to see where and how much memory is allocated over time. These have been added as an option in the Debug: Take Performance Profile command, which is also accessible via a record ⏺ button in the CALL STACK view.
Example of the Flame Chart visualizer showing a memory profile for vscode. One cell is hovered over, showing that 33KB of memory was allocated in "ipc.ts".
Languages:
CSS formatter:
The built-in CSS extension now ships with a formatter. The formatter works with CSS, LESS and SCSS. It is implemented by the JS Beautify library and comes with the following settings:
css.format.enable - Enable/disable default CSS formatter.
css.format.newlineBetweenRules - Separate rulesets by a blank line.
css.format.newlineBetweenSelectors - Separate selectors with a new line.
css.format.spaceAroundSelectorSeparator - Ensure a space character around selector separators '>', '+', '~' (for example, a > b).
The same settings also exist for less and scss.
JavaScript semantic highlighting in HTML:
We've aligned the semantic highlighting of JavaScript source in HTML files with what you see in normal .js files.
Not only does this make code colors more consistent, it also adds some important semantic information that was missing before, such as highlighting readonly types.
TypeScript 4.6.3:
VS Code now bundles TypeScript 4.6.3. This minor update fixes a few important bugs.
Markdown shorthand reference links are now clickable#
Markdown lets you can create links using a shorthand syntax in cases where the link text matches the link definition ID. For example, [my fancy link], uses the my fancy link link definition (for example, [my fancy link]: https://example.com). These shorthand links are now clickable in VS Code's editor:
Clicking a shorthand link in a Markdown file
In the editor, clicking these links navigates to the link definition. In the Markdown preview, the links instead navigate to the link destination.
reStructuredText grammar:
There is now a built-in extension for reStructuredText (rst) file syntax highlighting.
reStructuredText example showing syntax highlighting
Contributions to extensions:
Python:
Changes to the interpreter display in the Status bar
The Python extension, in order to be consistent with other languages, moved the selected Python interpreter information towards the right side in the Status bar beside the Python language status item. With the intention of cleaning up the Status bar, it's now only displayed when a Python or a settings.json file is currently open.
Python interpreter information displayed towards the right of the Status bar
New Python File command
There's now two faster ways to create empty Python files: through a new command called Python: New Python File, or through the New File... item on the Get Started page.
Pylint extension:
There is now a new Microsoft Pylint extension for linting using pylint. This extension utilizes the Language Server Protocol to provide linting support.
The Pylint extension provides additional configuration to adjust the severity levels of the issues reported via pylint.
Note: You may see two entries for the same problem in the Problems panel if you also have Pylint enabled in the Python extension. You can disable the built-in linting functionality by setting "python.linting.pylintEnabled": false.
Jupyter:
There were several improvements to the Jupyter extension this milestone.
Kernel Support:
Kernel startup was improved with:
Support for more conda environments.
Support for .env files on all platforms.
Data Viewer:
Named indexes for DataFrames and Series are now supported in the Data Viewer.
Named indexes support in Jupyter extension Data Viewer
New Jupyter notebook:
Creation of new Jupyter notebooks is now consolidated in the New File... menu.
New File... drop down with option to create a new Jupyter notebook
Remote Development:
Work continues on the Remote Development extensions, which allow you to use a container, remote machine, or the Windows Subsystem for Linux (WSL) as a full-featured development environment.
Feature highlights in 1.66 include:
"Open in Remote Container" badge - Direct users of your repo to reopen in a custom development container.
The Remote - SSH extension can now connect to remote Apple Silicon/M1/ARM64 machines.
You can learn about new extension features and bug fixes in the Remote Development release notes.
GitHub Pull Requests and Issues:
Work continues on the GitHub Pull Requests and Issues extension, which allows you to work on, create, and manage pull requests and issues. Check out the changelog for the 0.40.0 release of the extension to see the highlights.
PREVIEW FEATURES:
Terminal shell integration:
Shell integration continued to see more improvements this release mainly in the form of reliability and improvements to the decorations described in the Terminal section above.
Here are the highlights:
Command decorations are now shown in the scroll bar, similar to the editor.
Command decorations should be restored across window reloads (or detach/attach).
Better tracking of commands when resizing the terminal on Windows.
Improved handling of the Terminal: Clear VS Code command and clear shell command.
zsh right prompt support.
Handle more formats of bash's $PROMPT_COMMAND variable.
Support pwsh when PSReadLine is not enabled.
Shell initialization scripts can now opt out of shell integration by unsetting the $VSCODE_SHELL_INTEGRATION variable if there are known issues or they need special handling, even when the setting is enabled.
TypeScript 4.7 support:
This update includes initial support for the upcoming TypeScript 4.7 release. See the TypeScript 4.7 iteration plan for more details on what the TypeScript team is currently working on.
To start using the TypeScript 4.7 nightly builds, install the TypeScript Nightly extension.
Explorer file nesting:
This iteration we continued to work on support for file nesting in the Explorer. As part of this work, we polished support for moving, renaming, and deleting nested files, and added the setting explorer.experimental.fileNesting.operateAsGroup to configure whether edits to a nesting parent should be applied to its children as well.
Additionally, we extended the configuration language for file nesting to include more expansion patterns. Previously $(capture) in a child pattern would be expanded to the text consumed by a * in the parent pattern. Now, there is additional support for $(basename), $(extname), and $(dirname) in patterns. This enables patterns such as * -> $(basename).*.$(dirname) to nest all files with "added segments" under a single base file.
EXTENSION AUTHORING:
Notebook-aware document selectors:
We have finalized an addition to the vscode.DocumentSelector type. This type allows you to associate language features like Go to Definition to specific documents, it drives the UI, and also decides if the corresponding provider is asked for results. We have added a new property that allows extensions to narrow down on notebook types. For example, { language: 'python', notebookType: 'jupyter-notebook'} targets all python documents that are embedded in Jupyter notebooks.
Inlay hints can have edits:
The InlayHint type can now have an optional, lazy textEdits property. Inlay hints that have edits set to them will apply them on double-click. The textEdits should be used to make the edits that are needed to make the inlay hint obsolete. For example, double clicking a hint representing an inferred type should insert that type annotation.
Output channel with custom language ID:
In this milestone, we have finalized the createOutputChannel API to create an output channel with custom language ID. This will allow you to contribute token or syntax coloring and CodeLens features to your Output channel by passing a language ID.
Color theme kind: High Contrast Light:
Color themes can now specify hc-light as base theme (uiTheme). The base theme is used for all colors not defined by the color theme.
In the VS Code API, ColorTheme.kind can now also have value HighContrastLight.
High Contrast Light theme for color contributions:
Color contributions can now also define a High Contrast Light theme (highContrastLight). If not specified, the light color will be used as default.
NODE_MODULE_VERSION and Node.js API update:
For extension authors using native node modules, this release bumps the Node.js version from 14.16.0 to 16.13.0, which might have an impact on your module compilation depending on which API abstraction layer is used.
Desktop Remote
NODE_MODULE_VERSION / process.versions.modules 101 93
Node-API / process.versions.napi 8 8
Tree drag and drop API:
With the newly finalized TreeDragAndDropController API, extension-contributed tree views can support drag and drop. The tree view sample has an example of how to use this API.
DEBUGGER EXTENSION AUTHORING:
Support for CompletionItem.detail:
Last month, the Debug Adapter Protocol added a detail property to the CompletionItem object. This property is now supported in VS Code. You will see the detail in the suggest widget in the Debug Console.
Debug Console example displaying detail field
Language Server Protocol:
Type Hierarchy, inline values, and inlay hints support has been moved out of the proposed state to prepare for the 3.17 release. A new next version of the libraries has been published.
There is also a first version of a meta model for LSP together with the corresponding schema as a JSON schema or as TypeScript type definitions. The meta model contains the following information: specified requests and notifications together with their parameter types, return types, partial return types, and registration options. It also contains all defined structures and enums.
Debug Adapter Protocol:
We have addressed several documentation issues of the Debug Adapter Protocol:
In order to disambiguate the terminate and disconnect requests, we have improved their documentation.
The value variables has been documented for the context argument of the evaluate request. VS Code was using this undocumented value whenever the evaluate request was called in the context of the VARIABLES view. No changes are required for clients and debug adapters because the context argument is of type string and the variables value is only mentioned in the documentation.
Proposed extension APIs:
Every milestone comes with new proposed APIs and extension authors can try them out. As always, we want your feedback. Here are the steps to try out a proposed API:
Find a proposal that you want to try and add its name to package.json#enabledApiProposals.
Use the latest vscode-dts and run vscode-dts dev. It will download the corresponding d.ts files into your workspace.
You can now program against the proposal.
You cannot publish an extension that uses a proposed API. There may be breaking changes in the next release and we never want to break existing extensions.
InputBox validation message severity:
Our InputBox APIs (via window.showInputBox and window.createInputBox) provide mechanisms for validating the user's input. This iteration we are extending it with a proposed API to show severity.
For example, if you wanted to show the user an information message based on their input, your validation message can return:
Input box with 'this is an info message' severity message
Details of this proposal can be found in inputBoxSeverity.
Notebook document change events:
There is a new proposal for notebook document change events: it is available as notebookDocumentEvents and contains two events:
vscode.workspace.onDidSaveNotebookDocument fires whenever a notebook has been saved.
vscode.workspace.onDidChangeNotebookDocument fires whenever a notebook has changed. For example, when cells were added or removed, cells themselves changed, or metadata changed.
Tabs API shape finalization:
The tabs API is approaching finalization next milestone and is currently in a state where the shape will remain stable with little to no changes. The April 2022 iteration will be the last chance to provide feedback regarding the shape and features of this API. Feedback can be provided via GitHub issues. The tabs API allows for the reading of open tabs, their locations, and closing them.
Inline Completions:
We continued working on inline completions to prepare for finalization in the next couple of releases. Inline completions can now be used to suggest snippets or text-replacements (previously, only text-insertions were supported).
Drop into editor:
The proposed text editor drop API lets extensions handle drops into text editors. These drop events can come from within VS Code—such as dragging a file from VS Code's Explorer into a text editor—or can be generated by dropping a file from your operating system into VS Code.
Creating a link in a Markdown file using the proposed drop into editor API
To try the new API, you must set "workbench.experimental.editor.dragAndDropIntoEditor.enabled": true. After enabling this, you can then drop into the editor by holding down Shift while dragging and dropping.
We've included experimental support for generating links when you drop into a Markdown file. You can also see the Markdown extension's source for an example of the API in use.
Resolved/unresolved comments:
There is a new proposal for setting a resolved or unresolved state on comment threads. Comment threads that specify a state will be given additional UX treatment.
Engineering:
Electron 17 update:
In this milestone, we are excited to ship with Electron v17 in VS Code. This is a major update from our previous adoption of Electron v13 and takes advantage of the process reuse architecture from Electron. Over the past year, we have been reimplementing and gradually rolling out changes to some of our core services with respect to their interaction and lifetime associated with the workbench in preparation for this new architecture:
File Watcher
Integrated Terminal
Extension host
Search
Special thanks to everyone involved with this effort, also thanks to the community for self-hosting on Insiders and providing feedback so we can confidently ship this update.
What does this change mean for VS Code users?
Operations like switching workspaces and reloading workspaces should now be faster. With this update, we also bump our Chromium version to 98.0.4758.109 and Nodejs version to 16.13.0.
What's next:
We will continue Electron version adoption under their new release cadence. We are also actively working towards sandboxing the workbench and the next step is to improve the communication channel between the Node.js hosted service and a sandboxed workbench, which will allow us to further simplify the new architecture.
RPM package requirements list improvement:
We now calculate the dependencies needed for the rpm packages as part of our build process inspired by the work done in Chromium. This allows us to provide an up-to-date dependency list when adopting newer runtimes or native modules. We will also introduce a similar change to our debian packages in the upcoming milestone.
Support out-of-band releases for built-in extensions:
Those built-in extensions that are available in the Marketplace can now be released out-of-band and VS Code will detect the new version and update the extension. This will enable these extensions to support pre-releases as well.
Documentation:
R in VS Code:
There is a new R in Visual Studio Code topic describing R programming language support in VS Code with the R extension. The R extension includes rich language features such as code completions and linting as well as integrated R terminals and dedicated workspace, data, and plot viewers.
R Extension for Visual Studio Code details pane
Development containers blog post:
In case you missed Burke Holland's recent blog post on using dev containers to create easy to use programming environments, check out "The problem with tutorials". The blog post describes how Laravel uses pre-configured Docker containers to provide the runtime and dependencies for their PHP framework tutorials.
Notable fixes:
Debug console stops automatically scrolling sometimes when contents wrap
When debugging is started, the debug console does not work properly
Emacs usage in VS Code terminal is broken
contributes.configuration items respects "order" attribute in views only if search box empty
Glob patterns **/p* incorrectly match on /foo/ap
Settings list widget items that are not being edited don't seem to have a max width
Settings toc unable to be resized in smaller screens
Settings box can overlap setting

New in Microsoft Visual Studio Code 1.65.2 (Mar 13, 2022)

New in Microsoft Visual Studio Code 1.65.1 (Mar 9, 2022)

New in Microsoft Visual Studio Code 1.65 (Mar 7, 2022)

Welcome to the February 2022 release of Visual Studio Code:
New editor history navigation - Scope Go Back/Go Forward history to editor group or single editor.
Light High Contrast theme - Light theme for enhanced VS Code editor visibility.
New audio cues - Audio cues for warnings, inline suggestions, and breakpoint hits.
Drag and drop Problems and Search results - Drag results to new or existing editor groups.
Source Control diff editor management - Automatically close diff editors after Git operations.
Debugger lazy variable evaluation - Lazy evaluation of JavaScript/TypeScript property getters.
Preview: Terminal shell integration - Rerun terminal commands, command status decorations.
VS Code for the Web - Reopen recent local files and folders, improved Git integration.
Workbench:
New editor history navigation:
The editor history navigation feature in VS Code drives some popular commands, such as Go Back and Go Forward. Numerous feature requests accumulated over time to improve this feature and also add more capabilities. This milestone editor history navigation was rewritten from scratch to address most of these requests.
Editor group aware navigation:
Editor groups are now taken into account when navigating in the editor history. Navigating back and forward in editor history will activate and focus editors in exactly those editor groups as they were. When an editor group is removed, all associated history entries are discarded.
In the short video below, the first Go Back places the cursor in the new editor group and then the second Go Back navigation returns to the original editor group.
Editor history keeps track of appropriate editor group
New setting to scope navigation to editor group or editor:
A new setting workbench.editor.navigationScope makes it possible to scope editor history navigation to just the active editor group or even editor. Supported values are:
default: Editor navigation works across all opened editor groups and editors.
editorGroup: Editor navigation is limited to opened editors of the active editor group.
editor: Editor navigation is limited to the active editor.
If you configure the scope to editorGroup or editor, each editor group or editor will have their own navigation stack that can be navigated individually.
Notebook support:
You can now navigate between cells you have selected in any notebook. Navigation works across editors, in the same way as you can navigate between cursor locations in a text editor.
Navigation across notebook cells:
New commands to navigate edit or navigation locations:
By default, editor navigation locations are added whenever you navigate across editors but also when navigating within editors (for example, when switching notebook cells or changing selection in text editors). If you feel that too many locations are being recorded, new commands have been added that reduce locations to either:
Navigation locations - For example, when using Go to Definition.
Edit locations - Whenever an editor is changed. For example, when typing in a text editor.
You can assign your favorite keybinding to these commands to change your navigation accordingly.
Commands for edit locations:
workbench.action.navigateForwardInEditLocations - Go forward in edit locations.
workbench.action.navigateBackInEditLocations - Go back in edit locations.
workbench.action.navigatePreviousInEditLocations - Go previous in edit locations.
workbench.action.navigateToLastEditLocation - Go to last edit location (this command already existed before).
Commands for navigation locations:
workbench.action.navigateForwardInNavigationLocations - Go forward in navigation locations.
workbench.action.navigateBackInNavigationLocations - Go back in navigation locations.
workbench.action.navigatePreviousInNavigationLocations - Go previous in navigation locations.
workbench.action.navigateToLastNavigationLocation' - Go to last navigation location.
Associated context keys have been added to make assigning keybindings more powerful.
Context keys for edit locations:
canNavigateBackInEditLocations- Whether it is possible to go back in edit locations.
canNavigateForwardInEditLocations - Whether it is possible to go forward in edit locations.
canNavigateToLastEditLocation - Whether it is possible to go to the last edit location.
Context keys for navigation locations:
canNavigateBackInNavigationLocations - Whether it is possible to go back in navigation locations.
canNavigateForwardInNavigationLocations - Whether it is possible to go forward in navigation locations.
canNavigateToLastNavigationLocation - Whether it is possible to go to the last navigation location.
New layout control options:
Last milestone, we introduced the experimental layout control in the title bar (enabled by setting workbench.experimental.layoutControl.enabled to true). We have heard feedback that, while the actions in the control are useful, they require too many clicks. For that reason, we are adding several UI options for everyone to try out with the setting workbench.experimental.layoutControl.type. This setting has the following options:
menu: The previous behavior with a single button that opens a menu (default).
toggles: A new option that shows three buttons to toggle the Panel, Side Bar, and Side Panel.
both: A new option that shows the toggles followed by the menu button, which still allows you to fairly quickly access the customize layout Quick Pick.
The image below shows layoutControl.type set to both to display the three toggle buttons along with the menu dropdown.
Layout control with type set to both to show toggle buttons and menu dropdown
Light High Contrast theme:
A new Light High Contrast theme has been added to improve legibility and readability of the editor.
VS Code using Light High Contrast theme
Audio cues:
New audio cues have been added with this release, including audio cues for warnings, inline suggestions, and debugger breakpoint hits. The sounds have been tuned and the general setting audioCues.enabled has been deprecated in favor of the individual audioCues.* settings:
A screenshot of all available audio cue enablement settings
All audio cues except lineHasWarning are enabled by default for screen reader users (setting value auto).
A new audio cue command Help: List Audio Cues lists all available audio cues, lets you hear each audio cue as you move through the list, and review which cues are currently enabled.
Audio cue help command dropdown with the warning and breakpoint audio cues enabled
Drag and drop Problems and Search results#
You can now drag and drop a Problem, Search, or Reference result into the editor, opening the file and revealing the result position. This can be useful if you want to start a new editor group or drop a result into an existing editor group.
Drag and Drop problem result into the editor
Settings editor split view:
The Settings editor now uses an adjustable split view to separate the table of contents from the settings list.
Settings editor adjustable split view
Improved automatic language detection:
When the new setting workbench.editor.historyBasedLanguageDetection is enabled, untitled editors will use an improved automatic language detection algorithm that factors in your editor history and the contents of the current workspace. The new algorithm requires much less text input than before to provide detection results.
Below is an example of using this across JavaScript, TypeScript, Markdown, Python, PHP, and C++ (many more languages are supported):
Using automatic language detection for several programming languages
Theme: GitHub Light + HC Customizations
Improved language extension recommendations:
Language feature extension recommendations now take into consideration other prominent language extensions in the Marketplace while recommending. For example, VS Code does not recommend the Java Extension Pack if you have the Apache NetBeans Java extension installed.
Keyboard shortcut for extension tree hovers:
You can trigger the hover to show in custom tree views that are contributed by extensions by using the keyboard shortcut Ctrl/Cmd+K, Ctrl/Cmd+I.
Editor:
Surround With Snippet:
There is a new command to surround the current selection with a snippet. Select some text, invoke the Surround With Snippet command from the Command Palette (Ctrl+Shift+P), and select a snippet from the dropdown.
In the short video below, a selected method is surrounded by a try/catch snippet.
Running the Surround With Snippet command, accepting the try/catch snippet
Any applicable snippet that uses the TM_SELECTED_TEXT or SELECTION variables will be available in the Surround With Snippet Quick Pick dropdown. Custom user or project snippets are also included.
Accessible inlay hints:
Inlay hints show additional information within source code, like the inferred type of a variable. For screen reader users, there is a new command to help with this feature. Select Read Line With Inlay Hints from the Command Palette and the editor will read the current line interleaved with its hints.
Contextual Unicode highlighting:
To report fewer false positives, ambiguous and invisible Unicode characters are no longer highlighted if the surrounding characters visually indicate a non-ASCII script. Thus, in trusted workspaces, only characters that are invisible or can be confused with ASCII characters are highlighted. The exception to this is those characters that are contained in a word of non-ASCII characters, where at least one character cannot be confused with an ASCII character.
Before you can see multiple false positives in the const string:
Screenshot of text with many false positives and one true positive
After only the confusing character is highlighted:
Screenshot of text with only one true positive
Terminal:
Multi-line paste warning:
A dialog now shows by default when pasting multiple lines in terminals when the shell does not support multi-line. This warning is displayed for bracketed paste mode and for PowerShell when we hand off Ctrl+V directly to the shell. There is a Do not ask me again checkbox on the dialog to easily disable the feature.
Terminal link improvements:
The implementation for terminal links had a large refactor this release. This simplified and improved maintainability of the feature but also brought:
Link highlights work again.
Caching of resolved links, reducing latency for certain links to show up.
Workspace Search links are now handled by the same code as validated links, for more consistency and improving line/column recognition.
Several bug fixes.
Open file link command improvements:
The Open Last File Link and Open Detected Link... commands introduced last version now exclude folders, which should make them more useful.
Source Control:
Diff editor management:
This milestone we have made changes that should help with managing diff editors. There is a new command Git: Close All Diff Editors in the Command Palette that can be used to close all open diff editors. There is also a new setting, git.closeDiffOnOperation to automatically close diff editors when changes are stashed, committed, discarded, staged, or unstaged.
Git command output logging:
When executing a git command, the contents of stderr are logged in the Git output window. There is a new setting, git.commandsToLog, to specify a list of Git commands that will have the contents of stdout logged in the Git output window.
Debugging:
Lazy variables:
Accessing the value of a variable may have side-effects or be expensive. VS Code's generic debugger can now show a button for the user to fetch the variable value on demand. This is available for debug extensions that support the new "lazy" variable feature. Currently this has only been implemented by the built-in JavaScript debugger for property getters, but we expect that other debugger extensions will follow soon.
Expanding lazy variables in the debugger
Tasks:
There's a new platform independent userHome variable that you can use in tasks.
"label": "Test Home",
"type": "shell",
"command": "ls ${userHome}"
Notebooks:
Built-in output renderers update:
We moved the text, image, HTML and code renderers from the VS Code core to a built-in output renderer extension. With this change, VS Code can now search text on these output types.
In the short video below, searching for item initially has 3 results for the code cell, but can be filtered to also include the cell output.
Search keyword 'item' in code cell then also in cell output
Sticky scrolling notebook cell buttons#
The Run button and cell toolbar will now stick to the top of the screen when scrolling down a code cell. This makes them more accessible when working in a long code cell.
Notebook cell button and toolbar remain visible during scrolling
Languages:
TypeScript 4.6:
VS Code now ships with TypeScript 4.6. This update brings a number of new language features, along with tooling improvements and bug fixes. You can read more about TypeScript 4.6 on the TypeScript blog.
Syntax error reporting in JavaScript files:
Thanks to TypeScript 4.6, VS Code now reports some common syntax errors in JavaScript files. This includes parsing errors, as well as invalid redeclarations of block scoped variables:
Detecting a redeclaration of a const variable in a JavaScript file
Previously these errors were only reported when you enable semantic checking in your JavaScript.
You can disable this error reporting by setting:
"javascript.validate.enable": false
More JS/TS settings can be configured per language#
More of the JavaScript and TypeScript settings can now be configured as language-specific settings. Language-specific settings are useful if you want different settings for javascript vs javascriptreact, for example.
New language-specific enabled settings include:
javascript.preferences.quoteStyle, typescript.preferences.quoteStyle
javascript.preferences.importModuleSpecifier, typescript.preferences.importModuleSpecifier
javascript.preferences.importModuleSpecifierEnding, typescript.preferences.importModuleSpecifierEnding
javascript.preferences.jsxAttributeCompletionStyle, typescript.preferences.jsxAttributeCompletionStyle
javascript.preferences.renameShorthandProperties, typescript.preferences.renameShorthandProperties
javascript.preferences.useAliasesForRenames, typescript.preferences.useAliasesForRenames
javascript.suggest.enabled, typescript.suggest.enabled
javascript.suggest.completeJSDocs, typescript.suggest.completeJSDocs
javascript.suggest.jsdoc.generateReturns, typescript.suggest.jsdoc.generateReturns
javascript.autoClosingTags, typescript.autoClosingTags
New Lua syntax highlighting grammar#
VS Code has a new, better-maintained, Lua grammar for syntax highlighting of Lua files. The new grammar is actively maintained, fixes issues that existed in the old grammar, and supports newer Lua tokens.
VS Code for the Web:
Reopen local files and folders:
The list of recently opened local files and folders is now available when you access vscode.dev or insiders.vscode.dev with a browser that supports the web file system access API. Selecting a local file will open it in an editor and selecting a local folder will update the File Explorer to show its contents. You may be asked by the browser to confirm local file access before the contents are revealed.
Open recent folders in VS Code for the Web
Remote Repositories:
GitHub Repositories:
This milestone, merge conflict resolution was improved when editing GitHub repositories on vscode.dev and github.dev. There are now merge conflict decorations in your editor, with options to Accept Current Change, Accept Incoming Change or Accept Both Changes.
Merge conflict decorations and selecting Accept Current Change:
There is also a Stage Changes action in the Source Control view for files containing merge conflicts.
Staging merge conflicts:
Additionally, you can now easily stage and unstage all changes under a specific folder in a GitHub repository on vscode.dev and github.dev. To do so, right-click on the Source Control view and select View as Tree.
Stage all changes under a folder after setting View as Tree:
Workspace search and Find All References will now download and index a full copy of the repository by default, rather than defaulting to providing partial results as before.
There are several settings to configure this indexing feature:
remoteHub.indexing.verboseDownloadNotification - Controls whether the download notification is shown as a popup (default) or in the Status bar.
remoteHub.indexing.maxIndexSize - Controls the size limit of indexes to download. If this limit is exceeded, the download will be cancelled and partial results will be provided. You can leave this setting empty to never download repositories and always use partial results.
Azure Repos:
In this milestone, we switched Azure Repos support from using a specific Azure DevOps authentication provider to using the generic Microsoft authentication provider (used by Settings Sync). You will be prompted to log in again when you visit an Azure Repo but all of your saved changes will be persisted.
Contributions to extensions:
Hex Editor data inspector improvements:
Previously, the Hex Editor extension always displayed its Data Inspector in the Side bar, and revealed it whenever a hex editor was revealed. However, some users found this annoying, and it led to a particularly disruptive experience with its integration of a memory inspector for debuggers. Now, the Data Inspector will appear to the right side of the inspected bytes. If the editor is too narrow, the Data Inspector will be displayed inside a hover widget instead.
Image showing the Data Inspector to the right side of the hex bytes
This can be configured via the hexeditor.inspectorType setting, which can take one of three values:
aside - Show the Data Inspector to the side.
hover - Show the Data Inspector only on hover, regardless of editor width.
sidebar - Display the Data Inspector in the Side bar as before.
GitHub Pull Requests and Issues:
Work continues on the GitHub Pull Requests and Issues extension, which allows you to work on, create, and manage pull requests and issues. Check out the changelog for the 0.38.0 release of the extension to see the highlights.
Preview features:
Terminal shell integration:
Shell integration in the terminal was initially introduced in the last release and has seen many improvements this month. As a refresher, this feature allows VS Code to gain additional insights into what's happening within the terminal, which was previously largely unknown. The feature is still considered experimental and you can opt-in via the terminal.integrated.shellIntegration.enabled setting.
The biggest change this release is that commands detected by shell integration now feature decorations in the "gutter" to the left. A command decoration visually breaks up the buffer and provides access to information and actions that use shell integration capabilities. There are three types of command decorations: error, success, and default, as determined by the command's exit code.
A command succeeds and a success decoration is placed to the left of the prompt. A command fails and an error decoration is placed to the left of the prompt. A placeholder decoration is to the left of no-op commands and the current command before it's been executed.
Clicking on a decoration displays actions specific to that command in a menu, that currently include Re-run Command and Copy Output.
Command decoration context menu showing Re-run Command and Copy Output actions
Hovering over the decoration displays information about the command, such as the time since it was run and the associated exit code.
Command decoration hover displaying Show Command Actions option and information that the command executed 3 minutes ago and returned failed exit code 127
Decorations can be disabled by setting:
terminal.integrated.shellIntegration.decorationsEnabled to false. Individual icons can be configured via the terminal.integrated.shellIntegration.decorationIcon* settings and these new theme keys set the colors:
terminalCommandDecoration.successBackground
terminalCommandDecoration.errorBackground
terminalCommandDecoration.defaultBackground
Here are the other main changes:
The enablement setting has been renamed to terminal.integrated.shellIntegration.enabled.
The mechanism for enabling shell integration in all supported shells is now more reliable.
Shell integration should now work when using remote connected windows (SSH, WSL, containers).
Line continuations (for example, $PS2) should now work on all supported shells.
Commands that are "skipped" are now marked specially. For example, after using Ctrl+C or running an empty command.
The Run Recent Command and Go to Recent Directory commands now store history between sessions. Storing history can be configured via the terminal.integrated.shellIntegration.history setting.
ESLint:
The ESLint extension has preliminary support for notebook documents containing cells that can be validated with ESLint. This support is only available in the Pre-Release version of the extension.
Extension authoring:
Language status items:
We have finalized the API for language status items. This API shows language specific information for the active editor. This can be general information about the project or toolset version but can also display errors and warnings.
JSON language status item linking to schema used for validation
The API resembles the Status bar API and can be accessed via vscode.languages.createLanguageStatusItem(...). A language status item should be created with a document selector so that VS Code can show and hide it whenever the active editor changes.
Inlay Hints:
The Inlay Hint provider API is now finalized. It allows to inlay additional information with source code. The image below shows how TypeScript added an inlay hint for an inferred type.
TypeScript inferred variable type shown as inlay hint:
The API is built around the InlayHintsProvider. It provides InlayHint objects, which have a couple of interesting features:
An inlay hint can have a tooltip and a command.
The label of a hint can be composed of multiple parts, which again can have a tooltip and command.
The label parts can also have an associated source location that enables language features such as Go To Definition for this part.
Status bar focus borders:
We made it easier and more accessible to navigate the Status bar by adding focus borders to the Status bar and Status bar items.
Animation showing Status bar focus borders as the user tabs thought Status bar items
Theme authors can customize the border colors by configuring the two new theme colors:
statusBar.focusBorder: The border color of the entire status bar when focused.
statusBarItem.focusBorder: The border color the status bar items when focused.
Testing refresh action and sortText:
We've finalized our proposal to add a standard refresh handler to the TestController interface. If extensions assign a method to this property, VS Code will show a "refresh" icon in the Test Explorer view.
Additionally, the TestItem can now have a sortText attribute that controls the sort order for items which do not have a specific location in a file.
Comment timestamp:
The Comments API now let's you add a timestamp to each Comment. This timestamp is shown in the Comments widget and in the Comments view. By default, the timestamp is shown as a relative time (for example, "2 weeks ago"), but the user setting comments.useRelativeTime can be used to show an exact time instead. The hover of the timestamp will always be the exact time.
vscode-test package renamed to @vscode/test-electron
The vscode-test package has been renamed to @vscode/test-electron. Extension authors should update the entry in their extension's package.json file devDependencies, if they are including that package. The @vscode/test-electron package helps run integration tests for VS Code extensions. You can learn more at the vscode-test repository.
Updated codicons:
The following new icons were added to our codicon library:
arrow-circle-down
arrow-circle-left
arrow-circle-right
arrow-circle-up
error-small
indent
layout-activitybar-left
layout-activitybar-right
layout-centered
layout-menubar
layout-panel-center
layout-panel-justify
layout-panel-left
layout-panel-right
layout-panel
layout-sidebar-left
layout-sidebar-right
layout-statusbar
layout
newline
record-small
target
Preview of updated icons:
Icon contribution point is now final:
The icon contribution point allow extensions to define a new icon by ID, along with a default icon. The icon ID can then be used by the extension (or any other extensions that depend on the extension) anywhere a ThemeIcon can be used new ThemeIcon("iconId"), in Markdown strings ($(iconId)), and as icons in certain contribution points.
Product icon themes can redefine the icon (if they know about the icon ID).
In the example above, an extension defines two new icon IDs distro-ubuntu and distro-fedora, along with default icon definitions. The icons are defined in an icon font at the given font character.
File icon themes: Support for folder names in file associations:
In file icon themes, the associations in folderNames, folderNamesExpanded, fileNames, and fileExtensions can now also contain a folder name:
Running remotely installed web extensions in VS Code for the Web with Codespaces:
VS Code for the Web with Codespaces now supports running a remotely installed web extension in the web extension host. For example, if you have the Vim extension installed in a GitHub Codespace (via configuration in a devcontainer.json file) then Vim will be loaded in the web extension host when you open the codespace in the browser. Please read our Extension Host documentation for more information.
Note: There are currently known limitations regarding loading a web worker by such an extension. See issue for more details.
Debugger extension authoring:
Support for "important" Output events:
Recently, the Debug Adapter Protocol added an important category for the Output event. This category marks events that should stand out and not go overlooked by the user. VS Code will now show a notification popup for messages with the important category. They will also still be logged to the Debug Console.
Support for 'lazy' variables:
Some variables are dynamic and require executing code to get the value. A debug adapter may not want to retrieve their full values automatically, since doing so could have side-effects or be expensive.
Some debug adapters have addressed this problem by representing the "expensive variable" as a placeholder object that the user needs to "expand" explicitly in order to fetch the value. VS Code's built-in js-debug uses this approach for JS/TS getters:
The following screencast shows that the intermediate object makes it difficult to understand the effective data structure:
Reviewing property getter values without lazy evaluation
In this release, we have improved VS Code to render the intermediate object in a compact form with a (...) button for requesting the full value.
Reviewing property getter values with lazy evaluation triggerd by '(...)' button
A debug adapter can request this new presentation style for a variable by adding a VariablePresentationHint with a lazy property (see DAP additions). If the client does not support the lazy flag, the variable will be shown as before.
Language Server Protocol:
Another next version of the Language Server Protocol, together with the corresponding npm modules, has been published. The new version contains the following changes:
The conversion of LSP types into VS Code types and vice versa is now fully asynchronous. This change avoids the conversion of large data streams, which can block the extension host. Note that this is a breaking API change in the libraries (more information in the README.md). It does not affect the backwards compatibility of the protocol itself.
The proposed implementation for notebook documents was enhanced. It has now full middleware and provider support.
Debug Adapter Protocol:
There are several new properties added to the Debug Adapter Protocol.
The new boolean property lazy was added to the VariablePresentationHint. Clients can use the optional flag to present the variable with a UI that supports a specific gesture to fetch its value.
The new optional string property detail was added to the CompletionItem. With this human-readable string, a client can show additional information about the item, such as type or symbol information. Note that this property is not yet supported by VS Code.
Proposed extension APIs:
Every milestone comes with new proposed APIs and extension authors can try them out. As always, we want your feedback. Here are the steps to try out a proposed API:
Find a proposal that you want to try and add its name to package.json#enabledApiProposals.
Use the latest vscode-dts and run vscode-dts dev. It will download the corresponding d.ts files into your workspace.
You can now program against the proposal.
You cannot publish an extension that uses a proposed API. There may be breaking changes in the next release and we never want to break existing extensions.
Markdown hovers in Timeline items:
Items provided by a TimelineProvider can now support Markdown in the detail property, which is used to provide content for their tooltip.
Notebook aware document selectors:
The vscode.DocumentSelector type allows you to associate language features like Go to Definition to specific documents. This drives the UI and also decides if the corresponding provider is asked for results. We have added a new API proposal that allows extensions to also select notebook types. For example, { language: 'python', notebookType: 'jupyter-notebook'} targets all python documents that are embedded in Jupyter notebooks. This is the current proposal - give it a try and let us know what you think.
Output channel with custom language ID:
There are some extensions that are able to define token or syntax coloring and CodeLens features in their output channels, given that they are text documents (read-only) by themselves. Since all output channels share the same language ID, these customizations can be wrongly applied to other output channels. There was a feature request to create output channels with custom language IDs so that extension authors can define customizations by language. Hence in this milestone, we have introduced the proposal to create an output channel with a custom language ID. Please try it out and give us feedback.
MarkdownString.baseUri:
The proposed baseUri property on MarkdownString lets you specify a base URI that relative links and images in Markdown are resolved relative to. This property behaves much like the element in HTML.
If the baseUri ends with /, it is considered a directory and relative paths in Markdown are resolved relative to that directory:
const md = new vscode.MarkdownString(`[link](./file.js)`);
md.baseUri = vscode.Uri.file('/path/to/dir/');
// Here 'link' in the rendered Markdown resolves to '/path/to/dir/file.js'
If the baseUri is a file, relative paths in Markdown are resolved relative to the parent directory of that file:
const md = new vscode.MarkdownString(`[link](./file.js)`);
md.baseUri = vscode.Uri.file('/path/to/otherFile.js');
// Here 'link' in the rendered Markdown resolves to '/path/to/file.js'
New documentation:
Java GUI applications:
The new Java GUI Applications topic explains how to use the Extension Pack for Java to develop JavaFX, AWT, and Swing application in VS Code.
Notable fixes:
107748 Voice over does not read that a setting is ignored to sync
123399 Emmet doesn't add the class with tag A in jsx and html files.
141680 Searching for @tags in settings is slow
141977 Settings editor: Folder action item not handling keyup properly
142040 Improve Install Another Version action for extensions supporting pre-release.
142462 File writes can hang when write locks are not cleared up
142641 ts-node debugger not working properly in v1.64

New in Microsoft Visual Studio Code 1.64.2 (Feb 11, 2022)

New in Microsoft Visual Studio Code 1.64.1 (Feb 9, 2022)

New in Microsoft Visual Studio Code 1.64.0 (Feb 4, 2022)

Welcome to the January 2022 release of Visual Studio Code. There are many updates in this version that we hope you will like, some of the key highlights include:
New Side Panel - Display more views at once with the new Side Panel.
Settings editor search - Search now prioritizes whole word matches.
Audio cues - Hear when the cursor moves to folded regions, errors, and breakpoints.
Unicode highlighting - Avoid highlighting characters in supported languages.
Automatic terminal replies - Create automatic responses to common terminal prompts.
Notebook UI improvements - Search text in Markdown and output cells.
Debug binary data view - View and edit binary data while debugging.
Markdown path suggestions - Quickly insert relative file paths and header links.
JS/TS surround with snippets - Insert selected code inside snippets.
VS Code for the Web - Support for signed GitHub commits in vscode.dev and github.dev.
Workbench:
New Side Panel:
This milestone, we introduce the Side Panel, a new surface in the workbench opposite the Side Bar, where you can house views from the Side Bar or the bottom Panel. Unlike moving the bottom Panel to the left or the right of the editor, the new Side Panel works in addition to the bottom Panel so you can see more sets of views at once.
To use the Side Panel, you need to move some views over to it. Based on one of our most upvoted feature requests, you might want to move Outline view from the Side Bar to the Side Panel. You can do this by dragging and dropping the view into the Side Panel. If the Side Panel is not open, just like the bottom Panel, dragging a view to the edge of the editor area, will pop it open.
In the short video below, the Outline view is dragged to the right and dropped to create the Side Panel. The user can then switch views in the Side Bar (here opening the global Search view), while keeping the Outline view visible.
Moving Outline View to the Side Panel:
Alternatively, you can use the Move View command from the Command Palette, which will display a dropdown of available views. When you select a view, you can then choose the location by either creating a new Panel/Side Bar/Side Panel entry or placing the view in an existing location such as Explorer or Source Control.
Move View command view locations dropdown:
Views can be drag and dropped between the Panel, Side Bar, and Side Panel by grabbing the view icon. You can reset a view's location back to its default by right-clicking on the view icon and selecting Reset Location.
View context menu with Reset Location command:
If you'd like to reset all views back to the default layout, you can run Views: Reset View Locations from the Command Palette.
Replacing Panel location:
As mentioned above, the new Side Panel provides similar functionality as moving the Panel to the left or right, yet improves on this by not moving the entire contents of the original panel. Along with view drag and drop between panels, the new Side Panel is replacing the option to move the bottom Panel.
In light of that, we have deprecated the workbench.panel.defaultLocation setting as well as the Move Panel commands in favor of similar commands:
Move Views From Panel To Side Panel (workbench.action.movePanelToSidePanel)
Move Views From Side Panel To Panel (workbench.action.moveSidePanelToPanel)
The old Move Panel commands have been remapped to the new command that provides the similar behavior. Even with this mapping, we recommend updating your keybindings to the new commands.
Below, the entire bottom Panel is moved to the Side Panel and then back to the original Panel location.
New Panel View Commands:
Panel alignment:
Addressing another popular feature request, we have added a new layout option called Panel Alignment. This option allows you to configure how far the bottom Panel spans across your window. There are four options:
Center - This is the classic behavior. The panel spans the width of the editor area only.
Left - The panel will span from the left edge of the window to the right edge of the editor area.
Right - The panel will span from the right edge of the window to the left edge of the editor area.
Justify - The panel will span the full width of the window.
Note that with all options, the Activity Bar is considered the edge of the window.
You can configure these options in the menu under View > Appearance > Align Panel or using the new Set Panel Alignment to... commands.
Aligning the Panel with Panel alignment commands:
Customize Layout control:
With all these new layout options, we have been exploring ways to better expose layout configuration for discoverability and ease of use. That's why you might notice a new experimental Configure Layout button in your title bar. This only appears if your window.titleBarStyle setting is custom (default on Windows and macOS) and workbench.experimental.layoutControl.enabled is set to true. The button visibility is controlled by an experiment, but if you want to enable it manually, you can do so by applying these setting values in the Settings editor (Ctrl+,).
Configure Layout button on the title bar:
The contents of the menu are still being worked on, but currently you should see the ability to toggle the Side Bar, Panel, and Side Panel. Additionally, you will see an entry for a new command Customize Layout. This new command triggers a new interactive Quick Pick experience allowing you to control all aspects of layout configuration in one place.
Experimental Customize Layout control:
Try it out, and let us know if you have any feedback in issue #137633.
Settings editor:
The Settings editor search now looks for string value matches in string and enum settings when searching.
Settings editor pulling up results where the enum value matches the query
The new search algorithm also prioritizes whole word matches, which means that if one has both the Java and JavaScript extensions, the Java settings will show up first when searching "java".
Settings editor search showing Java results before JavaScript ones when searching "java"
Lastly, dropdowns (such as for files.autoSave) and list widgets (such as for files.associations) in the Settings editor now work with touchscreen devices.
Settings Sync:
Settings Sync now supports synchronizing User Tasks.
Settings Sync User Tasks:
The default Settings Sync machine names now include the browser and product names in VS Code for the Web.
Settings Sync default machine name including browser and product names
Explorer: Confirm and disable Undo:
The File Explorer has long supported an Undo stack to revert file and folder edits (rename, cut/copy/paste, move, import, etc.). Some users find this functionality unexpected, so there is now a setting to disable Undo in the Explorer (explorer.enableUndo).
Additionally, a new setting (explorer.confirmUndo) was added to configure how frequently the Explorer will prompt for confirmation when performing an Undo. By default, the Explorer will prompt more frequently than before to ensure destructive undoing doesn't accidentally happen, but this can be changed to the old behavior with the value "light", or set to "verbose" to prompt before all Undo actions.
Recording of the File Explorer under different undo configurations
Editor:
Audio cues:
Audio cues indicate if the current line has certain markers, such as errors, breakpoints, or folded text regions.
They are played when the primary cursor changes its line or the first time a marker is added to the current line. Audio cues are enabled automatically when a screen reader is attached, but can also be turned on manually by setting audioCues.enabled to on.
More audio cues are to come and we will iterate on the sound design.
Unicode highlighting improvements:
To improve the Unicode highlighting feature introduced in the November release, there are new settings to better deal with false positives.
The new setting editor.unicodeHighlight.allowedLocales can be used to allow characters that are common in one or many configured locales. By default, this includes the current VS Code display language and the current OS language. At the moment, only locales translated in vscode-loc Language Packs are supported.
The setting, editor.unicodeHighlight.includeStrings, controls whether characters in strings should be highlighted. The value is true by default but can be set to false to ignore strings.
Editor folding limit:
A new setting editor.foldingMaximumRegions allow users to change the maximum number of folding ranges that are shown in an editor. By default, the limit is 5000. Note that larger numbers can result in a reduced performance.
Editor adapts to language feature timings:
Extensions power almost all language features, including built-in features like folding regions, CodeLens, inlay hints, and semantic tokens. These features aren't triggered by user gestures but by typing, usually after a timeout. For instance, CodeLens updates as you type, and so does semantic tokens. The chosen timeout values had been fixed and more or less arbitrary. With this release, the editor adapts to the observed timings so that slower machines or network connections aren't overwhelmed with requests and faster machines are utilized better.
Terminal:
Automatic replies:
The terminal is now able to automatically reply when a specific sequence of characters is received. A good example of where this is useful is the Windows batch script message Terminate batch job (Y/N)? after hitting Ctrl+C when running a batch script. This typically just ends up causing problems for the user and so a default automatic reply was added. The terminal will now automatically reply with Y and enter (r), which makes Ctrl+C in Windows feel much better.
Pressing Ctrl+C will immediately reply to the question and return to the prompt
Theme: Sapphire
The feature was made configurable with the terminal.integrated.autoReplies setting, so you can set up custom replies for other things, but be careful when doing this, as you are sending text to the process automatically. For example, you could use it to automatically update Oh My Zsh when prompted
Enhanced VT support:
Support for Operating System Command (OSC) 4/10/11/12 escape sequences were added that enables applications to control the terminal's theme colors.
Keyboard navigable links:
Previously, link navigation in the terminal required the use of a mouse. Now, links can be opened using only the keyboard via the following commands:
Terminal: Open Last Web Link... for example, https://github.com/microsoft/vscode
Terminal: Open Last File Link... for example, /Users/user/repo/file.txt
Terminal: Open Detected Link... to view all links (web, file, word)
A Quick Pick is displayed with link results of type web, word, and file.
Source Control:
More control on repository discovery:
Based on community feedback, there are two new settings to better control the process of discovering Git repositories and accommodate more diverse folder structures.
git.repositoryScanMaxDepth - Control the depth used when scanning.
git.repositoryScanIgnoredFolders - Control the list of folders that should be ignored during scanning.
Changes list sort improvements:
A new setting (scm.defaultViewSortKey) controls the default sort key used for the changes list in the Source Control view. The choice for the sort key is also remembered for each folder/workspace.
The options are:
name - Sort changes by filename.
path - Sort changes by file path (default).
status - Sort changes by source control status.
You will need to reload the VS Code window to apply the setting change.
New Git stash command:
A new command, Git: Drop All Stashes..., was added to the Command Palette that allows users to clear all stash entries. As with any Git operation with permanent consequences, use this command with care.
Git Output - git commands execution time, and duration:
To help track down performance issues, the Git Output channel now shows the time when a git command was executed as well as the duration of the command, excluding the time it took to spawn the child process.
Notebooks:
Find text in rendered Markdown and code cell outputs:
VS Code now supports find text in the rendered view of Markdown cells and output of code cells. The feature is disabled by default as it would require rendering of all Markdown cells and outputs, which might be costly when opening a notebook. You can turn on this feature by choosing options (Markdown Preview, Code Cell Outputs) from the filter dropdown on the Find control input box.
Currently, there are some limitations when searching text in outputs. For example, you cannot search streaming/text output rendered by VS Code itself. We plan to improve this in the next iteration.
Notebook find in Markdown and outputs
Cell collapsing UI:
Notebook cells have a blue bar on the left side to indicate that they are focused. This bar is now interactive - you can click the top part to collapse the cell input, and the bottom part to collapse the output.
Cell collapse UI:
Markdown cell fold hint:
When a region of Markdown cells has been folded, a message will appear with the number of folded cells to make it more apparent that some cells are hidden.
Folded Markdown cell hint:
Cell execution hints:
We made some changes to make it more obvious when a cell is executing, and which cell is executing.
First, when a cell is executing but is not scrolled into view, a progress bar will be shown at the top of the editor pane.
Second, a new button, Go To Running Cell, is added to the notebook toolbar when a cell is executing.
Third, if code cells are visible in the outline or breadcrumbs via the notebook.outline.showCodeCells and notebook.breadcrumbs.showCodeCells settings, they will display an animated running icon when they are executing.
Notebook cell executing spinner:
Debugging:
Viewing and editing binary data:
VS Code's generic debugger now supports viewing and editing binary data (aka "memory"). Variables for which memory viewing and editing is available show an inline binary icon in the Variables view, and selecting it opens the Hex Editor:
Binary data shown for a variable during a debug session
Memory viewing and editing relies on the memory-related features of the Debug Adapter Protocol and debug extensions have to implement these features in order to enable the corresponding UI in VS Code. For details, see section Debugger extension authoring below. In this release, only the built-in JavaScript debugger supports viewing and editing of binary data, but we expect other debug extensions to follow soon.
JavaScript debugging:
Exclude callers from pausing at breakpoints
Sometimes you might set a breakpoint or add a debugger statement, but only want to pause when called from a certain code path. DOM event handlers like mousemove are a good example for this. In this release, the JavaScript debugger added the ability to "exclude a caller" from pausing at a breakpoint or debugger statement.
When paused at a location, you can right-click on a frame in the CALL STACK view and choose the Exclude Caller command. A new EXCLUDED CALLERS view will be shown to allow you to view and manage excluded callers, and afterwards your program won't pause at a breakpoint location if the excluded caller appears anywhere in its call stack.
Selecting the Exclude Caller command and displaying the Excluded Callers view
Edge support on Linux
Microsoft Edge debugging is now available on Linux, via the edge debug type.
Languages:
Markdown path IntelliSense:
The built-in Markdown extension now includes path IntelliSense for links and images.
Path suggestions in a Markdown link:
The paths suggestions work similarly to path IntelliSense in CSS and HTML files. Paths starting with / are resolved relative to the current workspace, while paths staring with ./ or without any prefix are resolved relative to the current file. Path suggestions are automatically shown when you type / or can be manually invoked by using Ctrl+Space.
Path IntelliSense can also help you link to headers within the current file or within another Markdown file. Start the path with # to see completions for all the headers in the file (depending on your settings, you may need to use Ctrl+Space to see these):
Header section suggestions in a Markdown link
You can disable path IntelliSense with "markdown.suggest.paths.enabled": false.
Markdown strikethrough support#
VS Code now supports rendering ~~strikethrough~~ text in both the Markdown editor and in the built-in Markdown preview:
Strikethrough rendering the Markdown editor and preview
Strikethroughs are written by wrapping text in two tilde characters.
While all of VS Code's built-in themes support strikethroughs, some themes from the Marketplace may require an update to properly render strikethrough text in the editor.
TS 4.5.5:
VS Code now bundles TypeScript 4.5.5.:
This minor update fixes a few important crashes and tooling bugs.
Surround with snippets for JS/TS:
Many of the JavaScript and TypeScript snippets have been updated to support surrounding selected text.
Surrounding selected code with an if statement
To use surround with, first select some text and then run Insert Snippet. Instead of replacing the selected text, snippets such as if or forof will now use the selected text as the body of the new statement.
HTML auto insert quotes after equals:
When typing = after a property in HTML, the language service now automatically inserts quotes and places the cursor between the quotes. The setting html.completion.attributeDefaultValue lets you specify what type of quotes (single or double) and by default uses double quotes.
The feature can be disabled by setting "html.autoCreateQuotes": false.
JSON Clear schema cache command:
A new command Clear schema cache clears the cache of previously downloaded schemas.
LaTeX support:
LaTeX basic language support has been added. This includes syntax highlighting and auto-closing pairs.
VS Code for the Web:
Remote Repositories:
GitHub Repositories
Commits created in VS Code for the Web are now signed and marked as Verified in the GitHub UI. Additionally, maintainers can now commit to pull requests submitted from forks when using VS Code for the Web. This is thanks to the new GitHub GraphQL createCommitOnBranch API.
Make verified commits and commit to pull requests from forks in VS Code for the Web
Additionally, the Source Control view now supports multiple selection.
Stage multiple selected changes with a single click
Theme: One Monokai
Previously, creating empty commits was only supported after cloning your GitHub repository to a local or remote machine. You can now also create empty commits in VS Code for the Web using the GitHub Repositories: Commit Empty command.
A new configuration was also added to enable automatically downloading the full contents of repositories below a given size to enable advanced features like whole-repository text search and Go to Reference. The setting remoteHub.experimental.fs.maxAutoDownloadSize controls the repository size limit before a prompt will be shown on attempting to download full contents. By default, maxAutoDownloadSize is not set, in order to never download without prompting.
Azure Repos support has moved out of the GitHub Repositories extension into its own dedicated extension that can also be installed on desktop.
Adopted pre-release extensions:
VS Code for the Web now bundles pre-release versions of both the GitHub Pull Request and Issues and GitHub Repositories extensions.
PWA and offline support:
VS Code for the Web has adopted the PWA model and can now be installed as a PWA on the host OS. Thanks to that adoption, it is also now possible to enable some offline functionality. Having once visited vscode.dev or insiders.vscode.dev, users can now use it to edit local files even while offline.
Install VS Code PWA prompt
Contributions to extensions:
Python:
Improved interpreter Quick Pick
In order to make it easier to select the desired interpreter, the Python extension now groups interpreters by type in the Select Interpreter Quick Pick.
Interpreters grouped in interpreter picker
We're also experimenting with moving the active/selected interpreter in the Status bar towards the right possibly inside the language status, so check the Python status in the right side in case it isn't visible.
Add support for 'conda run'
To improve our support for Anaconda users, we have implemented support for conda run, using the --no-capture-output parameter, which does not capture output that had caused errors in the past. This feature is implemented for executing the linter, testing, and formatting functions.
There is a known bug issue #10972 that causes an error on Windows when running linting and testing with a special character in the parameters. This is due to how conda run reads parameters with special characters, so it can affect any command line arguments you have specified in your settings.json.
The Anaconda team is working on the issue and hopes to have a fix out soon. You can update your version of Anaconda on the Conda website once the new version is released.
Smart selection and better folding support
Improvements were also made for Python code selection and folding via the Pylance language server.
Selecting Python code using the keyboard takes fewer keystrokes as the semantic information of your code is taken into account when defining the selection range:
Expanding and shrinking Python code with Shift+Alt+RightArrow and Shift+Alt+LeftArrow
As for folding, previously the regions were defined just by indentation, which was not ideal for some cases, such as multi-line strings. Now folding regions take into account semantic information appropriately, and also supports #region comments:
Collapsing and expanding folding regions in Python code
Jupyter:
Remote Jupyter servers:
The Jupyter extension now no longer requires you to reload VS Code when switching between local and remote Jupyter servers. In addition, the extension now displays both local and remote kernels together in the kernel picker.
Remote Jupyter connections
Hex Editor:
The Hex Editor has undergone some significant architectural refactoring. Notably, in most cases it's now able to open files of any size without performance issues. Additionally, its layout width is now configurable, and it has a more capable Find/Replace implementation. Continued improvements will be forthcoming in future iterations.
Remote Development:
Work continues on the Remote Development extensions, which allow you to use a container, remote machine, or the Windows Subsystem for Linux (WSL) as a full-featured development environment.
You can learn about new extension features and bug fixes in the Remote Development release notes.
GitHub Pull Requests and Issues:
Work continues on the GitHub Pull Requests and Issues extension, which allows you to work on, create, and manage pull requests and issues. Check out the changelog for the 0.36.0 release of the extension to see the highlights.
Preview features:
Terminal shell integration:
The terminal now features experimental shell integration that allows VS Code to gain insights on what is going on within the terminal, which was previously unknown. When enabled using the setting "terminal.integrated.enableShellIntegration": true, arguments to run a shell integration script will be injected into your terminal profile if possible. The script itself mostly injects invisible sequences into your prompt, providing VS Code with information such as the location of the prompt, command, and command output, what the current working directory (cwd) is for each command, and the exit code of each command.
Using this information, we can enhance existing features in various ways:
Detect the cwd quickly - Previously this was only possible on macOS and Linux and would launch processes or query the file system to get that information. This now also works on Windows. The cwd is used in features like link detection and inheriting the cwd when splitting a terminal tab.
Improve the command tracking feature - This feature existed beforehand but only had default keybindings on macOS (Cmd+Up/Down) and used a naive approach to guess where lines were based on when Enter was pressed.
Shell integration enables the following new features:
Run recent command - Since we know what commands are run, we can expose a command that allows you to view and run them again in a Quick Pick. Recent commands are displayed in a Quick Pick, including information about current working directory and how long ago they were run
Go to recent directory - Similar to above, we also allow navigating to past directories. Recent directories are displayed in a Quick Pick, ordered by frequency (descending)
Link support relative to the cwd - We now know the cwd for each line in the terminal buffer, so we can support opening links in the terminal relative to the cwd at the location where it was activated. Before, when a link was clicked, a Quick Pick would open with results from any folders containing a match for that name. Now, the exact file match will be opened. in a terminal with a cwd of vscode, package.json is echoed. Clicking on the file name will result in vscode/package.json opening. The directory is changed to be the template-string-converter and then package.json is echoed. Clicking on the file name will open template-string-converter/package.json.
The goal is to turn on shell integration by default when reliability of the feature is good enough. The approach we're taking with regard to argument injection is to be as unintrusive as possible. For example, we do not modify your shell initialization scripts automatically like some terminals but instead intercept the creation of the process, inspect the arguments, and inject shell integration arguments if we are confident the terminal can run with them. The hope is to make it work well without any configuration required by the user, and to not interfere with your existing shell settings.
The current shells supported are pwsh for Windows and pwsh, bash, and zsh for Linux and macOS.
As mentioned previously, this is an experimental feature that is a little rough around the edges and there are some known issues:
$PS2 line continuations aren't supported yet. However, line continuations in pwsh do work.
Right prompts aren't supported yet.
The zsh script is known to not activate sometimes.
Remote VS Code window support is limited.
Explorer file nesting:
The Explorer now has experimental support for displaying files in the same directory in a logically nested layout. This can be helpful for visually grouping related files together and collapsing files into a "root" file to reduce clutter. Several new settings have been added to control this behavior:
explorer.experimental.fileNesting.enabled: Controls whether file nesting is enabled.
explorer.experimental.fileNesting.expand: Controls whether file nests show as expanded by default.
explorer.experimental.fileNesting.patterns: Controls how files get nested.
For example, in many repositories .ts files sit next to their derived .js, .d.ts, and/or .js.map files. While hiding derived files entirely has long been possible via files.exclude, it can be nice to have a quick way of accessing derived files, which is now possible with nests:
Below, the Explorer is using the default explorer.experimental.fileNesting.patterns configuration to nest .js and .js.map files, which are displayed when the corresponding .ts file is expanded.
Explorer with some collapsed and expanded nests
Theme: GitHub Light
Extension authoring:
Language default icons:
Language contributors can define an icon for the language.
The icon is shown if the current file icon theme only has a generic file icon for the language.
Also file icon themes like Minimal or None that do not show file icons, will not use the language icon. If a file icon theme has an icon for an extension or file name, these will be preferred.
File icon themes can customize the new behavior by defining showLanguageModeIcons: true|false in the theme file.
showLanguageModeIcons: true shows the default language icons even if the theme does not specify a file icon.
showLanguageModeIcons: false prevents that default language icons are used.
QuickPickItem separators:
Extension authors now have the ability to add separators to a Quick Pick. This is useful for grouping items or adding a bit of space between items:
Quick Pick separators:
To add a separator to your existing Quick Pick, add a new QuickPickItem to your existing list of items but specify the kind property on the QuickPickItem and set it to QuickPickItemKind.Separator.
vscode.workspace.createFileSystemWatcher now supports any path:
The existing vscode.workspace.createFileSystemWatcher API was improved to allow you to pass in any file or folder path for file watching, even if it is outside of the workspace. Previously, the file watcher was limited to the opened folders in the workspace.
Depending on the glob pattern you pass into the method, the watcher will either be recursive (for example, **/*.js) or non-recursive (*.js). Recursive watchers require more resources, so we recommend using simple glob patterns if possible.
Note: As part of this change, we made a behavioral change for existing file watchers. A file watcher that is instructed with just a glob pattern (for example, vscode.workspace.createFileSystemWatcher('**')) will no longer receive events for files that changed outside of the workspace. It will only receive file events from paths that are inside the workspace. If the user does not have an open workspace, no event will be delivered via this method anymore. This was done to ensure that extensions do not receive unexpected events from outside the workspace.
vscode.TerminalLocation:
You can specify where an extension terminal will be created with the new TerminalLocation API.
This enables creating a split terminal by providing a parentTerminal, choosing between the editor area and the panel, and more.
Cancellation token for onWill events:
The VS Code API exposes events to participate in file operations, like onWillRenameFiles. This participation can be long-running and therefore users can cancel it. With this release, user-side cancellation can be observed by extensions via a cancellation token on the corresponding event, for example FileWillRenameEvent#token. This allows extensions to cancel expensive downlevel operations as well.
Git extension APIs:
A new Repository.add method has been added, to enable the ability to stage files.
The Repository.tag and Repository.deleteTag methods were added to enable the ability to create and delete tags.
onTaskType activation event:
Extension that provide tasks can limit their unneeded activations by using the new onTaskType:foo activation event. This is an improvement over activating on onCommand:workbench.action.tasks.runTask as workbench.action.tasks.runTask is usually too eager for task providing extensions.
Debugger extension authoring:
VS Code now implements the memory-related features of the Debug Adapter Protocol#
In this release, VS Code has started to support viewing and editing binary data by supporting the following memory-related features of the Debug Adapter Protocol:
VS Code honor's the memoryReference attribute on DAP variables and announces this by passing the client capability supportsMemoryReferences to the debug adapter.
If VS Code receives the capability supportsReadMemoryRequest from a debug adapter, it will enable the UI for viewing binary data and will issue readMemory requests to retrieve the data.
If VS Code receives the capability supportsWriteMemoryRequest from a debug adapter, it will enable the UI for editing binary data and will issue writeMemory requests to store the data.
VS Code handles the memory event and announces this by passing the client capability supportsMemoryEvent to the debug adapter.
Language Server Protocol:
A new next version of the Language Server Protocol, together with the corresponding npm modules, has been published. The version contains a proposed implementation for notebook documents. The specification part can be read here.
Proposed extension APIs:
Every milestone comes with new proposed APIs and extension authors can try them out. As always, we want your feedback. Here are the steps to try out a proposed API:
Find a proposal that you want to try and add its name to package.json#enabledApiProposals.
Use the latest vscode-dts and run vscode-dts dev. It will download the corresponding d.ts files into your workspace.
You can now program against the proposal.
You cannot publish an extension that uses a proposed API. There may be breaking changes in the next release and we never want to break existing extensions.
Disable terminal persistence:
When creating a terminal, you can opt out of terminal persistence on restart and reload by setting disablePersistence in TerminalOptions or ExtensionTerminalOptions.
Inlay hint API:
This is a shout out to everyone who's interested in the inlay hints API. It is nearing completion and has added support for interactive label parts. Those allow you to bind a source code location to hints that in return enables features like code navigation. Also, commands are now supported. The latest state and development of this proposal is here: vscode.proposed.inlayHints.d.ts
Language status API:
The language status item API is planned for finalization. Please try it out and provide feedback for vscode.proposed.languageStatus.d.ts
Testing Proposals:
We're proposing an official way to implement a "refresh" handler for tests, check out vscode.proposed.testRefresh.d.ts. This will allow extensions to unify behind a standard "refresh" button in VS Code and avoid implementing their own.
Additionally, we propose that TestItem have a sortText attribute in vscode.proposed.testSortText.d.ts.
Inline completions: Automatic bracket completion
When an extension provides an inline completion item, it can set its property completeBracketPairs to true. If set, VS Code tries to repair invalid brackets in the completion text by closing or removing them, before the inline completion is shown to the user.
Tree drag and drop proposal supports dragging into the editor:
The tree drag and drop proposal is almost ready for finalization and now supports dragging from a tree view into an editor when the "resourceurls" mime type is supported by the TreeDragAndDropController. Details are available in issue #141418. Try it out and provide feedback for vscode.proposed.treeViewDragAndDrop.d.ts.
Comment timestamp:
The commenting API has a new timestamp property on Comment. Along with the API is a new setting to control how comment timestamps are displayed: comments.useRelativeTime. Please try it out and provide feedback for vscode.proposed.commentTimestamp.d.ts.
Engineering:
vscode-bisect tool:
A new tool for bisecting released VS Code Insiders versions (web and desktop) is available to help diagnose issues:
npx vscode-bisect
VS Code bisect tool
Similar to git bisect, vscode-bisect will launch a range of released Insiders builds from the past, asking whether the build reproduces the issue or not. The end result is a range of commits that introduced the issue. The instance will use a dedicated fresh folder for user data to not impact your main development environment.
Run Code Web & Server from sources:
The scripts to run VS Code for the Web and VS Code Server from sources has moved to the scripts folder:
./scripts/code-web.sh|bat starts Code for the Web (aka "serverless)" from sources and opens a browser on it. Use --help for more options.
./scripts/code-server.sh|bat starts VS Code Server from sources. Add --launch to additionally open the web UI in a browser. Use --help for more options.
./scripts/test-web-integration.sh|bat for the remote web tests.
./scripts/test-remote-integration.sh|bat for the remote tests.
Extensions:
In this milestone, we improved Marketplace interactions by minimizing the number of queries VS Code makes to the service.
Notable fixes:
91286 Throttling settings sync activity on the client
117648 The result when "gtc" is expanded with emmet with the extension sass is strange.
Non-existent debugger configuration
Hovering over setting UI links shows # at the start
Store recently opened workspaces in global storage
Opening large binary files reads full contents
Opened editor can end up empty after a file change on disk
Debug: being asked to save a file on F5
Task cannot be referenced from a launch configuration that is in a different workspace folder
Double clicking on settings.json file results in new tabs each time
Problem with the VS Code Stop Debugging API
Comment.body rendered as Markdown, even for plain strings

New in Microsoft Visual Studio Code 1.63.2 (Dec 18, 2021)

New in Microsoft Visual Studio Code 1.63.1 (Dec 14, 2021)

New in Microsoft Visual Studio Code 1.63.0 (Dec 9, 2021)

Welcome to the November 2021 release of Visual Studio Code. There are many updates in this version that we hope you will like, some of the key highlights include:
Marketplace theme preview - Try out Color Themes without installing them.
Configure Problems navigation order - Go to next error or warning by severity or file position.
Show commands in screencast mode - Display command names along with keyboard shortcuts.
Notebook improvements - Adjust Markdown font size, better file and URL linking support.
Invisible Unicode highlighting - Highlights invisible or confusable Unicode characters.
TypeScript method completions - Quickly fill in interface and override methods.
Pre-release extensions - Try out extension new features and fixes early.
New Java welcome experience - To help you configure and learn about Java in VS Code.
More extensions for vscode.dev - Check out recent additions for VS Code for the Web.
Work in a container on an SSH server - New Remote - SSH Reopen in Container command.
Workbench:
Preview themes before installing:
You can now preview themes available on the Marketplace before installing them. From the Color Themes dropdown (Ctrl+K Ctrl+T), select Browse Additional Color Themes to list the Marketplace themes. The VS Code UI will preview the Color Theme as you navigate the dropdown.
Configure Problems navigation order:
You can now define the order for Go to Next Problem (Alt+F8) and Go to Previous Problem (Shift+Alt+F8) navigation. In previous versions, the order of navigation was based on severity, going to errors first, then warnings, then the rest. The new Problems: Sort Order (problems.sortOrder) setting lets you navigate problems by either their severity or position. When using "problems.sortOrder": "position", a warning on line 5 will be shown before an error on line 13, etc.
Multiple language specific editor settings:
You can now configure language specific editor settings for multiple languages at once. The following example shows how you can customize settings for javascript and typescript languages together in your settings.json file:
"[javascript][typescript]": {
"editor.maxTokenizationLineLength": 2500
Automatic 2x2 editor grid:
A true 2x2 grid editor layout was only possible using the View: Grid Editor Layout (2x2) command. Now you can get the same layout by manually splitting editors until you reach a 2x2 grid, and the grid will automatically lock into a true 2x2 layout.
Better Escape handling in lists:
Pressing Escape on lists and trees will now shrink the selection to a single element before clearing it.
Find enabled on web:
The Find control is now supported inside webviews when VS Code is running in a browser (github.dev in the example below):
Due to limitations with current browser APIs, find behaves a bit differently than it does on desktop. For example, on web, VS Code can only highlight the current find result. On desktop, all results are highlighted in the current file.
Screencast mode shows command names:
You can now choose to show command names as you trigger them via keyboard shortcuts in screencast mode. Use the Screencast Mode: Keyboard Shortcuts Format (screencastMode.keyboardShortcutsFormat) setting to configure this behavior.
Screencast mode with command names along with keystrokes
Pre release extensions:
VS Code now supports pre-release versions of extensions so you can opt in to install them and try out the latest cutting edge features from extensions. VS Code shows an additional Install Pre-Release Version option in the extension Install drop-down menu for installing the pre-release version.
Pre-Release install dropdown:
Theme: GitHub Light Theme:
Once installed, an indicator makes it clear if you are using the pre-release version of an extension:
Pre-Release version indication:
Theme: GitHub Light Theme:
If there is a pre-release version of an extension that you have already installed, you can easily switch to it:
Switch to Pre-Release version button:
Theme: GitHub Light Theme
Updated Find actions:
The Find actions in the Search view now use the same style as Find actions in the editor:
Find actions in both the Search view and the editor
Source Control:
Ignore trim whitespace in quick diff:
You can now configure the SCM quick diff feature displayed in the left gutter to ignore trim whitespace, using the scm.diffDecorationsIgnoreTrimWhitespace setting.
Notebooks:
Adjust the font size in notebooks:
The new notebook.markup.fontSize setting lets you control the font size of notebook Markdown content. The default for this setting is 120% of the current editor font size.
Syntax highlighting in Markdown cells:
VS Code now supports syntax highlighting of fenced codeblocks inside Markdown cells:
A fenced code block in a notebook with syntax highlighting
File links in notebooks:
Markdown inside notebooks can now link to other files in the current workspace:
File links in a Jupyter notebook
Links the start with / are resolved relative to the workspace root. Links that start with ./ or just start with a filename are resolved relative to the current notebook.
Bare http(s) links notebooks:
In addition, Markdown text that includes http or https is now automatically turned into a link:
A link automatically created from Markdown text
This matches the behavior of other notebook renderers, such as JupyterLab.
Dynamic visibility of notebook toolbar labels:
The notebook toolbar can decide if the label for an action should be visible based on the width of the editor group, by setting notebook.globalToolbarShowLabel to dynamic. It will hide labels from the right-most action groups first and then the left side ones. If the editor group is still too narrow when all labels are hidden, the actions will be moved into an overflow menu.
Show and hide notebook toolbar labels dynamically
The other values for notebook.globalToolbarShowLabel are now always and never.
Editor:
Unicode highlighting:
All uncommon invisible characters in source code are now highlighted by default:
Unicode Highlighting Example: Invisible character is highlighted with hover explanation
In addition, characters that can be confused with ASCII characters are also highlighted:
Unicode Highlighting Example: Confusing character is highlighted with hover explanation
You can read "The Invisible JavaScript Backdoor" blog post or this University of Cambridge article for how invisible or confusable Unicode characters can be used in Unicode spoofing attacks.
Note that this feature does not detect all possible Unicode spoofing attacks, as this depends on your font and locale settings. Also, the detection of ambiguous characters is done heuristically. To be on the safe side, VS Code's Workspace Trust Restricted Mode should be used to review source code, as all non-ASCII characters are highlighted in untrusted workspaces.
The settings editor.unicodeHighlight.invisibleCharacters, editor.unicodeHighlight.ambiguousCharacters, or editor.unicodeHighlight.nonBasicASCII can be set to false to disable the corresponding feature.
Individual characters can be excluded from being highlighted and characters in comments or text with the following settings:
editor.unicodeHighlight.allowedCharacters - List of specific characters not to be highlighted.
editor.unicodeHighlight.includeComments - Enable highlighting characters in comments.
In addition, Markdown documents are not highlighted by default.
Multiple hover providers:
When having multiple hover providers for a document, the hover will now display as soon as one of the providers has returned a result and it will update with the rest of the providers results, as they come in:
Tasks:
automationProfile setting:
The old settings terminal.integrated.automationShell.* have been deprecated and new terminal.integrated.automationProfile.* settings have been added. This allows for greater freedom in specifying properties of terminals used for tasks, including shell, icon, color, and shell argument.
gulpfile.ts support:
The built-in gulp extension now supports detecting tasks from gulpfile.ts files.
NPM Scripts view improvements:
The NPM scripts view shows more details about the scripts.
NPM Scripts view with script details
There is also a new setting npm.scriptExplorerExclude, which allows you to specify scripts to exclude from the NPM Scripts view.
Languages:
TypeScript 4.5:
VS Code now ships with TypeScript 4.5. This update brings a number of new language features, along with tooling improvements and bug fixes.
You can read more about TypeScript 4.5 on the TypeScript blog.
Method signature completions:
Method signature completions let you quickly override methods and implement interface methods. With this feature, when you are inside a class body, suggestions for methods—such as those from a super class—insert the entire signature of the method when accepted:
Completing method signatures in TypeScript
If you're writing TypeScript, accepting the suggestion also adds all the necessary imports for types referenced in the signature.
This feature requires TypeScript 4.5 in the workspace and can be enabled/disable using typescript.suggest.classMemberSnippets.enabled and javascript.suggest.classMemberSnippets.enabled.
JSX attribute completions:
When completing JSX attributes in JavaScript and TypeScript, VS Code will now automatically insert the attribute value:
Completing JSX attribute values:
The behavior of these completions can be configured using javascript.preferences.jsxAttributeCompletionStyle and typescript.preferences.jsxAttributeCompletionStyle.
Possible settings values are:
auto - Infer the attribute style based on its type. Strings use attr="" while other types use attr={}.
braces - Always use braces.
None- Just complete the attribute name.
Removing of semantic highlighting for older TS versions:
This update removes support for semantic highlighting when using TypeScript 4.1 or older in your workspace.
TypeScript 4.2 added native support for semantic highlighting. On older versions, semantic highlighting was implemented as a TypeScript language plugin provided by VS Code. Removing the plugin reduces the amount of code to maintain and ship.
Markdown Preview custom editor:
You can now use the Reopen With command to make a Markdown file be shown as a Markdown preview instead of text:
Switching an editor tab to a Markdown preview
Unlike the Markdown: Open Preview command, Reopen With does not open a new editor tab, instead it changes how an already opened editor tab is displayed. Use Reopen With again to switch the file back to the default text view.
Additionally, you can now configure VS Code to automatically open any Markdown file as a preview using the workbench.editorAssociations setting:
"workbench.editorAssociations": {
"*.md": "vscode.markdown.preview.editor"
Markdown Preview incremental updating:
The built-in Markdown preview now more intelligently updates itself as you type. Instead of replacing the entire Markdown preview document for every update, the preview now uses DOM diffing to only replace the elements in the preview document that have changed. This reduces the jittering that would sometime occur while typing.
JSON language indicator:
When editing in a JSON file, there's now a language indicator {} that shows whether the content was validated against one or more JSON schemas. Hovering over the indicator shows the validation state and a link to open the schema.
JSON schema caching:
JSON schemas from the schema store (json.schemastore.org) are now cached locally. This saves network bandwidth and helps when working off-line.
Emmet Remove Tag command improvement:
The Emmet: Remove Tag command now removes the line with the tag, along with excess empty lines as applicable, when the tag is on its own line before the removal. It also re-indents the remaining lines properly now, when there are empty lines in between the tags to be removed.
Emmet Remove Tag demo removing a surrounding div element
VS Code for the Web:
Azure Repos:
This milestone we have partnered with the Azure DevOps engineering team to add a new keyboard shortcut to the Files hub in Azure Repos. When browsing a repository in the Files hub, you can press . to open the repository in https://vscode.dev.
We have also added a new entry point to your Azure Repos repository. You can now use the new Open Repository from Azure Repos... menu item under the Open Remote Repositories... menu item in the remote picker to connect to your Azure Repos repository from within https://vscode.dev.
Additionally, you can now open an Azure Repos repository using the legacy Azure DevOps URL format (for example, https://.visualstudio.com) in vscode.dev by prefixing the URL with https://vscode.dev.
Improved Remote menu:
Three additional commands now appear in the Remote menu:
Close Remote Workspace - Change the workspace to the empty one.
Download Visual Studio Code - Go to https://code.visualstudio.com/download.
Go to Repository - Open the repository on the source control host website, for example https://github.com for GitHub repositories.
Contributions to extensions:
Java:
The Extension Pack for Java now has an in-product welcome experience to help you configure and learn about Java in VS Code. The walkthroughs cover installing the Java runtime and useful frameworks, opening and debugging your project, and running tests directly inside VS Code.
Extension Pack for Java walkthrough:
You can also check out the Java tutorials and user guides at https://code.visualstudio.com/docs/java to help get you started.
Jupyter:
Performance improvements:
There were a number of performance improvements made to the startup of Jupyter kernels, specifically Python. Users who have previously opened a notebook will see a 2x speedup when starting a kernel. Restarting Python kernels should also be faster.
For more details on the changes made to improve the performance, you can review the following issues:
Support pre-warming kernels to improve startup experience of notebooks. (#7903)
Faster activation of Python environments such as Conda. (#8342)
Avoid starting default kernel when starting jupyter. (#8185)
Avoid looking for IPyKernel when we've found it once before. (#8196)
Avoid unnecessarily searching for Jupyter packages when Jupyter runtime isn't required to start kernels. (#8350, #8352)
Improvements in handling kernel failures:
A diagnostic message along with a Quick Fix has been added to warn about the usage of !pip install when installing Python packages. The Quick Fix will help users choose the right command %pip install.
Pip install in Jupyter:
Several improvements have been made to provide better and more meaningful error messages when kernels fail to start or stop during execution. Errors are now displayed in the cells outputs along with instructions on how to fix the issue. This ensures that users are aware of the issue and can fix it, in case they miss the error displayed on the bottom right of VS Code.
Better kernel errors in Jupyter:
Python:
Limited support for untrusted and virtual workspaces:
The Python extension now has limited support for untrusted workspaces (see Workspace Trust) or is on a virtual file system (for example, if a remote GitHub repository is opened). Only partial IntelliSense is provided in such cases and other features of the extension are not available:
Hover, same file completion, and completion for built-ins like print are available, but the extension is limited to only working with your currently opened files.
For untrusted workspaces, only the Pylance language server is supported.
For virtual workspaces, only Jedi and Pylance are supported.
The language item in Status bar is updated to indicate these situations:
Limited support for Python in an untrusted workspace
Module rename refactoring:
You can now more easily rename modules with the Python and Pylance extensions. Once you rename a Python module, you'll be prompted to choose whether you'd like to change all imports and references throughout your code. If you're not sure, you can first preview what the changes will look like before you make the decision. Once you're confident, you can select Apply Refactoring or Discard Refactoring to not have the proposed changes applied.
Module rename with Pylance:
Remote Developmet:
Work continues on the Remote Development extensions, which allow you to use a container, remote machine, or the Windows Subsystem for Linux (WSL) as a full-featured development environment.
Feature highlights in 1.63 include:
You can now open a folder in a container when working on an SSH server with the Reopen in Container command.
Improved forwarded port security avoids unsafe ports.
Configurable WSL connection method lets you use wsl.exe or a socket connection to talk to the server.
Advanced container configuration videos covering how to change the default location of your project and improve performance on Windows.
You can learn about new extension features and bug fixes in the Remote Development release notes.
GitHub Pull Requests and Issues:
Work continues on the GitHub Pull Requests and Issues extension, which allows you to work on, create, and manage pull requests and issues. Check out the changelog for the 0.34.0 release of the extension to see the highlights.
Extension authoring:
Updated API proposal structure:
We have changed how API proposals are managed. Before, there was a single file that contained all proposals, vscode.proposed.d.ts. This file had grown and it was hard to tell what proposals an extension was using and if a certain proposal was already in the stable API. There is now a file per proposal.
For example:
vscode.proposed.languageStatus.d.ts - The language status item proposal.
vscode.proposed.tabs.d.ts - The editor tabs and tab groups proposed API.
Each proposal has a unique name and extensions wanting to use a proposed API need to list those names in their package.json. The enableProposedApi property in package.json is replaced by the new enabledApiProposals, which is a string array of proposal names and has IntelliSense and validation support.
IntelliSense when authoring the enabledApiProposals property
The updated flow for API proposals should be like this:
Find a proposal that you want to try and add its name to package.json#enabledApiProposals.
Use the latest vscode-dts and run vscode-dts dev. It will download the corresponding d.ts files into your workspace.
You can now program against the proposal.
A detailed migration guide and sample migrations can be found in issue #136964. Also note that the restrictions around proposed API usages haven't changed. Extensions using a proposed API cannot be published and cannot be used as-is.
Quick Pick API improvements:
This iteration, we are finalizing a couple of APIs for the QuickPick in VS Code.
QuickPickItem inline buttons:
Being able to provide rich input experiences is a goal of our extension API and using the familiarity of VS Code's Quick Pick allows for powerful yet simple UI flows. One addition is that extensions can now add buttons to individual QuickPickItems.
QuickPickItem buttons:
Clicking on a button triggers the onDidTriggerItemButton event that exists on a QuickPick object. We look forward to seeing how you use these buttons in your extensions.
Ability to keep scroll position when updating items:
Along with the ability to add buttons to QuickPickItems, you may also want to keep the scroll position when updating the items. This is a common use case for extensions who want to:
Implement a "remove this item from the list" (for example, Ctrl/Cmd + P x QuickPickItemButton).
Implement a "toggle this item in some way" (such as an "Insert Snippet" command).
Asynchronously loading items in the Quick Pick.
The keepScrollPosition property on the QuickPick object that comes back from window.createQuickPick() allows you to control whether or not the scroll position (cursorTop) in the Quick Pick moves back to the top of the list.
Authentication API improvements:
This iteration, we are finalizing several APIs related to authentication in VS Code.
Force the creation of a new session
Sometimes, when you get a session using authentication.getSession(), it may be valid for some resources but not valid for others, and by going through the sign-in flow again, this situation can be fixed.
An example is GitHub Single Sign On's Security Assertion Markup Language (SAML) support. By default, a token generated for you with repo scope will have the ability to access your own personal repositories. However, if you are in an organization with GitHub's Single Sign On turned on, you will have to explicitly grant a session the ability to access repositories in that organization.
In this example, the GitHub Authentication provider won't know the difference between a token that is properly SAML'd for what you're trying to access or not and so to rectify that behavior, you can now force the creation of a new session.
AuthenticationGetSessionOptions now has a forceNewSession property that lets you ask the user to sign in again. If you set this to true, the user will see:
Forcing sign in:
You can also specify an object with a detail string, if you want to show a more descriptive message to the user.
Silently retrieve a session if an extension has one
A common pattern we've seen is that some extensions, when they activate, will check to see if they have an authentication session available. If so, they will use it to pre-load data and do other tasks ahead of time to speed up performance later on. The downside of this was that if a user hasn't given that extension access to an authentication session, a badge would be displayed on the account menu and an item in the menu will be added asking the user to sign in.
This is fine for some cases, but in others it's not desirable and clutters the screen for the user. To help with this, there is a new property on AuthenticationGetSessionOptions called silent, which lets you ask for a session without showing any indication that the extension asked for it. That way, the extension can do what it wants if it has the ability to get a session, but if it doesn't, it doesn't pester the user.
Note: This API will only return an authenticated session if the extension has already been granted access to the session in the past (in other words, it's a "trusted extension"). An extension will never be given a session that the user didn't consent to.
Settings editor improvements:
Ordered settings:
Individual settings can now be ordered with the order field. Ordered settings always come before unordered ones within the same category, and the ordering is relative.
Ungrouped category support:
Settings can also be grouped under the main extension header instead of a specific category. To do that, set the category title of one of the categories to be the same as the extension display name.
Notice in the example below that the Conf > Language: Show Size setting is directly under the Configuration Sample header.
Settings appearing directly under the extension header
Support for number and integer objects
Objects with non-nullable number/integer values are now supported in the Settings editor.
An object setting in the Settings editor with number/integer values
New type signature for executeCommand:
In previous versions of VS Code, vscode.commands.executeCommand was typed to always return a promise of a potentially undefined value:
export function executeCommand(command: string, ...rest: any[]): Thenable;
However, not all commands can return undefined. For example, commands that return an array of items usually return an empty array instead of undefined if there are no results. In these cases, you had to use an ugly cast or add unnecessary checks to write type correct code.
To fix this, we've updated the typings for executeCommand to be more explicit:
export function executeCommand(command: string, ...rest: any[]): Thenable;
This means that if a command can return undefined, you must explicitly pass in | undefined as part of the type parameter:
vscode.commands.executeCommand('vscode.prepareCallHierarchy', ...);
This change only effects the typings of executeCommand and does not change the behavior of this function.
Updating vscode.d.ts for exactOptionalPropertyTypes:
We've updated the typings in vscode.d.ts to better support TypeScript's exactOptionalPropertyTypes strictness option. This work included:
Clarifying which optional properties can be assigned undefined.
Being more consistent in how we use ? versus | undefined.
If you are using exactOptionalPropertyTypes with your extension, please let us know if you run into any issues with the vscode.d.ts typings.
HTML custom data from URIs:
Custom data allows users and extensions to extend the HTML language support with new HTML tags and attributes.
In this release, the HTML custom data contribution also accepts document URIs. You can use this to provide the custom data at runtime through a document from a TextDocumentContentProvider.
Configuration defaults overrides:
You can now override defaults of other registered configurations through configurationDefaults contribution point in package.json. For example, the following snippet overrides the default behavior of files.autoSave setting to AutoSave files on focus change.
"configurationDefaults": {
"files.autoSave": "onFocusChange"
Note: Configurations with application or machine scopes cannot be overridden.
Replace content in Output channel:
In this milestone, a new replace API on the OutputChannel object can replace the content in the output channel.
Timeout of workspaceContains:
When using a workspaceContains: activation event with a glob pattern, VS Code starts a file name search in the workspace, looking for a file name that matches the provided glob pattern. As soon as a matching file name is found, the extension is activated. If no matching file names are found within 7 seconds, VS Code will now cancel the search and the extension will not be activated.
Publishing pre-release extensions:
VS Code now supports extension authors publishing pre-releases of their extensions through vsce by passing --pre-release flag. This means you can make your latest features available to users who chose to install pre-releases and get early feedback before the official extension release.
vsce publish --pre-release:
The VS Code Marketplace only supports major.minor.patch for extension versions and does not yet support semver pre-release tags. We therefore recommend that extensions use major.EVEN_NUMBER.patch for release versions and major.ODD_NUMBER.patch for pre-release versions. For example: 0.2.* for release and 0.3.* for pre-release. VS Code will auto update extensions to the highest version available, so even if a user opted into a pre-release version, once there is an extension released with a higher version, that user will be updated to the released version.
Language Server Protocol:
A new next version of the Language Server Protocol, together with the corresponding npm modules, has been published. Besides various minor improvements, the new version contains a proposed implementation for inline values.
Debug Adapter Protocol:
New important category for the Output event:
The Output event of the Debug Adapter Protocol is used to send the stdout and stderr streams of the debuggee as well as informational messages from the debugger to the Debug Console. This stream of messages can be a lot for a user to process and critical things can go unnoticed. For this reason, a new category important was added to the Output event, which can be used by a debug adapter to display critical messages that need to stand out and not get overlooked by the user. The important category is a hint for the client to show important information in a highly visible UI, for example as a popup notification. Since this category is a hint, clients might ignore the hint and assume the default category (console ).
Clarifications and improvements for the execution control requests:
Previously the Debug Adapter Protocol specified that all "execution control" requests (continue, next, stepIn, stepOut, stepBack, reverseContinue) operate on a single thread but that an implementation could decide to ignore the thread argument and operate on all threads. Since this fuzzy "single thread" semantics is not really useful, typically debug adapters implement something more useful:
"step" requests that step the current thread while allowing others threads to run freely by resuming them.
"continue" requests that resume all threads.
Since the current spec is impractical for execution control requests, we have changed the spec for all execution control requests (continue, next, stepIn, stepOut, stepBack, reverseContinue) so that it matches what is typically implemented.
In addition, some debug adapters have a need for an "alternative semantic" where step or continue operate only on the current thread but keep all other threads in the suspended state. For this "alternative behavior", a new optional singleThread property has been added to all execution control requests. A corresponding new capability supportsSingleThreadExecutionRequests must be used by a debug adapter to indicate to the client that the execution control requests support the singleThread property.
Proposed extension APIs:
Every milestone comes with new proposed APIs and extension authors can try them out. As always, we want your feedback. Here are the steps to try out a proposed API:
Find a proposal that you want to try and add its name to package.json#enabledApiProposals.
Use the latest vscode-dts and run vscode-dts dev. It will download the corresponding d.ts files into your workspace.
You can now program against the proposal.
You cannot publish an extension that uses a proposed API. There may be breaking changes in the next release and we never want to break existing extensions.
QuickPickItem separators:
This iteration we are introducing the ability for extensions to add separators (also known as "categories") to a Quick Pick via a proposed API (vscode.proposed.quickPickSeparators.d.ts). This is useful for grouping items or just having a bit of space between items:
Quick Pick separators:
To add a separator to your existing Quick Pick, you can add a new QuickPickItem to your existing list of items but specify the kind property on the QuickPickItem and set it to QuickPickItemKind.Separator.
In the example above, you would add the following object to your list of items:
label: 'APIs',
kind: QuickPickItemKind.Separator
If you don't specify a kind property, or you set it to QuickPickItemKind.Default, the item will be treated as a normal QuickPickItem.
You can provide feedback about this API in issue #74967.
Notable fixes:
Unable to run any tasks on a remote windows machine using openssh
Google Japanese Input (IME) on Mac - Suggestions Overlap w/ Text
Default settings deprecation warning with n breaks the json
Asking for nvm to be installed, when it is already
debug toolbar does not update if focused thread no longer exists
Cannot type Korean. Splitted self or missing
Zlib error: invalid distance too far back
I cannot save a file when there is another file with longer name
Call stack items aren't opening tabs with correct contents
Emmet does not work in js/jsx files for VS Code 1.62.2(Universal)
Perf: _removePropertiesWithPossibleUserInfo is ~10% of the cost of loading a renderer
Perf: Update editor configuration only after extensions are registered
vscode.dev can't switch branches in private repositories

New in Microsoft Visual Studio Code 1.62.3 (Nov 19, 2021)

New in Microsoft Visual Studio Code 1.62.2 (Nov 12, 2021)

New in Microsoft Visual Studio Code 1.62.1 (Nov 10, 2021)

New in Microsoft Visual Studio Code 1.62.0 (Nov 4, 2021)

Welcome to the October 2021 release of Visual Studio Code. In addition to releasing a preview of vscode.dev, we announced in the October iteration plan that we would focus on housekeeping GitHub issues and pull requests (see our issue cleanup guide). Across all of our VS Code repositories, we closed (either triaged or fixed) 4163 issues. While we closed issues, you created 2222 new issues. The main vscode repository now has 2491 open feature requests and 1246 open bugs. In addition, we closed 194 pull requests.
As in previous years, we used the live tracker from Benjamin Lannon to track our progress:
Burn down chart of VS Code issues:
Given the focus on shipping vscode.dev, not everybody on the team had cycles for clean-up, so some issue clean-up will continue in November. After housekeeping, we also addressed feature requests and community pull requests.
Watch a highlight of the new features in this version in the VS Code team's release party. You can find the recording of the event on our YouTube channel.
Visual Studio Code for the Web - vscode.dev (Preview)#
This iteration, we released a preview of Visual Studio Code for the Web. Visual Studio Code for the Web provides a zero-install experience running entirely in your browser, allowing you to quickly and safely browse source code repositories and make lightweight code changes. To get started, go to https://vscode.dev in your browser.
VS Code for the Web has many of the features of VS Code desktop that you love, including search and syntax highlighting, along with extension support to work on your codebase. In addition to opening repositories, forks, and pull requests from source control providers like GitHub and Azure Repos, you can also work with code that is stored on your local machine.
Not all extensions can run when VS Code is in the browser. Extensions that are purely declarative, such as themes, snippets, or grammars, can run unmodified in the browser. However, extensions that need to run code must be updated by the extension authors. We'd like to say thank you to the extension authors that already have published their extensions as web extensions.
WORKBENCH:
Settings editor accessibility:
We made various Settings editor accessibility improvements:
The Settings editor scrolls back to the top after performing a search, so the user does not end up midway through the search results after each search.
The settings scope switcher is accessible via keyboard.
Deprecated setting text blocks display an icon. Previously, the deprecated text was distinguished from the rest of the setting text only by color.
More UI elements within the Settings editor have the setting ID as their name.
Updated search icons:
The search icons are now the same weight and the match whole word icon was updated to be more distinguishable from the rest.
Parameter hint highlight:
VS Code now highlights the current parameter in the parameter hint and the color can be themed via editorHoverWidget.highlightForeground.
Example of a parameter hint with a highlighted word
Editor:
Improved bracket pair guides:
We continued iterating on bracket pair guides. Horizontal lines now outline the scope of a bracket pair. Also, vertical lines now depend on the indentation of the code that is surrounded by the bracket pair.
Bracket pair horizontal lines moving with text indentation
Bracket pair guides can be enabled by setting editor.guides.bracketPairs to true (defaults to false). We added a third option "active" to only show a bracket pair guide for the active bracket pair.
The new setting editor.guides.bracketPairsHorizontal controls if and when to render horizontal guides (defaults to active).
New themable colors editorBracketPairGuide.background{1,...,6} and editorBracketPairGuide.activeBackground{1,...,6} can be used to customize the color of bracket pair guides.
Customizable bracket pairs:
You can now configure bracket pairs for a specific programming language through settings. editor.language.bracketPairs can be used to configure which bracket characters should be matched. If set, editor.language.colorizedBracketPairs independently configures which bracket pairs are colorized when bracket pair colorization or bracket pair guides are enabled.
Display hovers above or below the current line:
You can now choose between displaying IntelliSense hovers above (default) or below the current line. By setting editor.hover.above to false, hovers will render below the current line.
IntelliSense hover below the current line in the editor
Unicode directional formatting characters#
To address CVE-2021-42574, VS Code now renders Unicode directional formatting characters by default.
Unicode directional formatting characters are rendered
The special rendering of these directional formatting characters can be turned off by setting editor.renderControlCharacters to false. The setting editor.renderControlCharacters is now true by default.
Extensions:
Verified extension publishers:
VS Code now shows if the domains of an extension publisher are verified by the Visual Studio Marketplace.
Verified extension publisher indicators in the Extensions view and details pane
Theme: GitHub Light Theme:
If you are an extension author, more details about how to become a verified publisher can be found in the Publishing Extensions topic.
Terminal:
New default keybindings for special characters#
The following keybindings were added that are typically supported in other terminals:
ctrl+shift+2: Inputs the null character (0x00).
ctrl+shift+6: Inputs the record separator character (0x1E).
ctrl+/: Inputs the unit separator character (0x1F).
Languages:
Configure how HTML completes attributes:
There is a new setting html.completion.attributeDefaultValue that lets you choose how values are filled in when an HTML attribute is completed:
doublequotes: The value is placed in double quotes (default)
singlequotes: The value is placed in single quotes
empty: The value is left empty
HTML value completion showing double quotes, single quotes, and left empty
Emmet improvements:
The new Emmet: Update Tag command (editor.emmet.action.updateTag) updates the placeholder with the HTML tag to be updated.
Emmet update tag command with placeholder
The extension also activates now when one tries to run any Emmet command. This change should fix an issue where some commands were not found when run from the Command Palette, while also keeping the activation event list more precise so that Emmet does not start up unnecessarily, such as in an empty workspace.
For multi-root workspaces, Emmet now sources snippets from all workspace folders, rather than just the first one. As a result, custom snippets from all workspace folders will be suggested when editing an applicable file in the workspace.
Notebooks:
Find and Replace supports capturing groups:
The Find and Replace widget in the notebook editor now supports regular expression capturing groups.
In the short video below, replace uses the first (and only) captured text ('a').
Find and Replace with capturing groups support
Better selection of output renderers and mimetypes:
Notebook cells can output multiple types of data (mimetypes) that can be rendered in different ways both by VS Code itself and extensions. Previously, VS Code had basic memoization (caching) of the selected renderer for a mimetype, and you could manually configure your preferred mimetypes using the notebook.displayOrder setting. However, VS Code wasn't particularly smart about picking the best renderer for a mimetype, and preferred mimetypes had to be updated manually.
Now, preferred renderers are cached on a per-notebook type, level in the workspace. Additionally, if you switch to view a different mimetype, that preference will be updated in-memory for the VS Code session, and you can use the Notebook: Save Mimetype Display Order command to easily update the notebook.displayOrder setting to the working preference.
Contributions to extensions:
Jupyter:
Kernels:
In order to make it easier to identify kernels, the Jupyter extension now groups kernels in the kernel picker.
Kernels grouped in kernel picker:
You can now filter the list of kernels displayed in the kernel picker, either globally or on a workspace basis. This is helpful if you have a large number of kernels installed but usually only work with a subset.
To manage the list of kernels displayed, you can use the command Jupyter: Filter Kernels from the Command Palette.
Kernel filtering via the Filter Kernels command dropdown check boxes
Automatic cell creation when running the last cells in an Interactive Window using Shift+Enter can now be configured via the setting jupyter.newCellOnRunLast. If you don't want the default behavior to add a new cell, you can set jupyter.netCellOnRunLast to false.
ESLint:
A new version of the ESLint extension has shipped. Major improvements are:
Extended support for ESLint version 8.x.
The ability to define the rule set that is applied during code action on save and format via the setting eslint.codeActionsOnSave.rules.
GitHub Pull Requests and Issues:
Work continues on the GitHub Pull Requests and Issues extension, which allows you to work on, create, and manage pull requests and issues. Check out the changelog for the 0.32.0 release of the extension to see the highlights.
Remote Development:
Work continues on the Remote Development extensions, which allow you to use a container, remote machine, or the Windows Subsystem for Linux (WSL) as a full-featured development environment.
Feature highlights in 1.62 include:
New setting remote.SSH.foldersSortOrder to sort SSH targets alphabetically or by recent use.
Windows Subsystem for Linux indicator lets you quickly know whether you are using WSL 1 or WSL 2.
Advanced container configuration videos covering how to persist bash history and work with monorepos.
You can learn about new extension features and bug fixes in the Remote Development release notes.
Preview features:
TypeScript 4.5 support:
This update adds support for the upcoming TypeScript 4.5 release. The TypeScript 4.5 beta announcement post has more information about the new language and tooling features. Some tooling highlights:
Method signature completions.
JSX attribute completions.
More accurate reference counts for the references CodeLens.
To start using the TypeScript 4.5 nightly builds, install the TypeScript Nightly extension.
Please share your feedback and let us know if you run into any bugs with TypeScript 4.5.
Extension authoring:
Emoji support in file decorations:
The file decorations API now supports emojis as badge texts.
Files decorated with emojis in the File Explorer
MarkdownString.supportHtml:
The new supportHtml property on MarkdownString enables rendering of a safe subset of raw HTML that appears inside the Markdown text.
The supportHtml property defaults to false. When disabled, VS Code will strip out any raw HTML tags that appear in the Markdown text.
Engineering:
File watching changes:
File watching in VS Code changed to a new library, thanks to the work of the Parcel team with their @parcel/watcher. We will gradually roll out this change to all users in the upcoming weeks. Linux users will be happy to learn that the files.watcherExclude now applies natively so that the number of file handles VS Code needs open for file watching can be greatly reduced.
The existing files.legacyWatcher setting was changed to an enumeration with these values:
on - The new file watcher will never be used.
off - The new file watcher will always be used.
default - The new file watcher will only be used when you open multi-root workspaces (via a .code-workspace file).
You should not notice any difference in your day to day work, but if file watching is broken for you, please report an issue.
Progress for Electron sandbox support:
As we continue to make the VS Code workbench ready for enabling Electron's sandbox, we made progress on moving Node.js file services out of the workbench window into a different process. The same is true for the file watcher that no longer forks from the workbench window, but from a background process. This change is enabled by default in VS Code Insiders and will be the default in Stable for our November release.
Notable fixes:
73061: Enumerable properties mixed with regular properties
130868: Emmet suggestions list missing entries after adding custom snippets.json
131966: Emmet unable to expand abbreviation with onclick attribute
135110: Support different border settings for vertical or horizontal layouts, for in-group editor splitting

Microsoft Visual Studio Code Changelog

What's new in Microsoft Visual Studio Code 1.88.1

New in Microsoft Visual Studio Code 1.88.0 (Apr 6, 2024)

New in Microsoft Visual Studio Code 1.87.2 (Mar 13, 2024)

New in Microsoft Visual Studio Code 1.87.1 (Mar 13, 2024)

New in Microsoft Visual Studio Code 1.87.0 (Feb 28, 2024)

New in Microsoft Visual Studio Code 1.86.2 (Feb 20, 2024)

New in Microsoft Visual Studio Code 1.86.1 (Feb 9, 2024)

New in Microsoft Visual Studio Code 1.86.0 (Feb 2, 2024)

New in Microsoft Visual Studio Code 1.85.2 (Jan 19, 2024)

New in Microsoft Visual Studio Code 1.85.1 (Dec 15, 2023)

New in Microsoft Visual Studio Code 1.85.0 (Dec 9, 2023)

New in Microsoft Visual Studio Code 1.84.2 (Nov 10, 2023)

New in Microsoft Visual Studio Code 1.84.1 (Nov 8, 2023)

New in Microsoft Visual Studio Code 1.84.0 (Nov 2, 2023)

New in Microsoft Visual Studio Code 1.83.1 (Oct 13, 2023)

New in Microsoft Visual Studio Code 1.83.0 (Oct 5, 2023)

New in Microsoft Visual Studio Code 1.82.3 (Oct 3, 2023)

New in Microsoft Visual Studio Code 1.82.2 (Sep 17, 2023)

New in Microsoft Visual Studio Code 1.82.1 (Sep 13, 2023)

New in Microsoft Visual Studio Code 1.82.0 (Sep 8, 2023)

New in Microsoft Visual Studio Code 1.81.1 (Aug 10, 2023)

New in Microsoft Visual Studio Code 1.81.0 (Aug 7, 2023)

New in Microsoft Visual Studio Code 1.80.1 (Jul 14, 2023)

New in Microsoft Visual Studio Code 1.80.0 (Jul 6, 2023)

New in Microsoft Visual Studio Code 1.79.2 (Jun 16, 2023)

New in Microsoft Visual Studio Code 1.79.1 (Jun 14, 2023)

New in Microsoft Visual Studio Code 1.79.0 (Jun 8, 2023)

New in Microsoft Visual Studio Code 1.78.2 (May 13, 2023)

New in Microsoft Visual Studio Code 1.78.1 (May 10, 2023)

New in Microsoft Visual Studio Code 1.78.0 (May 4, 2023)

New in Microsoft Visual Studio Code 1.77.3 (Apr 18, 2023)

New in Microsoft Visual Studio Code 1.77.2 (Apr 12, 2023)

New in Microsoft Visual Studio Code 1.77.1 (Apr 6, 2023)

New in Microsoft Visual Studio Code 1.77.0 (Apr 2, 2023)

New in Microsoft Visual Studio Code 1.76.2 (Mar 19, 2023)

New in Microsoft Visual Studio Code 1.76.1 (Mar 13, 2023)

New in Microsoft Visual Studio Code 1.76.0 (Mar 2, 2023)

New in Microsoft Visual Studio Code 1.75.1 (Feb 10, 2023)

New in Microsoft Visual Studio Code 1.75.0 (Feb 3, 2023)

New in Microsoft Visual Studio Code 1.74.2 (Dec 22, 2022)

New in Microsoft Visual Studio Code 1.74.1 (Dec 14, 2022)

New in Microsoft Visual Studio Code 1.74.0 (Dec 8, 2022)

New in Microsoft Visual Studio Code 1.73.1 (Nov 10, 2022)

New in Microsoft Visual Studio Code 1.73.0 (Nov 3, 2022)

New in Microsoft Visual Studio Code 1.72.2 (Oct 14, 2022)

New in Microsoft Visual Studio Code 1.72.1 (Oct 12, 2022)

New in Microsoft Visual Studio Code 1.72.0 (Oct 7, 2022)

New in Microsoft Visual Studio Code 1.71.2 (Sep 19, 2022)

New in Microsoft Visual Studio Code 1.71.1 (Sep 14, 2022)

New in Microsoft Visual Studio Code 1.71.0 (Sep 5, 2022)

New in Microsoft Visual Studio Code 1.70.2 (Aug 20, 2022)

New in Microsoft Visual Studio Code 1.70.1 (Aug 11, 2022)

New in Microsoft Visual Studio Code 1.70.0 (Aug 6, 2022)

New in Microsoft Visual Studio Code 1.69.2 (Aug 3, 2022)

New in Microsoft Visual Studio Code 1.69.1 (Jul 12, 2022)

New in Microsoft Visual Studio Code 1.69.0 (Jul 8, 2022)

New in Microsoft Visual Studio Code 1.68.1 (Jun 15, 2022)

New in Microsoft Visual Studio Code 1.68.0 (Jun 9, 2022)

New in Microsoft Visual Studio Code 1.67.2 (May 18, 2022)

New in Microsoft Visual Studio Code 1.67.1 (May 10, 2022)

New in Microsoft Visual Studio Code 1.67.0 (May 5, 2022)

New in Microsoft Visual Studio Code 1.66.2 (Apr 13, 2022)

New in Microsoft Visual Studio Code 1.66.1 (Apr 10, 2022)

New in Microsoft Visual Studio Code 1.66.0 (Mar 31, 2022)

New in Microsoft Visual Studio Code 1.65.2 (Mar 13, 2022)

New in Microsoft Visual Studio Code 1.65.1 (Mar 9, 2022)

New in Microsoft Visual Studio Code 1.65 (Mar 7, 2022)

New in Microsoft Visual Studio Code 1.64.2 (Feb 11, 2022)

New in Microsoft Visual Studio Code 1.64.1 (Feb 9, 2022)

New in Microsoft Visual Studio Code 1.64.0 (Feb 4, 2022)

New in Microsoft Visual Studio Code 1.63.2 (Dec 18, 2021)

New in Microsoft Visual Studio Code 1.63.1 (Dec 14, 2021)

New in Microsoft Visual Studio Code 1.63.0 (Dec 9, 2021)

New in Microsoft Visual Studio Code 1.62.3 (Nov 19, 2021)

New in Microsoft Visual Studio Code 1.62.2 (Nov 12, 2021)

New in Microsoft Visual Studio Code 1.62.1 (Nov 10, 2021)

New in Microsoft Visual Studio Code 1.62.0 (Nov 4, 2021)

New in Microsoft Visual Studio Code 1.61.2 (Oct 20, 2021)

New in Microsoft Visual Studio Code 1.61.1 (Oct 15, 2021)