NVim

VSCodeVim

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.
Report missing features/bugs on GitHub.

Table of Contents (click to expand)

💾 Installation
- Mac
- Windows
⚙️ Settings
.vimrc support
🖱️ Multi-Cursor Mode
Kill ring support
🔌 Emulated Plugins
🎩 VSCodeVim tricks!
📚 F.A.Q.
❤️ Contributing
- Special shoutouts to:

💾 Installation

VSCodeVim can be installed via the VS Code Marketplace.

Mac

To enable key-repeating, execute the following in your Terminal, log out and back in, and then 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.vscodium ApplePressAndHoldEnabled -bool false                      # For VS Codium
defaults write com.microsoft.VSCodeExploration ApplePressAndHoldEnabled -bool false   # For VS Codium Exploration users
defaults delete -g ApplePressAndHoldEnabled                                           # If necessary, reset global default

We also recommend increasing Key Repeat and Delay Until Repeat settings in System Preferences -> Keyboard.

Windows

Like real vim, VSCodeVim will take over your control keys. This behavior can be adjusted with the useCtrlKeys and handleKeys settings.

⚙️ 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.

Quick Example

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"]
    },
    {
      "before": ["K"],
      "commands": ["lineBreakInsert"],
      "silent": true
    }
  ],
  "vim.leader": "<space>",
  "vim.handleKeys": {
    "<C-a>": false,
    "<C-f>": false
  },

  "// To improve performance",
  "extensions.experimental.affinity": {
    "vscodevim.vim": 1
  }
}

VSCodeVim settings

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.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 behavior): `"vim.handleKeys": { "<C-f>": false }`.	String	`"<C-d>": true` `"<C-s>": false` `"<C-z>": false`
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.killRingMax	Maximum length of kill ring before oldest elements are thrown away.	Number	120
vim.searchHighlightColor	Background color of non-current search matches	String	`findMatchHighlightBackground` ThemeColor
vim.searchHighlightTextColor	Foreground color of non-current search matches	String	None
vim.searchMatchColor	Background color of current search match	String	`findMatchBackground` ThemeColor
vim.searchMatchTextColor	Foreground color of current search match	String	None
vim.substitutionColor	Background color of substitution text when `vim.inccommand` is enabled	String	"#50f01080"
vim.substitutionTextColor	Foreground color of substitution text when `vim.inccommand` is enabled	String	None
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

Neovim Integration

:warning: 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!

Key Remapping

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.
Keybinding overrides can include "before", "after", "commands", and "silent".
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, and don't show the message on the status bar:

    "vim.normalModeKeyBindings": [
        {
            "before": [":"],
            "commands": [
                "workbench.action.showCommands",
            ],
            "silent": true
        }
    ]

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 { to w in operator pending mode makes y{ and d{ work like yw and dw respectively:

    "vim.operatorPendingModeKeyBindings": [
        {
            "before": ["{"],
            "after": ["w"]
        }
    ]

Bind L to $ and H to ^ in operator pending mode makes yL and dH work like y$ and d^ 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 to k and k to j to exchange the cursor up and down commands. Notice that if you attempted this binding normally, the j would be replaced with k and the k would be replaced with j, 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"
            ]
        }
    ],

Debugging Remappings

Adjust the extension's logging level to 'debug' and open the Output window:
1. Run Developer: Set Log Level from the command palette.
2. Select Vim, then Debug
3. Run Developer: Reload window
4. In the bottom panel, open the Output tab and select Vim from the dropdown selection.

Are your configurations correct?

As each remapped configuration is loaded, it is logged to the Vim Output panel. 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 'commands'. 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. In the Vim Output panel, you should see:
```
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. It is still possible to remap those keys by using VSCode's keybindings.json (see next section: Remapping more complex key combinations).

Remapping more complex key combinations

It is highly recommended to remap keys using vim commands like "vim.normalModeKeyBindings" (see here). But sometimes the usual remapping commands are not enough as they do not support every key combinations possible (for example Alt+key or Ctrl+Shift+key). In this case it is possible to create new keybindings inside keybindings.json. To do so: open up keybindings.json in VSCode using CTRL+SHIFT+P and select Open keyboard shortcuts (JSON).

You can then add a new entry to the keybindings like so:

{
  "key": "YOUR_KEY_COMBINATION",
  "command": "vim.remap",
  "when": "inputFocus && vim.mode == 'VIM_MODE_YOU_WANT_TO_REBIND'",
  "args": {
    "after": ["YOUR_VIM_ACTION"]
  }
}

For example, to rebind ctrl+shift+y to VSCodeVim's yy (yank line) in normal mode, add this to your keybindings.json:

{
  "key": "ctrl+shift+y",
  "command": "vim.remap",
  "when": "inputFocus && vim.mode == 'Normal'",
  "args": {
    "after": ["y", "y"]
  }
}

If keybindings.json is empty the first time you open it, make sure to add opening [ and closing ] square brackets to the file as the keybindings should be inside a JSON Array.

Vim modes

Here are all the modes used by VSCodeVim:

Mode
Normal
Insert
Visual
VisualBlock
VisualLine
SearchInProgressMode
CommandlineInProgress
Replace
EasyMotionMode
EasyMotionInputMode
SurroundInputMode
OperatorPendingMode
Disabled

When rebinding keys in keybindings.json using "when clause context", it can be useful to know in which mode vim currently is. For example to write a "when clause" that checks if vim is currently in normal mode or visual mode it is possible to write the following:

"when": "vim.mode == 'Normal' || vim.mode == 'Visual'",

Vim settings

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.inccommand	Show the effects of the `:substitute` command while typing	String	`replace`
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.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.report	Threshold for reporting number of lines changed.	Number	2
vim.shell	Path to the shell to use for `!` and `:!` commands.	String	`/bin/sh` on Unix, `%COMSPEC%` environment variable on Windows
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.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`

