Vim Mode

Zed includes a Vim emulation layer known as "vim mode". On this page, you will learn how to turn Zed's vim mode on or off, what tools and commands Zed provides to help you navigate and edit your code, and generally how to make the most of vim mode in Zed.

You'll learn how to:

• Understand the core differences between Zed's vim mode and traditional Vim
• Enable or disable vim mode
• Make the most of Zed-specific features within vim mode
• Customize vim mode key bindings
• Configure vim mode settings

Whether you're new to vim mode or an experienced Vim user looking to optimize your Zed experience, this guide will help you harness the full power of modal editing in Zed.

Zed's vim mode design

Vim mode tries to offer a familiar experience to Vim users: it replicates the behavior of motions and commands precisely when it makes sense and uses Zed-specific functionality to provide an editing experience that "just works" without requiring configuration on your part.

This includes support for semantic navigation, multiple cursors, or other features usually provided by plugins like surrounding text.

So, Zed's vim mode does not replicate Vim one-to-one, but it meshes Vim's modal design with Zed's modern features to provide a more fluid experience. It's also configurable, so you can add your own key bindings or override the defaults.

Core differences

There are four types of features in vim mode that use Zed's core functionality, leading to some differences in behavior:

1. Motions: vim mode uses Zed's semantic parsing to tune the behavior of motions per language. For example, in Rust, jumping to matching bracket with % works with the pipe character |. In JavaScript, w considers $ to be a word character.
2. Visual block selections: vim mode uses Zed's multiple cursor to emulate visual block selections, making block selections a lot more flexible. For example, anything you insert after a block selection updates on every line in real-time, and you can add or remove cursors anytime.
3. Macros: vim mode uses Zed's recording system for vim macros. So, you can capture and replay more complex actions, like autocompletion.
4. Search and replace: vim mode uses Zed's search system, so, the syntax for regular expressions is slightly different compared to Vim. Head to the Regex differences section for details.

Note: The foundations of Zed's vim mode should already cover many use cases, and we're always looking to improve it. If you find missing features that you rely on in your workflow, please file an issue on GitHub.

Enabling and disabling vim mode

When you first open Zed, you'll see a checkbox on the welcome screen that allows you to enable vim mode.

If you missed this, you can toggle vim mode on or off anytime by opening the command palette and using the workspace command toggle vim mode.

Note: This command toggles the following property in your user settings:

{
  "vim_mode": true
}

Zed-specific features

Zed is built on a modern foundation that (among other things) uses tree-sitter and language servers to understand the content of the file you're editing and supports multiple cursors out of the box.

Vim mode has several "core Zed" key bindings that will help you make the most of Zed's specific feature set.

Language server

The following commands use the language server to help you navigate and refactor your code.

Git

Treesitter

Treesitter is a powerful tool that Zed uses to understand the structure of your code. Zed provides motions that change the current cursor position, and text objects that can be used as the target of actions.

