Key Bindings for Visual Studio Code

Visual Studio Code lets you perform most tasks directly from the keyboard. This page lists out the default bindings (keyboard shortcuts) and describes how you can update them.

Note: If you visit this page on a Mac, you will see the key bindings for the Mac. If you visit using Windows or Linux, you will see the keys for that platform. If you need the key bindings for another platform, hover your mouse over the key you are interested in.

Keyboard Shortcuts editor

Visual Studio Code provides a rich and easy keyboard shortcuts editing experience using Keyboard Shortcuts editor. It lists all available commands with and without keybindings and you can easily change / remove / reset their keybindings using the available actions. It also has a search box on the top that helps you in finding commands or keybindings. You can open this editor by going to the menu under File > Preferences > Keyboard Shortcuts. (Code > Preferences > Keyboard Shortcuts on macOS)

Most importantly, you can see keybindings according to your keyboard layout. For example, key binding kbstyle(Cmd+\) in US keyboard layout will be shown as kbstyle(Ctrl+Shift+Alt+Cmd+7) when layout is changed to German. The dialog to enter key binding will assign the correct and desired key binding as per your keyboard layout.

For doing more advanced keyboard shortcut customization, read Advanced Customization.

Keymap extensions

Keyboard shortcuts are vital to productivity and changing keyboarding habits can be tough. To help with this, File > Preferences > Keymap Extensions shows you a list of popular keymap extensions. These extensions modify the VS Code shortcuts to match those of other editors so you don’t need to learn new keyboard shortcuts. There is also a Keymaps category of extensions in the Marketplace.

Tip: Click on an extension tile above to read the description and reviews to decide which extension is best for you. See more in the Marketplace.

Keyboard Shortcuts Reference

We also have a printable version of these keyboard shortcuts. Help > Keyboard Shortcut Reference displays a condensed PDF version suitable for printing as an easy reference.

Below are links to the three platform-specific versions:

• Windows
• macOS
• Linux

Detecting keybinding conflicts

If you have many extensions installed or you have customized your keyboard shortcuts, you can sometimes have keybinding conflicts where the same keyboard shortcut is mapped to several commands. This can result in confusing behavior, especially if different keybindings are going in and out of scope as you move around the editor.

The Keyboard Shortcuts editor has a context menu command Show Same Keybindings, which will filter the keybindings based on a keyboard shortcut to display conflicts.

Pick a command with the keybinding you think is overloaded and you can see if multiple commands are defined, the source of the keybindings and when they are active.

Viewing modified keybindings

You can view any user modified keyboard shortcuts in VS Code in the Keyboard Shortcuts editor with the Show User Keybindings command in the More Actions (…) menu. This applies the @source:user filter to the Keyboard Shortcuts editor (Source is ‘User’).

Advanced customization

All keyboard shortcuts in VS Code can be customized via the keybindings.json file.

• To configure keyboard shortcuts through the JSON file, open Keyboard Shortcuts editor and select the Open Keyboard Shortcuts (JSON) button on the right of the editor title bar.
• This will open your keybindings.json file where you can overwrite the Default Keybindings.

You can also open the keybindings.json file from the Command Palette (kb(workbench.action.showCommands)) with the Preferences: Open Keyboard Shortcuts (JSON) command.

Keyboard rules

Each rule consists of:

• a key that describes the pressed keys.
• a command containing the identifier of the command to execute.
• an optional when clause containing a boolean expression that will be evaluated depending on the current context.

Chords (two separate keypress actions) are described by separating the two keypresses with a space. For example, kbstyle(Ctrl+K Ctrl+C).

When a key is pressed:

• the rules are evaluated from bottom to top.
• the first rule that matches, both the key and in terms of when, is accepted.
• no more rules are processed.
• if a rule is found and has a command set, the command is executed.

The additional keybindings.json rules are appended at runtime to the bottom of the default rules, thus allowing them to overwrite the default rules. The keybindings.json file is watched by VS Code so editing it while VS Code is running will update the rules at runtime.