.vimrc support

:warning: .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

:warning: 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 to cmd-d (OSX) or ctrl-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.

Kill ring support

You can set the maximum length of kill ring with vim.killRingMax. To yank from the kill ring, VSCodeVim with kill ring provides alt-y keybinding, following Emacs's.

🔌 Emulated Plugins

vim-airline

:warning: 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",

vim-easymotion

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`)	String	`\b[A-Za-z0-9]\\|[A-Za-z0-9]\b\\|_.\\|#.\\|[a-z][A-Z]`
vim.easymotionSearchLines	Set the number of lines for the easymotion search.	Number	100

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.

vim-flash

Based on flash.nvim and configured through the following settings:

Setting	Description	Type	Default Value
vim.flash.enable	Enable the Flash plugin for Vim.	Boolean	false
vim.flash.ignorecase	Set to consider case sensitive in search patterns	Boolean	true
vim.flash.labels	Set the characters used for jump marker name.	String	'hklyuiopnm,qwertzxcvbasdgjf;'
vim.flash.marker.backgroundColor	The background color of the marker box.	String	'#ccff88'
vim.flash.marker.nextMatchBackgroundColor	The background color of the next marker box.	String	'#ffb86c'

The most basic usage method

The most basic way to use flash is: f + search characters + marker point label

Support displaying the currently entered search character in StatusBar

To maintain consistency with / search, the current input character will be displayed during search

Support recording jump points

After using flash to jump, it will be recorded in the jump list. So this means that you can jump back to the previous position through ctrl+o/i

Support visualization mode

flash can also be used in conjunction with visualization mode

Just press v and then press f + the search character

Support operator

flash also supports operators

Now you can use it in conjunction with operators such as d y

Support automatic jump to the next marker point with a carriage return

If you want to jump directly to the next marker point, Just press the enter key directly, Here, different background colors have been added to indicate the next marker point

Support previous search

Sometimes I still want to search for the previous search character, but I am too lazy to input it repeatedly

All you need to do is press f + enter

The previous search record will only be recorded after a successful challenge

If there is no previous search record, a prompt will be given

Want to use native f functionality?

Just enter \, everything is the same as before

vim-surround

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 type cs"' to end up with 'test'
"test" with cursor inside quotes type ds" to end up with test
"test" with cursor inside quotes type cs"t and enter 123> to end up with <123>test</123>

vim-commentary

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 example gcc to toggle line comment for current line and gc2j to toggle line comments for the current line and the next two lines.
gC - toggles block comment. For example gCi) to comment out everything within parentheses.

vim-indent-object

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)

vim-indentwise

Based on vim-indentwise, it allows moving by indentation level. Useful in languages that don't use braces around statements (e.g. Python) but also for other languages (e.g. to move to the next line that starts at column 0)

Setting	Description	Type	Default Value
vim.indentwise	Enable/disable vim-indentwise	Boolean	false

There are 3 main ways of moving:

By relative indent level, either to a line with less, equal or greater indent.
To an absolute indent level. If spaces are used, the number of spaces that constitute a level is taken from the tabSize editor setting.
To the beginning/end of the current block (i.e. to the last line above/first line below the next/last line with less indent than block the current line is part of). Vim-indent-object described above is another useful alternative for this.

In all modes, empty lines are ignored and never jumped to (use the jump by paragraph motion to go to empty lines).

Absolute indent level jumps work a bit differently than they do in vim-indentwise: instead of using the optional count prefix to specify the level, the level is given at the end explicitly. This allows both to combine it with counts (e.g. 2]_0 to jump to the 2nd next line that has 0 indent), and also allows custom key remaps to specific levels (e.g. in python jumping to the next/previous line at indent level 0 is very common and you may want to use a custom keyboard shortcut to do this quicker)