Note that the definitions for the targets of the [m family of motions are the same as the boundaries defined by af. The targets of the [[ are the same as those defined by ac, though if there are no classes, then functions are also used. Similarly gc is used to find [ /. g c

The definition of functions, classes and comments is language dependent, and support can be added to extensions by adding a [textobjects.scm]. The definition of arguments and tags operates at the tree-sitter level, but looks for certain patterns in the parse tree and is not currently configurable per language.

Multi cursor

These commands help you manage multiple cursors in Zed.

Pane management

These commands open new panes or jump to specific panes.

In insert mode

The following commands help you bring up Zed's completion menu, request a suggestion from GitHub Copilot, or open the inline AI assistant without leaving insert mode.

Supported plugins

Zed's vim mode includes some features that are usually provided by very popular plugins in the Vim ecosystem:

• You can surround text objects with ys (yank surround), change surrounding with cs, and delete surrounding with ds.
• You can comment and uncomment selections with gc in visual mode and gcc in normal mode.
• The project panel supports many shortcuts modeled after the Vim plugin netrw: navigation with hjkl, open file with o, open file in a new tab with t, etc.
• You can add key bindings to your keymap to navigate "camelCase" names. Head down to the Optional key bindings section to learn how.

Command palette

Vim mode allows you to open Zed's command palette with :. You can then type to access any usual Zed command. Additionally, vim mode adds aliases for popular Vim commands to ensure your muscle memory transfers to Zed. For example, you can write :w or :write to save the file.

Below, you'll find tables listing the commands you can use in the command palette. We put optional characters in square brackets to indicate that you can omit them.

Note: We don't emulate the full power of Vim's command line yet. In particular, commands currently do not support arguments. Please file issues on GitHub as you find things that are missing from the command palette.

File and window management

This table shows commands for managing windows, tabs, and panes. As commands don't support arguments currently, you cannot specify a filename when saving or creating a new file.

Note: The ! character is used to force the command to execute without saving changes or prompting before overwriting a file.

Ex commands

These ex commands open Zed's various panels and windows.

Navigating diagnostics

These commands navigate diagnostics.

Git

These commands interact with the version control system git.

Jump

These commands jump to specific positions in the file.

Replacement

This command replaces text. It emulates the substitute command in vim. The substitute command uses regular expressions, and Zed uses a slightly different syntax than vim. You can learn more about Zed's syntax below, in the regex differences section. Also, by default, Zed always replaces all occurrences of the search pattern in the current line.

Editing

These commands help you edit text.

Command mnemonics

As any Zed command is available, you may find that it's helpful to remember mnemonics that run the correct command. For example:

• :diffs for "toggle all hunk diffs"
• :cpp for "copy path to file"
• :crp for "copy relative path"
• :reveal for "reveal in finder"
• :zlog for "open zed log"
• :clank for "cancel language server work"

Customizing key bindings

In this section, we'll learn how to customize the key bindings of Zed's vim mode. You'll learn:

• How to select the correct context for your new key bindings.
• Useful contexts for vim mode key bindings.
• Common key bindings to customize for extra productivity.

Selecting the correct context

Zed's key bindings are evaluated only when the "context" property matches your location in the editor. For example, if you add key bindings to the "Editor" context, they will only work when you're editing a file. If you add key bindings to the "Workspace" context, they will work everywhere in Zed. Here's an example of a key binding that saves when you're editing a file:

{
  "context": "Editor",
  "bindings": {
    "ctrl-s": "file::Save"
  }
}

Contexts are nested, so when you're editing a file, the context is the "Editor" context, which is inside the "Pane" context, which is inside the "Workspace" context. That's why any key bindings you add to the "Workspace" context will work when you're editing a file. Here's an example:

// This key binding will work when you're editing a file. It comes built into Zed by default as the workspace: save command.
{
  "context": "Workspace",
  "bindings": {
    "ctrl-s": "file::Save"
  }
}

Contexts are expressions. They support boolean operators like && (and) and || (or). For example, you can use the context "Editor && vim_mode == normal" to create key bindings that only work when you're editing a file and you're in vim's normal mode.

Vim mode adds several contexts to the "Editor" context:

Note: Contexts are matched only on one level at a time. So it is possible to use the expression "Editor && vim_mode == normal", but "Workspace && vim_mode == normal" will never match because we set the vim context at the "Editor" level.

Useful contexts for vim mode key bindings

Here's a template with useful vim mode contexts to help you customize your vim mode key bindings. You can copy it and integrate it into your user keymap.

[
  {
    "context": "VimControl && !menu",
    "bindings": {
      // Put key bindings here if you want them to work in normal & visual mode.
    }
  },
  {
    "context": "vim_mode == normal && !menu",
    "bindings": {
      // "shift-y": ["workspace::SendKeystrokes", "y $"] // Use neovim's yank behavior: yank to end of line.
    }
  },
  {
    "context": "vim_mode == insert",
    "bindings": {
      // "j k": "vim::NormalBefore" // In insert mode, make jk escape to normal mode.
    }
  },
  {
    "context": "EmptyPane || SharedScreen",
    "bindings": {
      // Put key bindings here (in addition to the context above) if you want them to
      // work when no editor exists.
      // "space f": "file_finder::Toggle"
    }
  }
]

Note: If you would like to emulate Vim's map commands (nmap, etc.), you can use the action workspace::SendKeystrokes in the correct context.

Optional key bindings

By default, you can navigate between the different files open in the editor with shortcuts like ctrl+w followed by one of hjkl to move to the left, down, up, or right, respectively.

But you cannot use the same shortcuts to move between all the editor docks (the terminal, project panel, assistant panel, ...). If you want to use the same shortcuts to navigate to the docks, you can add the following key bindings to your user keymap.

{
  "context": "Dock",
  "bindings": {
    "ctrl-w h": ["workspace::ActivatePaneInDirection", "Left"],
    "ctrl-w l": ["workspace::ActivatePaneInDirection", "Right"],
    "ctrl-w k": ["workspace::ActivatePaneInDirection", "Up"],
    "ctrl-w j": ["workspace::ActivatePaneInDirection", "Down"]
    // ... or other keybindings
  }
}

Subword motion, which allows you to navigate and select individual words in camelCase or snake_case, is not enabled by default. To enable it, add these bindings to your keymap.

[
  {
    "context": "VimControl && !menu && vim_mode != operator",
    "bindings": {
      "w": "vim::NextSubwordStart",
      "b": "vim::PreviousSubwordStart",
      "e": "vim::NextSubwordEnd",
      "g e": "vim::PreviousSubwordEnd"
    }
  }
]

Vim mode comes with shortcuts to surround the selection in normal mode (ys), but it doesn't have a shortcut to add surrounds in visual mode. By default, shift-s substitutes the selection (erases the text and enters insert mode). To use shift-s to add surrounds in visual mode, you can add the following object to your keymap.

{
  "context": "vim_mode == visual",
  "bindings": {
    "shift-s": [
      "vim::PushOperator",
      {
        "AddSurrounds": {}
      }
    ]
  }
}

The Sneak motion feature allows for quick navigation to any two-character sequence in your text. You can enable it by adding the following keybindings to your keymap. By default, the s key is mapped to vim::Substitute. Adding these bindings will override that behavior, so ensure this change aligns with your workflow preferences.

[
  {
    "context": "vim_mode == normal || vim_mode == visual",
    "bindings": {
      "s": ["vim::PushOperator", { "Sneak": {} }],
      "S": ["vim::PushOperator", { "SneakBackward": {} }]
    }
  }
]

Restoring common text editing keybindings

If you're using vim mode on Linux or Windows, you may find it overrides keybindings you can't live without: ctrl+v to copy, ctrl+f to search, etc. You can restore them by copying this data into your keymap:

{
  "context": "Editor && !menu",
  "bindings": {
    "ctrl-c": "editor::Copy",          // vim default: return to normal mode
    "ctrl-x": "editor::Cut",           // vim default: decrement
    "ctrl-v": "editor::Paste",         // vim default: visual block mode
    "ctrl-y": "editor::Undo",          // vim default: line up
    "ctrl-f": "buffer_search::Deploy", // vim default: page down
    "ctrl-o": "workspace::Open",       // vim default: go back
    "ctrl-a": "editor::SelectAll",     // vim default: increment
  }
},

Changing vim mode settings

You can change the following settings to modify vim mode's behavior:

Here's an example of adding a digraph for the zombie emoji. This allows you to type ctrl-k f z to insert a zombie emoji. You can add as many digraphs as you like.

{
  "vim": {
    "custom_digraphs": {
      "fz": "🧟‍♀️"
    }
  }
}

Here's an example of these settings changed:

{
  "vim": {
    "use_system_clipboard": "never",
    "use_multiline_find": true,
    "use_smartcase_find": true,
    "toggle_relative_line_numbers": true,
    "highlight_on_yank_duration": 50,
    "custom_digraphs": {
      "fz": "🧟‍♀️"
    }
  }
}

Useful core Zed settings for vim mode

Here are a few general Zed settings that can help you fine-tune your Vim experience:

Here's an example of these settings changed:

{
  // Disable cursor blink
  "cursor_blink": false,
  // Use relative line numbers
  "relative_line_numbers": true,
  // Hide the scroll bar
  "scrollbar": { "show": "never" },
  // Prevent the buffer from scrolling beyond the last line
  "scroll_beyond_last_line": "off",
  // Allow the cursor to reach the edges of the screen
  "vertical_scroll_margin": 0,
  "gutter": {
    // Disable line numbers completely:
    "line_numbers": false
  },
  "command_aliases": {
    "W": "w",
    "Wq": "wq",
    "Q": "q"
  }
}

The command_aliases property is a single object that maps keys or key sequences to vim mode commands. The example above defines multiple aliases: W for w, Wq for wq, and Q for q.

Regex differences

Zed uses a different regular expression engine from Vim. This means that you will have to use a different syntax in some cases. Here are the most common differences:

• Capture groups: Vim uses \( and \) to represent capture groups, in Zed these are ( and ). On the flip side, in Vim, ( and ) represent literal parentheses, but in Zed these must be escaped to \( and \).
• Matches: When replacing, Vim uses the backslash character followed by a number to represent a matched capture group. For example, \1. Zed uses the dollar sign instead. So, when in Vim you use \0 to represent the entire match, in Zed the syntax is $0 instead. Same for numbered capture groups: \1 in Vim is $1 in Zed.
• Global option: By default, in Vim, regex searches only match the first occurrence on a line, and you append /g at the end of your query to find all matches. In Zed, regex searches are global by default.
• Case sensitivity: Vim uses /i to indicate a case-insensitive search. In Zed you can either write (?i) at the start of the pattern or toggle case-sensitivity with the shortcut alt-cmd-c|alt-c.

Note: To help with the transition, the command palette will fix parentheses and replace groups for you when you write a Vim-style substitute command, :%s//. So, Zed will convert %s:/\(a\)(b)/\1/ into a search for "(a)(b)" and a replacement of "$1".

For the full syntax supported by Zed's regex engine see the regex crate documentation.