Vim emulation for Visual Studio Code
VSCodeVim is a Vim emulator for Visual Studio Code.
- ๐ For a full list of supported Vim features, please refer to our roadmap.
- ๐ Our change log outlines the breaking/major/minor updates between releases.
- โ If you need to ask any questions, join us on Slack
- Report missing features/bugs on GitHub.
Table of Contents (click to expand)
VSCodeVim is automatically enabled following installation and reloading of VS Code.
To enable key-repeating execute the following in your Terminal and restart VS Code:
$ defaults write com.microsoft.VSCode ApplePressAndHoldEnabled -bool false # For VS Code
$ defaults write com.microsoft.VSCodeInsiders ApplePressAndHoldEnabled -bool false # For VS Code Insider
$ defaults write com.visualstudio.code.oss ApplePressAndHoldEnabled -bool false # For VS Codium
$ defaults delete -g ApplePressAndHoldEnabled # If necessary, reset global default
We also recommend increasing Key Repeat and Delay Until Repeat settings in System Preferences -> Keyboard.
Like real vim, VSCodeVim will take over your control keys. This behaviour can be adjusted with the useCtrlKeys
and handleKeys
settings.
The settings documented here are a subset of the supported settings; the full list is described in the Contributions
tab of VSCodeVim's extension details page, which can be found in the extensions view of VS Code.
Below is an example of a settings.json file with settings relevant to VSCodeVim:
{
"vim.easymotion": true,
"vim.incsearch": true,
"vim.useSystemClipboard": true,
"vim.useCtrlKeys": true,
"vim.hlsearch": true,
"vim.insertModeKeyBindings": [
{
"before": ["j", "j"],
"after": ["<Esc>"]
}
],
"vim.normalModeKeyBindingsNonRecursive": [
{
"before": ["<leader>", "d"],
"after": ["d", "d"]
},
{
"before": ["<C-n>"],
"commands": [":nohl"]
}
],
"vim.leader": "<space>",
"vim.handleKeys": {
"<C-a>": false,
"<C-f>": false
}
}
These settings are specific to VSCodeVim.
Setting | Description | Type | Default Value |
---|---|---|---|
vim.changeWordIncludesWhitespace | Include trailing whitespace when changing word. This configures the cw action to act consistently as its siblings (yw and dw) instead of acting as ce. | Boolean | false |
vim.cursorStylePerMode.{Mode} | Configure a specific cursor style for {Mode}. Omitted modes will use default cursor type Supported cursors: line, block, underline, line-thin, block-outline, and underline-thin. | String | None |
vim.digraphs.{shorthand} | Set custom digraph shorthands that can override the default ones. Entries should map a two-character shorthand to a descriptive string and one or more UTF16 code points. Example: "R!": ["๐", [55357, 56960]] |
Object | {"R!": ["๐", [0xD83D, 0xDE80]] |
vim.debug.silent | Boolean indicating whether log messages will be suppressed. | Boolean | false |
vim.debug.loggingLevelForConsole | Maximum level of messages to log to console. Logs are visible in the developer tools. Supported values: 'error', 'warn', 'info', 'verbose', 'debug'). | String | error |
vim.debug.loggingLevelForAlert | Maximum level of messages to present as VS Code information window. Supported values: 'error', 'warn', 'info', 'verbose', 'debug'). | String | error |
vim.disableExtension | Disable VSCodeVim extension. This setting can also be toggled using toggleVim command in the Command Palette |
Boolean | false |
vim.handleKeys | Delegate configured keys to be handled by VS Code instead of by the VSCodeVim extension. Any key in keybindings section of the package.json that has a vim.use<C-...> in the when argument can be delegated back to VS Code by setting "<C-...>": false . Example: to use ctrl+f for find (native VS Code behaviour): "vim.handleKeys": { "<C-f>": false } . |
String | "<C-d>": true |
vim.overrideCopy | Override VS Code's copy command with our own, which works correctly with VSCodeVim. If cmd-c/ctrl-c is giving you issues, set this to false and complain here. | Boolean | false |
vim.useSystemClipboard | Use the system clipboard register (* ) as the default register |
Boolean | false |
vim.searchHighlightColor | Set the color of search highlights | String | findMatchHighlightBackground ThemeColor |
vim.startInInsertMode | Start in Insert mode instead of Normal Mode | Boolean | false |
vim.useCtrlKeys | Enable Vim ctrl keys overriding common VS Code operations such as copy, paste, find, etc. | Boolean | true |
vim.visualstar | In visual mode, start a search with * or # using the current selection |
Boolean | false |
vim.highlightedyank.enable | Enable highlighting when yanking | Boolean | false |
vim.highlightedyank.color | Set the color of yank highlights | String | rgba(250, 240, 170, 0.5) |
vim.highlightedyank.duration | Set the duration of yank highlights | Number | 200 |
โ ๏ธ Experimental feature. Please leave feedback on neovim integration here.
To leverage neovim for Ex-commands,
- Install neovim
- Modify the following configurations:
Setting | Description | Type | Default Value |
---|---|---|---|
vim.enableNeovim | Enable Neovim | Boolean | false |
vim.neovimPath | Full path to neovim executable. If left empty, PATH environment variable will be automatically checked for neovim path. | String | |
vim.neovimUseConfigFile | If true , Neovim will load a config file specified by vim.neovimConfigPath . This is necessary if you want Neovim to be able to use its own plugins. |
Boolean | false |
vim.neovimConfigPath | Path that Neovim will load as config file. If left blank, Neovim will search in its default location. | String |
Here's some ideas on what you can do with neovim integration:
- The power of g
- The :normal command
- Faster search and replace!
Custom remappings are defined on a per-mode basis.
"vim.insertModeKeyBindings"
/"vim.normalModeKeyBindings"
/"vim.visualModeKeyBindings"
/"vim.operatorPendingModeKeyBindings"
- Keybinding overrides to use for insert, normal, operatorPending and visual modes.
- Bind
jj
to<Esc>
in insert mode:
"vim.insertModeKeyBindings": [
{
"before": ["j", "j"],
"after": ["<Esc>"]
}
]
- Bind
ยฃ
to goto previous whole word under cursor
"vim.normalModeKeyBindings": [
{
"before": ["ยฃ"],
"after": ["#"]
}
]
- Bind
:
to show the command palette:
"vim.normalModeKeyBindings": [
{
"before": [":"],
"commands": [
"workbench.action.showCommands",
]
}
]
- Bind
<leader>m
to add a bookmark and<leader>b
to open the list of all bookmarks (using the Bookmarks extension):
"vim.normalModeKeyBindings": [
{
"before": ["<leader>", "m"],
"commands": [
"bookmarks.toggle"
]
},
{
"before": ["<leader>", "b"],
"commands": [
"bookmarks.list"
]
}
]
- Bind
ctrl+n
to turn off search highlighting and<leader>w
to save the current file:
"vim.normalModeKeyBindings": [
{
"before":["<C-n>"],
"commands": [
":nohl",
]
},
{
"before": ["leader", "w"],
"commands": [
"workbench.action.files.save",
]
}
]
- Bind
{
tow
in operator pending mode makesy{
andd{
work likeyw
anddw
respectively.
"vim.operatorPendingModeKeyBindings": [
{
"before": ["{"],
"after": ["w"]
}
]
- Bind
L
to$
andH
to^
in operator pending mode makesyL
anddH
work likey$
andd^
respectively.
"vim.operatorPendingModeKeyBindings": [
{
"before": ["L"],
"after": ["$"]
},
{
"before": ["H"],
"after": ["^"]
}
]
- Bind
>
and<
in visual mode to indent/outdent lines (repeatable)
"vim.visualModeKeyBindings": [
{
"before": [
">"
],
"commands": [
"editor.action.indentLines"
]
},
{
"before": [
"<"
],
"commands": [
"editor.action.outdentLines"
]
},
]
- Bind
<leader>vim
to clone this repository to the selected location.
"vim.visualModeKeyBindings": [
{
"before": [
"<leader>", "v", "i", "m"
],
"commands": [
{
"command": "git.clone",
"args": [ "https://github.com/VSCodeVim/Vim.git" ]
}
]
}
]
"vim.insertModeKeyBindingsNonRecursive"
/"normalModeKeyBindingsNonRecursive"
/"visualModeKeyBindingsNonRecursive"
/"operatorPendingModeKeyBindingsNonRecursive"
- Non-recursive keybinding overrides to use for insert, normal, and visual modes
- Example: Exchange the meaning of two keys like
j
tok
andk
toj
to exchange the cursor up and down commands. Notice that if you attempted this binding normally, thej
would be replaced withk
and thek
would be replaced withj
, on and on forever. When this happens 'maxmapdepth' times (default 1000) the error message 'E223 Recursive Mapping' will be thrown. Stop this recursive expansion using the NonRecursive variation of the keybindings.
"vim.normalModeKeyBindingsNonRecursive": [
{
"before": ["j"],
"after": ["k"]
},
{
"before": ["k"],
"after": ["j"]
}
]
- Bind
(
to 'i(' in operator pending mode makes 'y(' and 'c(' work like 'yi(' and 'ci(' respectively.
"vim.operatorPendingModeKeyBindingsNonRecursive": [
{
"before": ["("],
"after": ["i("]
}
]
- Bind
p
in visual mode to paste without overriding the current register
"vim.visualModeKeyBindingsNonRecursive": [
{
"before": [
"p",
],
"after": [
"p",
"g",
"v",
"y"
]
}
],
-
Are your configurations correct?
Adjust the extension's logging level to 'debug', restart VS Code. As each remapped configuration is loaded, it is outputted to console. In the Developer Tools console, do you see any errors?
debug: Remapper: normalModeKeyBindingsNonRecursive. before=0. after=^. debug: Remapper: insertModeKeyBindings. before=j,j. after=<Esc>. error: Remapper: insertModeKeyBindings. Invalid configuration. Missing 'after' key or 'command'. before=j,k.
Misconfigured configurations are ignored.
-
Does the extension handle the keys you are trying to remap?
VSCodeVim explicitly instructs VS Code which key events we care about through the package.json. If the key you are trying to remap is a key in which vim/vscodevim generally does not handle, then it's most likely that this extension does not receive those key events from VS Code. With logging level adjusted to 'debug', as you press keys, you should see output similar to:
debug: ModeHandler: handling key=A. debug: ModeHandler: handling key=l. debug: ModeHandler: handling key=<BS>. debug: ModeHandler: handling key=<C-a>.
As you press the key that you are trying to remap, do you see it outputted here? If not, it means we don't subscribe to those key events.
Configuration settings that have been copied from vim. Vim settings are loaded in the following sequence:
:set {setting}
vim.{setting}
from user/workspace settings.- VS Code settings
- VSCodeVim default values
Setting | Description | Type | Default Value |
---|---|---|---|
vim.autoindent | Copy indent from current line when starting a new line | Boolean | true |
vim.gdefault | When on, the :substitute flag g is default on. This means that all matches in a line are substituted instead of one. When a g flag is given to a :substitute command, this will toggle the substitution of all or one match. |
Boolean | false |
vim.hlsearch | Highlights all text matching current search | Boolean | false |
vim.ignorecase | Ignore case in search patterns | Boolean | true |
vim.incsearch | Show the next match while entering a search | Boolean | true |
vim.joinspaces | Add two spaces after '.', '?', and '!' when joining or reformatting | Boolean | true |
vim.leader | Defines key for <leader> to be used in key remappings |
String | \ |
vim.showcmd | Show (partial) command in status bar | Boolean | true |
vim.showmodename | Show name of current mode in status bar | Boolean | true |
vim.smartcase | Override the 'ignorecase' setting if search pattern contains uppercase characters | Boolean | true |
vim.textwidth | Width to word-wrap when using gq |
Number | 80 |
vim.timeout | Timeout in milliseconds for remapped commands | Number | 1000 |
vim.maxmapdepth | Maximum number of times a mapping is done without resulting in a character to be used. This normally catches endless mappings, like ":map x y" with ":map y x". It still does not catch ":map g wg", because the 'w' is used before the next mapping is done. | Number | 1000 |
vim.whichwrap | Allow specified keys that move the cursor left/right to move to the previous/next line when the cursor is on the first/last character in the line. See :help whichwrap. | String | b,s |
vim.report | Threshold for reporting number of lines changed. | Number | 2 |
โ ๏ธ .vimrc support is currently experimental. Only remaps are supported, and you may experience bugs. Please report them!
Set vim.vimrc.enable
to true
and set vim.vimrc.path
appropriately.
โ ๏ธ Multi-Cursor mode is experimental. Please report issues in our feedback thread.
Enter multi-cursor mode by:
- On OSX,
cmd-d
. On Windows,ctrl-d
. gb
, a new shortcut we added which is equivalent tocmd-d
(OSX) orctrl-d
(Windows). It adds another cursor at the next word that matches the word the cursor is currently on.- Running "Add Cursor Above/Below" or the shortcut on any platform.
Once you have multiple cursors, you should be able to use Vim commands as you see fit. Most should work; some are unsupported (ref PR#587).
- Each cursor has its own clipboard.
- Pressing Escape in Multi-Cursor Visual Mode will bring you to Multi-Cursor Normal mode. Pressing it again will return you to Normal mode.
โ ๏ธ There are performance implications to using this plugin. In order to change the status bar, we override the configurations in your workspace settings.json which results in increased latency and a constant changing diff in your working directory (see issue#2124).
Change the color of the status bar based on the current mode. Once enabled, configure "vim.statusBarColors"
. Colors can be defined for each mode either as string
(background only), or string[]
(background, foreground).
"vim.statusBarColorControl": true,
"vim.statusBarColors.normal": ["#8FBCBB", "#434C5E"],
"vim.statusBarColors.insert": "#BF616A",
"vim.statusBarColors.visual": "#B48EAD",
"vim.statusBarColors.visualline": "#B48EAD",
"vim.statusBarColors.visualblock": "#A3BE8C",
"vim.statusBarColors.replace": "#D08770",
"vim.statusBarColors.commandlineinprogress": "#007ACC",
"vim.statusBarColors.searchinprogressmode": "#007ACC",
"vim.statusBarColors.easymotionmode": "#007ACC",
"vim.statusBarColors.easymotioninputmode": "#007ACC",
"vim.statusBarColors.surroundinputmode": "#007ACC",
Based on vim-easymotion and configured through the following settings:
Setting | Description | Type | Default Value |
---|---|---|---|
vim.easymotion | Enable/disable easymotion plugin | Boolean | false |
vim.easymotionMarkerBackgroundColor | The background color of the marker box. | String | '#0000' |
vim.easymotionMarkerForegroundColorOneChar | The font color for one-character markers. | String | '#ff0000' |
vim.easymotionMarkerForegroundColorTwoCharFirst | The font color for the first of two-character markers, used to differentiate from one-character markers. | String | '#ffb400' |
vim.easymotionMarkerForegroundColorTwoCharSecond | The font color for the second of two-character markers, used to differentiate consecutive markers. | String | '#b98300' |
vim.easymotionIncSearchForegroundColor | The font color for the search n-character command, used to highlight the matches. | String | '#7fbf00' |
vim.easymotionDimColor | The font color for the dimmed characters, used when #vim.easymotionDimBackground# is set to true. |
String | '#777777' |
vim.easymotionDimBackground | Whether to dim other text while markers are visible. | Boolean | true |
vim.easymotionMarkerFontWeight | The font weight used for the marker text. | String | 'bold' |
vim.easymotionKeys | The characters used for jump marker name | String | 'hklyuiopnm,qwertzxcvbasdgjf;' |
vim.easymotionJumpToAnywhereRegex | Custom regex to match for JumpToAnywhere motion (analogous to Easymotion_re_anywhere ). Example setting (which also matches start & end of line, as well as Javascript comments in addition to the regular behavior (note the double escaping required): ^\s*. |
\b[A-Za-z0-9] | [A-Za-z0-9]\b |
Once easymotion is active, initiate motions using the following commands. After you initiate the motion, text decorators/markers will be displayed and you can press the keys displayed to jump to that position. leader
is configurable and is \
by default.
Motion Command | Description |
---|---|
<leader><leader> s <char> |
Search character |
<leader><leader> f <char> |
Find character forwards |
<leader><leader> F <char> |
Find character backwards |
<leader><leader> t <char> |
Til character forwards |
<leader><leader> T <char> |
Til character backwards |
<leader><leader> w |
Start of word forwards |
<leader><leader> b |
Start of word backwards |
<leader><leader> l |
Matches beginning & ending of word, camelCase, after _ , and after # forwards |
<leader><leader> h |
Matches beginning & ending of word, camelCase, after _ , and after # backwards |
<leader><leader> e |
End of word forwards |
<leader><leader> ge |
End of word backwards |
<leader><leader> j |
Start of line forwards |
<leader><leader> k |
Start of line backwards |
<leader><leader> / <char>... <CR> |
Search n-character |
<leader><leader><leader> bdt |
Til character |
<leader><leader><leader> bdw |
Start of word |
<leader><leader><leader> bde |
End of word |
<leader><leader><leader> bdjk |
Start of line |
<leader><leader><leader> j |
JumpToAnywhere motion; default behavior matches beginning & ending of word, camelCase, after _ and after # |
<leader><leader> (2s|2f|2F|2t|2T) <char><char>
and <leader><leader><leader> bd2t <char>char>
are also available.
The difference is character count required for search.
For example, <leader><leader> 2s <char><char>
requires two characters, and search by two characters.
This mapping is not a standard mapping, so it is recommended to use your custom mapping.
Based on surround.vim, the plugin is used to work with surrounding characters like parentheses, brackets, quotes, and XML tags.
Setting | Description | Type | Default Value |
---|---|---|---|
vim.surround | Enable/disable vim-surround | Boolean | true |
t
or <
as <desired>
or <existing>
will enter tag entry mode. Using <CR>
instead of >
to finish changing a tag will preserve any existing attributes.
Surround Command | Description |
---|---|
y s <motion> <desired> |
Add desired surround around text defined by <motion> |
d s <existing> |
Delete existing surround |
c s <existing> <desired> |
Change existing surround to desired |
S <desired> |
Surround when in visual modes (surrounds full selection) |
Some examples:
"test"
with cursor inside quotes typecs"'
to end up with'test'
"test"
with cursor inside quotes typeds"
to end up withtest
"test"
with cursor inside quotes typecs"t
and enter123>
to end up with<123>test</123>
Similar to vim-commentary, but uses the VS Code native Toggle Line Comment and Toggle Block Comment features.
Usage examples:
gc
- toggles line comment. For examplegcc
to toggle line comment for current line andgc2j
to toggle line comments for the current line and the next two lines.gC
- toggles block comment. For examplegCi)
to comment out everything within parentheses.
Based on vim-indent-object, it allows for treating blocks of code at the current indentation level as text objects. Useful in languages that don't use braces around statements (e.g. Python).
Provided there is a new line between the opening and closing braces / tag, it can be considered an agnostic cib
/ci{
/ci[
/cit
.
Command | Description |
---|---|
<operator>ii |
This indentation level |
<operator>ai |
This indentation level and the line above (think if statements in Python) |
<operator>aI |
This indentation level, the line above, and the line after (think if statements in C/C++/Java/etc) |
Based on vim-sneak, it allows for jumping to any location specified by two characters.
Setting | Description | Type | Default Value |
---|---|---|---|
vim.sneak | Enable/disable vim-sneak | Boolean | false |
vim.sneakUseIgnorecaseAndSmartcase | Respect vim.ignorecase and vim.smartcase while sneaking |
Boolean | false |
Once sneak is active, initiate motions using the following commands. For operators sneak uses z
instead of s
because s
is already taken by the surround plugin.
Motion Command | Description |
---|---|
s<char><char> |
Move forward to the first occurrence of <char><char> |
S<char><char> |
Move backward to the first occurrence of <char><char> |
<operator>z<char><char> |
Perform <operator> forward to the first occurrence of <char><char> |
<operator>Z<char><char> |
Perform <operator> backward to the first occurrence of <char><char> |
Based on CamelCaseMotion, though not an exact emulation. This plugin provides an easier way to move through camelCase and snake_case words.
Setting | Description | Type | Default Value |
---|---|---|---|
vim.camelCaseMotion.enable | Enable/disable CamelCaseMotion | Boolean | false |
Once CamelCaseMotion is enabled, the following motions are available:
Motion Command | Description |
---|---|
<leader>w |
Move forward to the start of the next camelCase or snake_case word segment |
<leader>e |
Move forward to the next end of a camelCase or snake_case word segment |
<leader>b |
Move back to the prior beginning of a camelCase or snake_case word segment |
<operator>i<leader>w |
Select/change/delete/etc. the current camelCase or snake_case word segment |
By default, <leader>
is mapped to \
, so for example, d2i\w
would delete the current and next camelCase word segment.
Disable input method when exiting Insert Mode.
Setting | Description |
---|---|
vim.autoSwitchInputMethod.enable |
Boolean denoting whether autoSwitchInputMethod is on/off. |
vim.autoSwitchInputMethod.defaultIM |
Default input method. |
vim.autoSwitchInputMethod.obtainIMCmd |
The full path to command to retrieve the current input method key. |
vim.autoSwitchInputMethod.switchIMCmd |
The full path to command to switch input method, with {im} a placeholder for input method key. |
Any third-party program can be used to switch input methods. The following will walkthrough the configuration using im-select.
-
Install im-select (see installation guide)
-
Find your default input method key
-
Mac:
Switch your input method to English, and run the following in your terminal:
/<path-to-im-select-installation>/im-select
to output your default input method. The table below lists the common English key layouts for MacOS.Key Description com.apple.keylayout.US U.S. com.apple.keylayout.ABC ABC com.apple.keylayout.British British com.apple.keylayout.Irish Irish com.apple.keylayout.Australian Australian com.apple.keylayout.Dvorak Dvorak com.apple.keylayout.Colemak Colemak -
Windows:
Refer to the im-select guide on how to discover your input method key. Generally, if your keyboard layout is en_US the input method key is 1033 (the locale ID of en_US). You can also find your locale ID from this page, where the
LCID Decimal
column is the locale ID.
-
-
Configure
vim.autoSwitchInputMethod
.-
MacOS:
Given the input method key of
com.apple.keylayout.US
andim-select
located at/usr/local/bin
. The configuration is:"vim.autoSwitchInputMethod.enable": true, "vim.autoSwitchInputMethod.defaultIM": "com.apple.keylayout.US", "vim.autoSwitchInputMethod.obtainIMCmd": "/usr/local/bin/im-select", "vim.autoSwitchInputMethod.switchIMCmd": "/usr/local/bin/im-select {im}"
-
Windows:
Given the input method key of
1033
(en_US) andim-select.exe
located atD:/bin
. The configuration is:"vim.autoSwitchInputMethod.enable": true, "vim.autoSwitchInputMethod.defaultIM": "1033", "vim.autoSwitchInputMethod.obtainIMCmd": "D:\\bin\\im-select.exe", "vim.autoSwitchInputMethod.switchIMCmd": "D:\\bin\\im-select.exe {im}"
-
The {im}
argument above is a command-line option that will be passed to im-select
denoting the input method to switch to. If using an alternative program to switch input methods, you should add a similar option to the configuration. For example, if the program's usage is my-program -s imKey
to switch input method, the vim.autoSwitchInputMethod.switchIMCmd
should be /path/to/my-program -s {im}
.
Based on ReplaceWithRegister, an easy way to replace existing text with the contents of a register.
Setting | Description | Type | Default Value |
---|---|---|---|
vim.replaceWithRegister | Enable/disable ReplaceWithRegister | Boolean | false |
Once active, type gr
(say "go replace") followed by a motion to describe the text you want replaced by the contents of the register.
Motion Command | Description |
---|---|
[count]["a]gr<motion> |
Replace the text described by the motion with the contents of the specified register |
[count]["a]grr |
Replace the [count] lines or current line with the contents of the specified register |
{Visual}["a]gr |
Replace the selection with the contents of the specified register |
Similar to vim-textobj-entire.
Adds two useful text-objects:
ae
which represents the entire content of a buffer.ie
which represents the entire content of a buffer without the leading and trailing spaces.
Usage examples:
dae
- delete the whole buffer content.yie
- will yank the buffer content except leading and trailing blank lines.gUae
- transform the whole buffer to uppercase.
VS Code has a lot of nifty tricks and we try to preserve some of them:
gd
- jump to definition.gq
- on a visual selection reflow and wordwrap blocks of text, preserving commenting style. Great for formatting documentation comments.gb
- adds another cursor on the next word it finds which is the same as the word under the cursor.af
- visual mode command which selects increasingly large blocks of text. For example, if you had "blah (foo [bar 'ba|z'])" then it would select 'baz' first. If you pressedaf
again, it'd then select [bar 'baz'], and if you did it a third time it would select "(foo [bar 'baz'])".gh
- equivalent to hovering your mouse over wherever the cursor is. Handy for seeing types and error messages without reaching for the mouse!
-
None of the native Visual Studio Code
ctrl
(e.g.ctrl+f
,ctrl+v
) commands workSet the
useCtrlKeys
setting tofalse
. -
Moving
j
/k
over folds opens up the foldsTry setting
vim.foldfix
totrue
. This is a hack; it works fine, but there are side effects (see issue#22276). -
Key repeat doesn't work
Are you on a Mac? Did you go through our mac-setup instructions?
-
There are annoying intellisense/notifications/popups that I can't close with
<esc>
! Or I'm in a snippet and I want to close intellisensePress
shift+<esc>
to close all of those boxes. -
How can I use the commandline when in Zen mode or when the status bar is disabled?
This extension exposes a remappable command to show a VS Code style quick-pick version of the commandline, with more limited functionality. This can be remapped as follows in VS Code's keybindings.json settings file.
{ "key": "shift+;", "command": "vim.showQuickpickCmdLine", "when": "editorTextFocus && vim.mode != 'Insert'" }
Or for Zen mode only:
{ "key": "shift+;", "command": "vim.showQuickpickCmdLine", "when": "inZenMode && vim.mode != 'Insert'" }
-
How can I move the cursor by each display line with word wrapping?
If you have word wrap on and would like the cursor to enter each wrapped line when using j, k, โ or โ, set the following in VS Code's keybindings.json settings file.
{ "key": "up", "command": "cursorUp", "when": "editorTextFocus && vim.active && !inDebugRepl && !suggestWidgetMultipleSuggestions && !suggestWidgetVisible" }, { "key": "down", "command": "cursorDown", "when": "editorTextFocus && vim.active && !inDebugRepl && !suggestWidgetMultipleSuggestions && !suggestWidgetVisible" }, { "key": "k", "command": "cursorUp", "when": "editorTextFocus && vim.active && !inDebugRepl && vim.mode == 'Normal' && !suggestWidgetMultipleSuggestions && !suggestWidgetVisible" }, { "key": "j", "command": "cursorDown", "when": "editorTextFocus && vim.active && !inDebugRepl && vim.mode == 'Normal' && !suggestWidgetMultipleSuggestions && !suggestWidgetVisible" }
Caveats: This solution restores the default VS Code behavior for the j and k keys, so motions like
10j
will not work. If you need these motions to work, other, less performant options exist. -
I've swapped Escape and Caps Lock with setxkbmap and VSCodeVim isn't respecting the swap
This is a known issue in VS Code, as a workaround you can set
"keyboard.dispatch": "keyCode"
and restart VS Code.
This project is maintained by a group of awesome people and contributions are extremely welcome โค๏ธ. For a quick tutorial on how you can help, see our contributing guide.
- Thanks to @xconverge for making over 100 commits to the repo. If you're wondering why your least favorite bug packed up and left, it was probably him.
- Thanks to @Metamist for implementing EasyMotion!
- Thanks to @sectioneight for implementing text objects!
- Special props to Kevin Coleman, who created our awesome logo!
- Shoutout to @chillee aka Horace He for his contributions and hard work.