Motion Command	Description
`]-`	Move forward to the next line with less indentation than the current line
`]=`	Move forward to the next line with equal indentation with the current line
`]+`	Move forward to the next line with greater indentation than the current line
`[-`	Move backward to the last line with less indentation than the current line
`[=`	Move backward to the last line with equal indentation with the current line
`[+`	Move backward to the last line with greater indentation than the current line
`]_0`	Move forward to the next line with indent level 0
`]_1`	Move forward to the next line with indent level 1
`]_2`	Move forward to the next line with indent level 2
`]_3`	Move forward to the next line with indent level 3
`]_4`	Move forward to the next line with indent level 4
`]_5`	Move forward to the next line with indent level 5
`]_6`	Move forward to the next line with indent level 6
`]_7`	Move forward to the next line with indent level 7
`]_8`	Move forward to the next line with indent level 8
`]_9`	Move forward to the next line with indent level 9
`[_0`	Move backward to the last line with indent level 0
`[_1`	Move backward to the last line with indent level 1
`[_2`	Move backward to the last line with indent level 2
`[_3`	Move backward to the last line with indent level 3
`[_4`	Move backward to the last line with indent level 4
`[_5`	Move backward to the last line with indent level 5
`[_6`	Move backward to the last line with indent level 6
`[_7`	Move backward to the last line with indent level 7
`[_8`	Move backward to the last line with indent level 8
`[_9`	Move backward to the last line with indent level 9
`]%`	Move to the end of the current indentation block (the last line with the same indentation level)
`[%`	Move to the start of the current indentation block (the first line with the same indentation level)

vim-sneak

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>`

CamelCaseMotion

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.

Input Method

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 and im-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) and im-select.exe located at D:/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}.

ReplaceWithRegister

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

vim-textobj-entire

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.

vim-textobj-arguments

Similar to the argument text object in targets.vim. It is an easy way to deal with arguments inside functions in most programming languages.

Motion Command	Description
`<operator>ia`	The argument excluding separators.
`<operator>aa`	The argument including separators.

Usage examples:

cia - change the argument under the cursor while preserving separators like comma ,.
daa - will delete the whole argument under the cursor and the separators if applicable.

Setting	Description	Type	Default Value
vim.argumentObjectOpeningDelimiters	A list of opening delimiters	String list	["(", "["]
vim.argumentObjectClosingDelimiters	A list of closing delimiters	String list	[")", "]"]
vim.argumentObjectSeparators	A list of object separators	String list	[","]

🎩 VSCodeVim tricks!

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 pressed af 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!

📚 F.A.Q.

None of the native Visual Studio Code ctrl (e.g. ctrl+f, ctrl+v) commands work

Set the useCtrlKeys setting to false.
Moving j/k over folds opens up the folds

Try setting vim.foldfix to true. 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 intellisense

Press 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.
VSCodeVim is too slow!

You can try adding the following setting, and reload/restart VSCode:
```
"extensions.experimental.affinity": {
  "vscodevim.vim": 1
}
```
Caveats: One issue with using the affinity setting is that each time you update your settings file, the Vim plugin will reload, which can take a few seconds.

❤️ Contributing

This project is maintained by a group of awesome people and contributions are extremely welcome :heart:. For a quick tutorial on how you can help, see our contributing guide.

Special shoutouts to:

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.

HenryTsz

VSCodeVim

💾 Installation

Mac

Windows

⚙️ Settings

Quick Example

VSCodeVim settings

Neovim Integration

Key Remapping

"vim.insertModeKeyBindings"/"vim.normalModeKeyBindings"/"vim.visualModeKeyBindings"/"vim.operatorPendingModeKeyBindings"

"vim.insertModeKeyBindingsNonRecursive"/"normalModeKeyBindingsNonRecursive"/"visualModeKeyBindingsNonRecursive"/"operatorPendingModeKeyBindingsNonRecursive"

Debugging Remappings

Remapping more complex key combinations

Vim modes

Vim settings

.vimrc support

🖱️ Multi-Cursor Mode

Kill ring support

🔌 Emulated Plugins

vim-airline

vim-easymotion

vim-flash

The most basic usage method

Support displaying the currently entered search character in StatusBar

Support recording jump points

Support visualization mode

Support operator

Support automatic jump to the next marker point with a carriage return

Support previous search

Want to use native f functionality?

vim-surround

vim-commentary

vim-indent-object

vim-indentwise

vim-sneak

CamelCaseMotion

Input Method

ReplaceWithRegister

vim-textobj-entire

vim-textobj-arguments

🎩 VSCodeVim tricks!

📚 F.A.Q.

❤️ Contributing

Special shoutouts to:

`"vim.insertModeKeyBindings"`/`"vim.normalModeKeyBindings"`/`"vim.visualModeKeyBindings"`/`"vim.operatorPendingModeKeyBindings"`

`"vim.insertModeKeyBindingsNonRecursive"`/`"normalModeKeyBindingsNonRecursive"`/`"visualModeKeyBindingsNonRecursive"`/`"operatorPendingModeKeyBindingsNonRecursive"`