The keyboard shortcuts dispatching is done by analyzing a list of rules that are expressed in JSON. Here are some examples:

// Keybindings that are active when the focus is in the editor
{ "key": "home",            "command": "cursorHome",                  "when": "editorTextFocus" },
{ "key": "shift+home",      "command": "cursorHomeSelect",            "when": "editorTextFocus" },
// Keybindings that are complementary
{ "key": "f5",              "command": "workbench.action.debug.continue", "when": "inDebugMode" },
{ "key": "f5",              "command": "workbench.action.debug.start",    "when": "!inDebugMode" },
// Global keybindings
{ "key": "ctrl+f",          "command": "actions.find" },
{ "key": "alt+left",        "command": "workbench.action.navigateBack" },
{ "key": "alt+right",       "command": "workbench.action.navigateForward" },
// Global keybindings using chords (two separate keypress actions)
{ "key": "ctrl+k enter",    "command": "workbench.action.keepEditor" },
{ "key": "ctrl+k ctrl+w",   "command": "workbench.action.closeAllEditors" },

Accepted keys

The key is made up of modifiers and the key itself.

The following modifiers are accepted:

The following keys are accepted:

• kbstyle(f1-f19), kbstyle(a-z), kbstyle(0-9)
• kbstyle(`), kbstyle(-), kbstyle(=), kbstyle([), kbstyle(]), kbstyle(\), kbstyle(;), kbstyle('), kbstyle(,), kbstyle(.), kbstyle(/)
• kbstyle(left), kbstyle(up), kbstyle(right), kbstyle(down), kbstyle(pageup), kbstyle(pagedown), kbstyle(end), kbstyle(home)
• kbstyle(tab), kbstyle(enter), kbstyle(escape), kbstyle(space), kbstyle(backspace), kbstyle(delete)
• kbstyle(pausebreak), kbstyle(capslock), kbstyle(insert)
• kbstyle(numpad0-numpad9), kbstyle(numpad_multiply), kbstyle(numpad_add), kbstyle(numpad_separator)
• kbstyle(numpad_subtract), kbstyle(numpad_decimal), kbstyle(numpad_divide)

Command arguments

You can invoke a command with arguments. This is useful if you often perform the same operation on a specific file or folder. You can add a custom keyboard shortcut to do exactly what you want.

The following is an example overriding the kbstyle(Enter) key to print some text:

  { "key": "enter", "command": "type",
                    "args": { "text": "Hello World" },
                    "when": "editorTextFocus" }

The type command will receive {"text": "Hello World"} as its first argument and add “Hello World” to the file instead of producing the default command.

For more information on commands that take arguments, refer to Built-in Commands.

Removing a specific key binding rule

You can write a key binding rule that targets the removal of a specific default key binding. With the keybindings.json, it was always possible to redefine all the key bindings of VS Code, but it can be difficult to make a small tweak, especially around overloaded keys, such as kbstyle(Tab) or kbstyle(Escape). To remove a specific key binding, add a - to the command and the rule will be a removal rule.

Here is an example:

// In Default Keyboard Shortcuts
...
{ "key": "tab", "command": "tab", "when": ... },
{ "key": "tab", "command": "jumpToNextSnippetPlaceholder", "when": ... },
{ "key": "tab", "command": "acceptSelectedSuggestion", "when": ... },
...
// To remove the second rule, for example, add in keybindings.json:
{ "key": "tab", "command": "-jumpToNextSnippetPlaceholder" }

Keyboard layouts

Note: This section relates only to key bindings, not to typing in the editor.

The keys above are string representations for virtual keys and do not necessarily relate to the produced character when they are pressed. More precisely:

• Reference: Virtual-Key Codes (Windows)
• kbstyle(tab) for VK_TAB (0x09)
• kbstyle(;) for VK_OEM_1 (0xBA)
• kbstyle(=) for VK_OEM_PLUS (0xBB)
• kbstyle(,) for VK_OEM_COMMA (0xBC)
• kbstyle(-) for VK_OEM_MINUS (0xBD)
• kbstyle(.) for VK_OEM_PERIOD (0xBE)
• kbstyle(/) for VK_OEM_2 (0xBF)
• kbstyle(`) for VK_OEM_3 (0xC0)
• kbstyle([) for VK_OEM_4 (0xDB)
• kbstyle(\) for VK_OEM_5 (0xDC)
• kbstyle(]) for VK_OEM_6 (0xDD)
• kbstyle(') for VK_OEM_7 (0xDE)
• etc.

Different keyboard layouts usually reposition the above virtual keys or change the characters produced when they are pressed. When using a different keyboard layout than the standard US, Visual Studio Code does the following:

All the key bindings are rendered in the UI using the current system’s keyboard layout. For example, Split Editor when using a French (France) keyboard layout is now rendered as kbstyle(Ctrl+*):

When editing keybindings.json, VS Code highlights misleading key bindings, those that are represented in the file with the character produced under the standard US keyboard layout, but that need pressing keys with different labels under the current system’s keyboard layout. For example, here is how the Default Keyboard Shortcuts rules look like when using a French (France) keyboard layout:

There is also a widget that helps input the key binding rule when editing keybindings.json. To launch the Define Keybinding widget, press kb(editor.action.defineKeybinding). The widget listens for key presses and renders the serialized JSON representation in the text box and below it, the keys that VS Code has detected under your current keyboard layout. Once you’ve typed the key combination you want, you can press kbstyle(Enter) and a rule snippet will be inserted.

Note: On Linux, Visual Studio Code detects your current keyboard layout on start-up and then caches this information. For a good experience, we recommend restarting VS Code if you change your keyboard layout.

Keyboard layout-independent bindings

Using scan codes, it is possible to define keybindings which do not change with the change of the keyboard layout. For example:

{ "key": "cmd+[Slash]", "command": "editor.action.commentLine",
                           "when": "editorTextFocus" }

Accepted scan codes:

• kbstyle([F1]-[F19]), kbstyle([KeyA]-[KeyZ]), kbstyle([Digit0]-[Digit9])
• kbstyle([Backquote]), kbstyle([Minus]), kbstyle([Equal]), kbstyle([BracketLeft]), kbstyle([BracketRight]), kbstyle([Backslash]), kbstyle([Semicolon]), kbstyle([Quote]), kbstyle([Comma]), kbstyle([Period]), kbstyle([Slash])
• kbstyle([ArrowLeft]), kbstyle([ArrowUp]), kbstyle([ArrowRight]), kbstyle([ArrowDown]), kbstyle([PageUp]), kbstyle([PageDown]), kbstyle([End]), kbstyle([Home])
• kbstyle([Tab]), kbstyle([Enter]), kbstyle([Escape]), kbstyle([Space]), kbstyle([Backspace]), kbstyle([Delete])
• kbstyle([Pause]), kbstyle([CapsLock]), kbstyle([Insert])
• kbstyle([Numpad0]-[Numpad9]), kbstyle([NumpadMultiply]), kbstyle([NumpadAdd]), kbstyle([NumpadComma])
• kbstyle([NumpadSubtract]), kbstyle([NumpadDecimal]), kbstyle([NumpadDivide])

‘when’ clause contexts

VS Code gives you fine control over when your key bindings are enabled through the optional when clause. If your key binding doesn’t have a when clause, the key binding is globally available at all times. A when clause evaluates to either Boolean true or false for enabling key bindings.

Conditional operators

For conditional expressions, you can use the following conditional operators:

Contexts

Below are some of the possible when clause contexts which evaluate to Boolean true/false.

Note: You can use any user or workspace setting that evaluates to a boolean here with the prefix "config.".

The list above isn’t exhaustive and you may see some when contexts for specific VS Code UI in the Default Keyboard Shortcuts.

Active/Focused view or panel ‘when’ clause context

You can have a keybinding that is enabled only when a specific view or panel is visible.

View Identifiers:

• workbench.view.explorer - File Explorer
• workbench.view.search - Search
• workbench.view.scm - Source Control
• workbench.view.debug - Run
• workbench.view.extensions - Extensions

Panel Identifiers:

• workbench.panel.markers - Problems
• workbench.panel.output - Output
• workbench.panel.repl - Debug Console
• workbench.panel.terminal - Integrated Terminal
• workbench.panel.comments - Comments
• workbench.view.search - Search when search.location is set to panel

If you want a keybinding that is enabled only when a specific view or panel has focus, use sideBarFocus or panelFocus in combination with activeViewlet or activiewFocus.

For example, the when clause below is true only when the File Explorer has focus:

"sideBarFocus && activeViewlet == 'workbench.view.explorer'"

key-value when clause operator

There is a key-value pair operator for when clauses. The expression key =~ value treats the right hand side as a regular expression to match against the left hand side. For example, to contribute context menu items for all Docker files, one could use:

   "when": "resourceFilename =~ /docker/"

Custom keybindings for refactorings

The editor.action.codeAction command lets you configure keybindings for specific Refactorings (Code Actions). For example, the keybinding below triggers the Extract function refactoring Code Actions:

{
  "key": "ctrl+shift+r ctrl+e",
  "command": "editor.action.codeAction",
  "args": {
    "kind": "refactor.extract.function"
  }
}

This is covered in depth in the Refactoring topic where you can learn about different kinds of Code Actions and how to prioritize them in the case of multiple possible refactorings.

Default Keyboard Shortcuts

You can view all default keyboard shortcuts in VS Code in the Keyboard Shortcuts editor with the Show Default Keybindings command in the More Actions (…) menu. This applies the @source:default filter to the Keyboard Shortcuts editor (Source is ‘Default’).

You can view the default keyboard shortcuts as a JSON file using the command Preferences: Open Default Keyboard Shortcuts (JSON).

Note: The following keys are rendered assuming a standard US keyboard layout. If you use a different keyboard layout, please read below. You can view the currently active keyboard shortcuts in VS Code in the Command Palette (View -> Command Palette) or in the Keyboard Shortcuts editor (File > Preferences > Keyboard Shortcuts).

Some commands included below do not have default keyboard shortcuts and so are displayed as kbstyle(unassigned) but you can assign your own keybindings.

Basic Editing

Rich Languages Editing

Navigation

Editor/Window Management

File Management

Display

Search

Preferences

Debug

Tasks

Extensions

Next steps

Now that you know about our Key binding support, what’s next…

• Language Support - Our Good, Better, Best language grid to see what you can expect
• Debugging - This is where VS Code really shines
• Node.js - End to end Node.js scenario with a sample app

Common questions

How can I find out what command is bound to a specific key?

In the Keyboard Shortcut editor, you can filter on specific keystrokes to see which commands are bound to which keys. Below you can see that kbstyle(Ctrl+Shift+P) is bound to Show All Commands to bring up the Command Palette.

How to add a key binding to an action, for example, add Ctrl+D to Delete Lines

Find a rule that triggers the action in the Default Keyboard Shortcuts and write a modified version of it in your keybindings.json file:

// Original, in Default Keyboard Shortcuts
{ "key": "ctrl+shift+k",          "command": "editor.action.deleteLines",
                                     "when": "editorTextFocus" },
// Modified, in User/keybindings.json, Ctrl+D now will also trigger this action
{ "key": "ctrl+d",                "command": "editor.action.deleteLines",
                                     "when": "editorTextFocus" },

How can I add a key binding for only certain file types?

Use the editorLangId context key in your when clause:

{ "key": "shift+alt+a",           "command": "editor.action.blockComment",
                                     "when": "editorTextFocus && editorLangId == csharp" },

I have modified my key bindings in keybindings.json; why don’t they work?

The most common problem is a syntax error in the file. Otherwise, try removing the when clause or picking a different key. Unfortunately, at this point, it is a trial and error process.