Key bindings

Zed can be configured via a simple JSON file located at ~/.config/zed/keymap.json.

Predefined keymaps

We have a growing collection of pre-defined keymaps in zed repository's keymaps folder. Our current keymaps include:

• Atom
• JetBrains
• SublimeText
• TextMate
• VSCode (default)

These keymaps can be set via the base_keymap setting in your settings.json file. Additionally, if you'd like to work from a clean slate, you can provide "None" to the setting.

Custom key bindings

Accessing custom key bindings

You can open keymap.json via ⌘ + K, ⌘ + S, the command palette, or the Zed > Settings > Open Key Bindings application menu item.

Adding a custom key binding

To customize key bindings, specify a context and the list of bindings to set. Re-mapping an existing binding will clobber the existing binding in favor of the custom one.

An example of adding a set of custom key bindings:

[
  {
    "context": "Editor",
    "bindings": {
      "ctrl-w": "editor::SelectLargerSyntaxNode",
      "ctrl-shift-W": "editor::SelectSmallerSyntaxNode",
      "ctrl-c": "editor::Cancel"
    }
  }
]

You can see more examples in Zed's default.json

There are some key bindings that can't be overridden; we are working on an issue surrounding this.

Disabling a key binding

Use null value to disable a key binding:

[
  {
    "context": "Editor",
    "bindings": {
      "alt-\\": null
    }
  }
]

Keybinding syntax

Zed has the ability to match against not just a single keypress, but a sequence of keys typed in order. Each key in the "bindings" map is a sequence of keypresses separated with a space.

Each key press is a sequence of modifiers followed by a key. The modifiers are:

• ctrl- The control key
• cmd-, win- or super- for the platform modifier (Command on macOS, Windows key on Windows, and the Super key on Linux).
• alt- for alt (option on macOS)
• shift- The shift key
• fn- The function key

The keys can be any single unicode codepoint that your keyboard generates (for example a, 0, £ or ç), or any named key (tab, f1, shift, or cmd).

A few examples:

 "bindings": {
   "cmd-k cmd-s": "zed::OpenKeymap", // matches ⌘-k then ⌘-s
   "space e": "editor::Complete", // type space then e
   "ç": "editor::Complete", // matches ⌥-c
   "shift shift": "file_finder::Toggle", // matches pressing and releasing shift twice
 }

The shift- modifier can only be used in combination with a letter to indicate the uppercase version. For example shift-g matches typing G. Although on many keyboards shift is used to type punctuation characters like (, the keypress is not considered to be modified and so shift-( does not match.

The alt- modifier can be used on many layouts to generate a different key. For example on macOS US keyboard the combination alt-c types ç. You can match against either in your keymap file, though by convention Zed spells this combination as alt-c.

It is possible to match against typing a modifier key on its own. For example shift shift can be used to implement JetBrains search everywhere shortcut. In this case the binding happens on key release instead of key press.

Contexts

Each key binding includes a context which determes when the key binding is active. If no context key is present it is considered to be in the Global context. The context is a boolean expression that can include the following:

• Pane
• Workspace
• Editor
• Menu
• Terminal
• Assistant
• ProjectPanel
• ProjectSearch
• BufferSearch
• Search
• Dock
• EmptyPane
• SharedScreen
• VimControl
• vim_mode == normal
• vim_mode == visual
• vim_mode == insert
• vim_mode == replace
• vim_mode == operator
• vim_mode == waiting

See also: vim context docs

Remapping keys

A common request is to be able to map from one sequence of keys to another. As of Zed 0.124.0 you can do this with the workspace::SendKeystrokes action.

[
  {
    "bindings": {
      "alt-down": ["workspace::SendKeystrokes", "down down down down"],
      "cmd-alt-c": [
        "workspace::SendKeystrokes",
        "cmd-shift-p copy relative path enter"
      ],
      "cmd-alt-r": ["workspace::SendKeystrokes", "cmd-p README enter"]
    }
  },
  {
    "context": "Editor && vim_mode == insert",
    "bindings": {
      "j k": ["workspace::SendKeystrokes", "escape"]
    }
  }
]

There are some limitations to this, notably:

• Any asynchronous operation will not happen until after all your key bindings have been dispatched. For example this means that while you can use a binding to open a file (as in the cmd-alt-r example) you cannot send further keystrokes and hope to have them interpreted by the new view.
• Other examples of asynchronous things are: communicating with a language server, changing the language of a buffer, anything that hits the network.
• There is a limit of 100 simulated keys at a time, this is to avoid accidental infinite recursion if you trigger SendKeystrokes again inside your bindings.

The argument to SendKeystrokes is a space-separated list of keystrokes (using the same syntax as above). Due to the way that keystrokes are parsed, any segment that is not recognized as a keypress will be sent verbatim to the currently focused input field.

Forward keys to terminal

If you're on Linux or Windows, you might find yourself wanting to forward key combinations to the built-in terminal instead of them being handled by Zed.

For example, ctrl-n creates a new tab in Zed on Linux. If you want to send ctrl-n to the built-in terminal when it's focused, add the following to your keymap:

{
  "context": "Terminal",
  "bindings": {
    "ctrl-n": ["terminal::SendKeystroke", "ctrl-n"]
  }
}

Task Key bindings

You can also bind keys to launch Zed Tasks defined in your tasks.json. See the tasks documentation for more.

All key bindings

Global

Editor

Editor (Full Only)

Editor (Auto Height Only)

Pane

Buffer Search Bar

Workspace

Project Panel

Project Search Bar

Terminal

Assistant Editor