Zed v1.18 · settings, keymap contexts, tasks and the agent · 1239 entries

Written for someone who already knows what a language server and a DAP adapter are, and wants the architecture and the configuration model rather than a feature tour. Zed is a native editor in Rust that draws its whole interface on the GPU, keeps every buffer as a CRDT so collaboration is not bolted on, parses with tree-sitter on a background thread, and sandboxes extensions as WebAssembly — and nearly everything distinctive about it follows from those four choices. The guide covers the settings precedence ladder and the two lsp blocks people confuse, how keymap context predicates actually resolve, multibuffers (the feature with no equivalent elsewhere), tasks and runnables, DAP scenarios, the agent panel with its profiles, tool permissions and MCP servers, and it installs Zed on macOS, Windows with PowerShell and Omarchy. Cards 1–15 are the guide; the rest is a filterable index of 1239 entries — 841 default key bindings with their actions and contexts, taken from Zed’s own default-macos.json and default-linux.json, and 282 settings from its settings reference. Press / to jump to the filter box; hover a clipped row for the whole entry.

Dots: macOS and Linux/Windows alike macOS only Linux / Windows only AI — agent, assistant, edit prediction vim or helix mode
Sources: the Zed documentation in zed-industries/zed (docs/src), and the shipped keymaps assets/keymaps/default-macos.json and default-linux.json, read by a script rather than retyped. Checked against Zed v1.18.1 stable, released 4 September 2026. Hover a clipped row for the whole entry.

The Working Guide

Zed as it is actually configured — the architecture, the settings ladder, keymap contexts, tasks, the debugger and the agent

What Zed Actually Is

Rust, a GPU, and a rope

Zed is a native editor written in Rust that draws its entire interface on the GPU. There is no browser engine, no DOM and no JavaScript in the editing path. That one decision explains most of what is distinctive about it — the input latency, the fact that a 100 MB file opens, the fact that the extension API is WebAssembly rather than "run whatever you like in the host process", and the fact that the extension catalogue is a thousand items rather than fifty thousand.

The pieces

LayerWhat it is
GPUIZed’s own UI framework: a retained-mode element tree rendered through Metal on macOS, Vulkan on Linux, DirectX on Windows. Not a widget toolkit binding — the whole thing is theirs.
The bufferA rope over a copy-on-write B-tree ("SumTree"), with the edit history stored as a CRDT. Collaboration is not bolted on: every buffer is already a CRDT whether or not anyone else is connected.
Tree-sitterIncremental parsing, on a background thread, for highlighting, indentation, folding, outline, text objects and structural selection. Syntax is a parse tree here, not a regex cascade.
LSP / DAP clientsLanguage servers and debug adapters are the extension points for language intelligence; Zed downloads and manages the binaries for the common ones.
ExtensionsWebAssembly modules with a narrow, versioned host API — sandboxed, and unable to block the UI thread.
The agentA first-party coding agent in a panel, with tool calling, MCP servers and support for external agents over ACP.

Release channels

Stablethe default. v1.18.1 as of 4 September 2026Previewone week ahead of stable; the same build that becomes itNightlytip of main, rebuilt dailyDevyour own cargo run build

All four can be installed side by side; each keeps its own configuration directory, so a preview build cannot corrupt your stable settings.

The honest trade. You get a fast, coherent editor with real collaboration and a genuinely good agent. You give up the enormous VS Code extension ecosystem, some language coverage, and a settings surface that assumes you are comfortable editing JSON. If your workflow depends on one obscure VS Code extension, that is the whole decision.

Installing Zed

macOS · Windows · Omarchy
macOS

The .dmg from zed.dev is the primary route; Homebrew wraps the same build. The zed CLI is not installed automatically — run cli: install cli binary from the command palette.

# the cask is the same build as the dmg brew install --cask zed # preview channel, side by side with stable brew install --cask zed@preview # then, inside Zed: # cmd-shift-p -> cli: install cli binary # installs /usr/local/bin/zed zed --version
Windows — PowerShell

Windows support went stable during 2025 and is a first-class target now. Winget is the supported install; the CLI ships with the package but its directory may not be on PATH.

winget install -e --id ZedIndustries.Zed # where things live on Windows $env:APPDATA\Zed\settings.json $env:APPDATA\Zed\keymap.json $env:APPDATA\Zed\extensions\ # put the install dir on PATH, then zed --version zed . # uninstall: Settings > Apps > Installed apps
Omarchy / Arch

Zed is in the Arch extra repository, so on Omarchy this is one pacman line. The AUR carries the preview and git builds. The upstream install script works too and puts everything under ~/.local, which is the right answer on an immutable or shared box.

sudo pacman -S zed # AUR alternatives: # zed-preview-bin zed-git # or the upstream script, no root needed curl -f https://zed.dev/install.sh | sh # preview channel: curl -f https://zed.dev/install.sh | ZED_CHANNEL=preview sh # it lands in ~/.local/zed.app and symlinks # ~/.local/bin/zed zed --uninstall

Where configuration lives

macOSLinuxWindows
config root~/Library/Application Support/Zed/~/.config/zed/%APPDATA%\Zed\
settingssettings.json — cmd-, / ctrl-,
keyskeymap.json
per project.zed/settings.json, .zed/tasks.json, .zed/debug.json — commit these
First five minutes. cmd-shift-p is the command palette and it is the whole discovery mechanism — every action on this sheet is reachable from it, and it shows the key binding beside each one. Set "base_keymap" to "VSCode" or "JetBrains" if your fingers already belong to something else, then change one key at a time.

Settings

JSON, and a precedence ladder

Configuration is one JSON file plus overrides. There is a settings UI (zed: open settings), but it writes the same file, and everything on this page assumes the file.

defaultscompiled in; zed: open default settings shows the whole thinguser settings.jsonyour global preferencesproject .zed/settings.jsonper worktree; merged over the user file, and checked into the repo"languages" blockper language, in either file — beats the file-wide valuemodelinea Vim or Emacs modeline in the file itself, if modeline_lines > 0

The shape of a real settings file

{ "theme": "One Dark", "buffer_font_family": "Zed Plex Mono", "buffer_font_size": 15, "ui_font_size": 16, "format_on_save": "on", "formatter": "language_server", "remove_trailing_whitespace_on_save": true, "ensure_final_newline_on_save": true, "tab_size": 2, "soft_wrap": "editor_width", "wrap_guides": [80, 120], "languages": { "Python": { "tab_size": 4, "format_on_save": "off", "language_servers": ["pyright", "!pylsp"] }, "Markdown": { "soft_wrap": "editor_width" } }, "lsp": { "rust-analyzer": { "initialization_options": { "check": { "command": "clippy" }, "cargo": { "features": "all" } } } }, "file_types": { "JSONC": ["*.json"], "Shell Script": [".envrc"] }, "file_scan_exclusions": ["**/.git", "**/target", "**/node_modules"], "telemetry": { "diagnostics": false, "metrics": false } }

Three conventions worth knowing

  • "!server-name" disables a language server in the language_servers array; "..." stands for "and the defaults", so ["ruff", "..."] adds one without replacing the list.
  • Arrays replace, objects merge. Setting file_scan_exclusions throws the defaults away unless you include "...".
  • disable_ai: true turns off every AI feature at once, and is honourable in a project file when a repository must not be sent anywhere.
zed: open default settings is the real reference. It is the complete commented default file — every key, with its shipped value, in one buffer you can search. The index half of this sheet is that file’s documentation, extracted.

Keymap

contexts are the whole idea

keymap.json is an array of blocks. Each block has an optional context predicate and a map of key sequences to actions. Zed evaluates the predicate against a tree of contexts — roughly Workspace > Pane > Editor plus attributes — and the most specific matching binding wins.

[ { "context": "Editor && mode == full && !menu", "bindings": { "cmd-shift-k": "editor::DeleteLine", "cmd-k cmd-s": "zed::OpenKeymap", "ctrl-a": ["pane::DeploySearch", { "replace_enabled": true }], "cmd-1": ["workspace::ActivatePane", 0], "cmd-r": null } }, { "context": "vim_mode == insert", "bindings": { "j k": "vim::NormalBefore" } } ]
PieceRule
modifiersctrl- cmd- alt- shift- fn- super- win-, and secondary- = cmd on macOS, ctrl elsewhere
sequencesspace-separated: "cmd-k cmd-s" is two chords
action, no argsa bare string: "editor::Undo"
action with argsan array: ["workspace::ActivatePane", 0]
unbindnull — and it does not fall through to the parent context
predicates&& || ! (), and X > Y for "Y with X above it"
shift-only meaningful with a letter; punctuation is written as the shifted character

Finding the names

zed: open default keymapthe shipped file for your platform — copy from it, do not guesszed: open keymapyour own filethe command paletteshows the action name and its current binding beside every commanddev: open key context viewlive context tree at the cursor, with every attribute — the debugger for bindingsbase_keymapa setting: VSCode, JetBrains, Sublime, Atom, Emacs, TextMate, Cursor, None
A binding that "does not work" is nearly always a context problem, not a syntax problem. Open the key context view, put the cursor where you expect the binding to fire, and read what is actually active. Editor matches search boxes and commit-message fields too, which is why almost every serious binding wants Editor && mode == full.

Getting Around

four pickers and a tree

Navigation in Zed is fuzzy pickers plus language-server jumps. Learning five keys covers nearly everything.

WhatmacOSLinux / Windows
command palettecmd-shift-pctrl-shift-p
file findercmd-pctrl-p
symbols in this filecmd-shift-octrl-shift-o
symbols in the projectcmd-tctrl-t
project searchcmd-shift-fctrl-shift-f
go to linectrl-gctrl-g
go to definitionf12 / cmd-clickf12 / ctrl-click
find all referencesshift-f12shift-f12
back / forwardctrl-- / ctrl-shift--ctrl-- / ctrl-shift--
project panelcmd-shift-ectrl-shift-e
outline panelcmd-shift-bctrl-shift-b

Things the pickers do that are not obvious

  • The file finder takes :line:col — type main.rs:120 and it opens there.
  • It searches paths, not just names, so src/ha co narrows the way you would hope.
  • A picker result opens as a preview tab (italic title) and is replaced by the next preview unless you edit it or double-click. preview_tabs controls this.
  • cmd-k then a direction opens the result in a split; cmd-k is the pane-management prefix generally.
  • The tab switcher (ctrl-tab) is MRU-ordered, unlike the tab bar.
Project search results are a multibuffer, not a list. That is the next card, and it is the feature most worth understanding.

Multibuffers

the feature with no equivalent

A multibuffer is one editor containing excerpts from many files, each excerpt a live, editable window onto its buffer. Type in it and you are typing in the underlying file. Search-and-replace across a repository stops being a dialog and becomes ordinary editing with the results in front of you.

project searchevery hit, in context, editable in placefind all referencesevery call site as an excerptthe diagnostics viewevery error, with the code around itagent editsthe review view is a multibuffer of the diffgit diff viewevery changed hunk in the project, one buffer

Working in one

editor::ExpandExcerptsshow more lines around an excerpt — expand_excerpt_lines, default 5editor::OpenExcerptsopen the excerpt under the cursor as a normal file tabcmd-enter / ctrl-enterin the search bar, put the results in a multibuffer rather than a listselect all + editmultiple cursors span excerpts, so one edit applies across every file at oncedouble_click_in_multibuffersetting: select (default) or open the excerpt’s file
The workflow worth stealing. cmd-shift-f, search, alt-enter to open every match as a multibuffer, cmd-shift-l (select all occurrences), type once — you have just edited forty files with the change visible on every one before you save. It is the same operation :cdo performs in Vim, except you can see it.

Excerpts are reference-counted views of the same buffers the tabs use, so an unsaved change made in a multibuffer shows up in the file’s own tab immediately, and cmd-s saves everything the multibuffer touched.

Editing

selections, cursors and format-on-save

The editing model is Sublime-descended: multiple selections are the primitive, and most commands act on all of them.

ActionmacOSDoes
add cursor above / belowcmd-alt-up/downa second selection in the same column
select next occurrencecmd-dadd the next match of the selection
select all occurrencescmd-shift-levery match, at once — the bulk-rename that needs no LSP
expand / shrink selectionalt-up / alt-downby syntax node, via tree-sitter
move line up / downctrl-cmd-up/downwith indentation fixed
duplicate linecmd-shift-d
toggle commentcmd-/line comments from the language config
rename symbolf2language-server rename, across the project
code actionscmd-.quick fixes and refactors
formatcmd-shift-iformatter: language server, external command, or prettier
rewrapcmd-k cmd-qrespects allow_rewrap, default comments only
column selectionctrl-alt-dragblockwise selection with the mouse

Formatting, precisely

{ "format_on_save": "on", "formatter": "language_server", "languages": { "JavaScript": { "formatter": { "external": { "command": "prettier", "arguments": ["--stdin-filepath", "{buffer_path}"] } } }, "Python": { "formatter": [ { "code_actions": { "source.organizeImports.ruff": true } }, { "language_server": { "name": "ruff" } } ] } } }

A formatter can be a single value or an array run in order, which is how "organise imports, then format" is expressed. {buffer_path} is substituted for the external command.

Two formatters will fight. If a language server also formats (rust-analyzer, gopls) and you configure an external one, decide which and disable the other — otherwise the result depends on timing, and the diff churns.

Language Servers

and the toolchain problem

Zed downloads and manages language servers for the languages it supports directly and for those an extension adds. You configure them under "lsp" by server name, and choose which run per language.

{ "languages": { "Python": { "language_servers": ["pyright", "ruff", "!pylsp"] }, "TypeScript": { "language_servers": ["vtsls", "..."] } }, "lsp": { "pyright": { "settings": { "python": { "analysis": { "typeCheckingMode": "strict" } } } }, "gopls": { "initialization_options": { "usePlaceholders": true } }, "rust-analyzer": { "binary": { "path": "~/.cargo/bin/rust-analyzer", "arguments": [] } } } }
Key under lsp.<server>Goes to
initialization_optionsthe initialize request — read once at startup
settingsworkspace/didChangeConfiguration — the live settings most servers actually read
binary.path / binary.argumentsuse your own build instead of the managed download
binary.ignore_system_versionforce the managed one even if a system copy exists
enable_lsp_taskslet the server contribute runnables
Which of the two blocks a server reads is server-specific and is the single most common configuration mistake. rust-analyzer reads initialization_options; pyright reads settings; several read both and mean different things by them. Check the server’s own docs, then confirm with dev: open language server logs.

Toolchains and the environment

Zed picks a toolchain per language per worktree — the Python virtualenv, the Node version, the Ruby gemset — and shows it in the status bar. It also reads project environment from direnv when load_direnv is set (default "direct"), which is how a server launched by the editor sees the same PATH your shell does.

toolchain selectorstatus bar, or the command palette — per worktree, rememberedload_direnvdirect (Zed runs direnv itself) or shell_hookdev: open language server logsthe raw LSP traffic; where a broken configuration confesseslsp_document_colors / semantic_tokensopt in to server-driven colour and highlighting
Launched from the Dock, an editor has no shell environment. On macOS this is the classic "works in the terminal, not in the editor" bug. Zed mitigates it by reading your shell’s environment for the project directory, but if a server cannot find a tool, check the status bar toolchain and direnv first.

Tasks

and the arrow in the gutter

A task is a shell command with a label, run in a terminal Zed manages, with the editor’s state substituted into it. Definitions live in tasks.json globally or .zed/tasks.json per project.

[ { "label": "test current file", "command": "pytest", "args": ["$ZED_RELATIVE_FILE"], "cwd": "$ZED_WORKTREE_ROOT", "reveal": "always", "use_new_terminal": false }, { "label": "run $ZED_SYMBOL", "command": "cargo", "args": ["test", "$ZED_SYMBOL"], "tags": ["rust-test"] } ]
task: spawnpick a task from the palettetask: rerunrun the last one again — the key worth binding["task::Spawn", {"task_name": "…"}]bind one task to a key${VAR:default}a default when the variable is unset — the only way to keep a task usable with nothing selected"tags"attach the task to a runnables.scm capture from the language extension

Runnables

The little run arrow beside a test function is not hard-coded. The language extension ships a tree-sitter query, runnables.scm, that captures the nodes a task can be attached to; captures other than @run become $ZED_CUSTOM_<NAME> in the task. That is the whole mechanism, and it is why adding "run this test" to a new language is a query file rather than a plugin.

Tasks are ordinary shell. There is no task-runner DSL, no problem matchers and no dependency graph — if you want a pipeline, write a script and call it. The build field of a debug scenario is the one exception: it runs a task before the debugger starts.

Debugger

DAP, with scenarios instead of launch.json

Zed speaks the Debug Adapter Protocol. Adapters for C, C++, Go, JavaScript, TypeScript, PHP, Python and Rust are built in; Java, Ruby and Swift come from language extensions.

// .zed/debug.json [ { "label": "debug the binary", "adapter": "CodeLLDB", "request": "launch", "program": "$ZED_WORKTREE_ROOT/target/debug/app", "cwd": "$ZED_WORKTREE_ROOT", "build": { "command": "cargo", "args": ["build"] } }, { "label": "attach to node", "adapter": "JavaScript", "request": "attach" } ]

label and adapter are the only fields Zed requires; everything else is passed to the adapter, and task variables are expanded throughout. build embeds a task that must succeed first. For Rust, Go, Python, JavaScript and TypeScript, Zed can generate a scenario from an existing task, which is what the debug arrow in the gutter uses.

debugger: startthe new-process modal, listing scenarios found in the projectf4 / f5start · continuef10 / f11 / shift-f11step over · step into · step outgutter clicktoggle a breakpoint; right-click for log points and conditions"stepping_granularity"line, statement or instruction"save_breakpoints"keep breakpoints across sessions — on by default"inline_values"show variable values inline in the editor"log_dap_communications"the adapter transcript, for when an adapter misbehaves
A debug session that will not start is nearly always the adapter, not Zed. Turn on log_dap_communications, start it again and read the transcript — the adapter says exactly which field it did not like. Adapter binaries are downloaded on first use, so the first start of a session is slower and needs the network.

Terminal, Git and Remote

the three panels

Terminal

ctrl-` toggle the terminal panel"terminal": {"shell"}system, or {"program": …}, or with_arguments"terminal": {"working_directory"}current_project_directory, first_project_directory, always_home, or a path"terminal": {"env"}extra environment for terminals and tasks"terminal": {"detect_venv"}activate the project virtualenv automatically"terminal": {"blinking", "copy_on_select", "line_height"}the usual emulator knobs

Task output lands in this panel; each task can reuse a terminal or take a fresh one (use_new_terminal).

Git

the git panelstaged and unstaged changes, stage/unstage per hunk or per file, commit from the panelthe diff viewevery change in the project as one multibuffer; diff_view_style is split or unifiedgutter hunksclick to expand; restore or stage a single hunk from thereinline blame"git": {"inline_blame": {"enabled": true}}branch pickerswitch, create, and open the git graphgit worktreesfirst-class: a picker, plus a create_worktree task hook for copying .env files in

Remote development

Zed splits into a UI process on your machine and a headless server on the far end; language servers, the file system and tasks all run remotely, and only UI updates cross the wire. It is not SSHFS and not a terminal multiplexer.

zed ssh://user@host/path/to/projectopen a remote project from the CLIthe remote projects pickerthe same thing from the UI; it reads your ~/.ssh/configread_ssh_configsetting; on by defaultthe serverdownloaded and installed automatically, per Zed version, under the remote user’s home
The remote end needs to be able to fetch the server binary the first time, and it must match the client version — which is why a client update briefly breaks a remote project until the new server lands.

The Agent Panel

threads, tools and permissions

Zed ships a first-party coding agent in a dock panel. It is a real agent, not a completion sidebar: it reads and edits files, runs terminal commands and calls tools, and its edits arrive as a reviewable diff.

PieceWhat it does
threadone conversation with its own history and checkpoints; you can restore to a checkpoint, edit a past message and re-run
profilewhich built-in and MCP tools the agent may reach in this thread
tool permissionsallow / deny / confirm per permission-gated tool call
context@-mention files, symbols, threads and web pages; a selection can be sent as context; images too
reviewthe agent’s edits as a multibuffer diff you accept or reject hunk by hunk
terminal threadsan agent that works in a terminal rather than the editor
skills & instructionssince v1.4, packaged reusable instructions (~/.agents/skills/) and always-on project context

Project instructions the agent reads on its own

.rulesZed’s own nameAGENTS.md · AGENT.mdthe cross-tool conventionCLAUDE.md · GEMINI.mdother agents’ files, honoured for compatibility.cursorrules · .windsurfrules · .clinerulesditto.github/copilot-instructions.mdditto — the first matching file wins, in that order

MCP servers

{ "context_servers": { "my-server": { "source": "custom", "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/data"], "env": {} } } }

An MCP server can also arrive as an extension, in which case it is installed from the extension list and configured through the extension’s own settings. Tool calling has to be supported by the model you have selected; Zed shows "No tools" beside a model that cannot.

Edit prediction and the inline assistant

ZetaZed’s open-source edit-prediction model; tab accepts, alt-tab on Linuxedit_predictions.modeeager or subtle — whether a prediction shows before you askedit_predictions_disabled_inlanguage scopes to keep it out of, e.g. ["comment", "string"]inline assistant (ctrl-enter)a prompt over the selection, editing in placeexternal agentsClaude Code, Gemini CLI and others over ACP, in the same panel"disable_ai": trueturn all of it off, globally or per project
Whatever the agent can read, it can send. private_files globs and redact_private_values exist for exactly this; set "disable_ai": true in .zed/settings.json for a repository that must not leave the machine, and remember that a project settings file is the thing your colleagues get too.

Appearance

themes, fonts and the docks
{ "theme": { "mode": "system", "light": "One Light", "dark": "One Dark" }, "icon_theme": "Zed (Default)", "buffer_font_family": "Zed Plex Mono", "buffer_font_size": 15, "buffer_font_features": { "calt": false }, "buffer_line_height": { "custom": 1.6 }, "ui_font_family": "Zed Plex Sans", "ui_font_size": 16, "experimental.theme_overrides": { "editor.background": "#1b1b1fff", "syntax": { "comment": { "font_style": "italic" } } } }
SettingEffect
themea name, or an object with mode/light/dark to follow the system
experimental.theme_overridespatch individual theme keys without forking the theme
buffer_font_featuresOpenType features — "calt": false is how you turn ligatures off
centered_layoutpadding either side; workspace::ToggleCenteredLayout
tab_bar, toolbar, status_bar, gutter, scrollbar, minimapeach an object of booleans — this is where you make the window quiet
bottom_dock_layoutcontained, full, left_aligned, right_aligned
indent_guides, wrap_guides, show_whitespaces, whitespace_mapthe visual aids
reduce_motion, cursor_blink, hide_mouseanimation and pointer behaviour
theme selectorcmd-k cmd-t — live preview as you arrow throughicon theme selectorthe same, for file iconszed: open themethe current theme as JSON, if it is a local onebuffer font sizecmd-= / cmd--; these do not persist unless you pass {"persist": true}

Themes and icon themes are extensions — 352 themes and 25 icon themes in the registry as of this build. The extensions sheet covers writing one.

Diagnosing Zed

four commands
zed --foregroundrun attached to the terminal with verbose logging — the way to see an extension’s outputzed --user-data-dir /tmp/zed-cleana throwaway profile: no settings, no extensions. The fastest bisect there iszed: open logthe log file, in an editor tabdev: open key context viewthe live context tree — why a binding is not firingdev: open language server logsraw LSP traffic per serverdev: open syntax tree viewthe tree-sitter parse of the current buffer — why highlighting or a text object is wrongeditor: copy file locationpath:line, for pasting into an issue

When it is slow

  • Check the worktree first. A project that includes node_modules, target or a build output directory makes every picker slow. file_scan_exclusions and file_scan_depth are the fix, and .gitignore is honoured by default.
  • Turn off the language server and see. "language_servers": [] for the language, restart, and compare — most "Zed is slow" reports are one server indexing.
  • The performance profiler lives behind "instrumentation": {"performance_profiler": {"enabled": true}}.
  • Extensions are WASM and cannot hang the UI thread, but a language server they launch certainly can.

Privacy knobs

"telemetry": {"diagnostics": false, "metrics": false}turn off crash reports and usage metrics"private_files"globs never sent to AI features — .env and friends by default"redact_private_values": truehide the values of those files on screen too"disable_ai": trueevery AI feature offworktree trustZed asks before running project-supplied tasks and configuration from a directory you have not opened before
Bug reports. zed --user-data-dir reproduces it or it does not; if it does, the version from zed --version, the log, and the language-server log are what an issue actually needs. An agent thread can be exported with agent: open active thread as markdown.

Traps

and honest limits
Project settings are executable trust. .zed/settings.json can point a formatter or a language server at an arbitrary binary, and .zed/tasks.json is a list of shell commands. Zed’s worktree-trust prompt exists for this; do not click through it on a repository you have just cloned.
format_on_save plus two formatters churns your diffs. If a language server and an external formatter both claim the file, the result depends on which finishes; pick one per language.
Arrays replace, they do not merge. Setting file_scan_exclusions or language_servers discards the defaults unless you include the "..." element. This is the most common "why did that stop working" after an edit to settings.
null in a keymap does not fall through. Unbinding a key in a context stops it reaching the parent context’s binding as well. If you wanted the outer binding, bind it explicitly.
Preview tabs quietly replace each other. Single-clicking through search results does not accumulate tabs; if you meant to keep one, double-click it or edit it. preview_tabs.enabled: false turns the behaviour off entirely.
Vim mode is not Vim. Macros, visual block and search-and-replace are re-implemented on Zed’s own primitives, and :s takes Zed regex — $1, not \1. Most muscle memory transfers; the corners do not, and there is no Vimscript.
Extensions are not VS Code extensions. The API is WebAssembly with a narrow, versioned surface: languages, grammars, themes, icon themes, snippets, language servers, debug adapters, MCP servers and slash commands. An extension cannot draw its own UI panel. If you need one that does, Zed is not that editor yet.
The zed CLI is not installed for you on macOS. Run cli: install cli binary once, or EDITOR="zed --wait" silently does nothing.
Font size shortcuts do not persist by default. cmd-= is bound to ["zed::IncreaseBufferFontSize", {"persist": false}] — rebind it with "persist": true if you expect the change to survive a restart.
What it is genuinely good at: opening instantly, staying responsive on large files, multibuffer refactors, real-time collaboration that works without a server you run, and an agent panel that is part of the editor rather than a webview bolted to the side.

Binding, Action & Setting Index

Every default key binding with its action and context, and every documented setting — read out of Zed’s own keymaps and settings reference. Type in the filter box, or press /

Editing

193

Editor actions

alt-tabeditor::AcceptEditPrediction
tabeditor::AcceptEditPrediction
ctrl-cmd-downeditor::AcceptNextLineEditPrediction
ctrl-cmd-righteditor::AcceptNextWordEditPrediction
cmd-ctrl-peditor::AddSelectionAbove {"skip_soft_wrap": false}
cmd-alt-upeditor::AddSelectionAbove {"skip_soft_wrap": true}
cmd-ctrl-neditor::AddSelectionBelow {"skip_soft_wrap": false}
cmd-alt-downeditor::AddSelectionBelow {"skip_soft_wrap": true}
shift-backspace · ctrl-h · backspaceeditor::Backspace
shift-tabeditor::Backtab
cmd-k cmd-beditor::BlameHover
escapeeditor::Cancel
tabeditor::ComposeCompletion
entereditor::ConfirmCodeAction
entereditor::ConfirmCompletion
shift-entereditor::ConfirmCompletionReplace
entereditor::ConfirmRename
pageupeditor::ContextMenuFirst
pagedowneditor::ContextMenuLast
down · ctrl-neditor::ContextMenuNext
up · ctrl-peditor::ContextMenuPrevious
cmd-ceditor::Copy
cmd-k peditor::CopyPath
cmd-xeditor::Cut
ctrl-d · deleteeditor::Delete
cmd-shift-keditor::DeleteLine
cmd-backspaceeditor::DeleteToBeginningOfLine
cmd-deleteeditor::DeleteToEndOfLine
ctrl-alt-delete · ctrl-alt-deditor::DeleteToNextSubwordEnd
alt-deleteeditor::DeleteToNextWordEnd {"ignore_newlines": false, "ignore_br…
ctrl-alt-backspace · ctrl-alt-heditor::DeleteToPreviousSubwordStart
alt-backspace · ctrl-weditor::DeleteToPreviousWordStart {"ignore_newlines": false, "ignore_br…
ctrl-cmd-ceditor::DisplayCursorNames
ctrl-alt-shift-ceditor::DisplayCursorNames
alt-shift-downeditor::DuplicateLineDown
alt-shift-upeditor::DuplicateLineUp
shift-f9editor::EditLogBreakpoint
cmd-"editor::ExpandAllDiffHunks
shift-entereditor::ExpandExcerpts
alt-shift-f12editor::FindAllReferences
alt-cmd-[editor::Fold
cmd-k cmd-0editor::FoldAll
cmd-k cmd-1editor::FoldAtLevel_1
cmd-k cmd-2editor::FoldAtLevel_2
cmd-k cmd-3editor::FoldAtLevel_3
cmd-k cmd-4editor::FoldAtLevel_4
cmd-k cmd-5editor::FoldAtLevel_5
cmd-k cmd-6editor::FoldAtLevel_6
cmd-k cmd-7editor::FoldAtLevel_7
cmd-k cmd-8editor::FoldAtLevel_8
cmd-k cmd-9editor::FoldAtLevel_9
cmd-k cmd-[editor::FoldRecursive
cmd-shift-ieditor::Format
ctrl-f12editor::GoToDeclaration
alt-ctrl-f12editor::GoToDeclarationSplit
f12editor::GoToDefinition
alt-f12editor::GoToDefinitionSplit
f8editor::GoToDiagnostic {"severity": {"min": "hint", "max": "…
cmd-f8editor::GoToHunk
alt-.editor::GoToHunk
shift-f12editor::GoToImplementation
cmd-shift-alt-backspaceeditor::GoToNextChange
cmd-shift-backspaceeditor::GoToPreviousChange
shift-f8editor::GoToPreviousDiagnostic {"severity": {"min": "hint", "max": "…
cmd-shift-f8editor::GoToPreviousHunk
alt-,editor::GoToPreviousHunk
cmd-f12editor::GoToTypeDefinition
alt-cmd-f12editor::GoToTypeDefinitionSplit
cmd-k cmd-ieditor::Hover
cmd-]editor::Indent
ctrl-jeditor::JoinLines
ctrl-keditor::KillRingCut
ctrl-yeditor::KillRingYank
ctrl-pagedowneditor::LineDown
ctrl-pageupeditor::LineUp
down · ctrl-neditor::MoveDown
ctrl-b · lefteditor::MoveLeft
alt-downeditor::MoveLineDown
alt-upeditor::MoveLineUp
pagedowneditor::MovePageDown
ctrl-veditor::MovePageDown {"center_cursor": true}
pageupeditor::MovePageUp
ctrl-shift-veditor::MovePageUp {"center_cursor": true}
ctrl-f · righteditor::MoveRight
cmd-up · cmd-homeeditor::MoveToBeginning
ctrl-aeditor::MoveToBeginningOfLine {"stop_at_soft_wraps": false, "stop_a…
cmd-left · homeeditor::MoveToBeginningOfLine {"stop_at_soft_wraps": true, "stop_at…
cmd-| · ctrl-meditor::MoveToEnclosingBracket
cmd-down · cmd-endeditor::MoveToEnd
ctrl-eeditor::MoveToEndOfLine {"stop_at_soft_wraps": false}
cmd-right · endeditor::MoveToEndOfLine {"stop_at_soft_wraps": true}
ctrl-downeditor::MoveToEndOfParagraph
ctrl-alt-right · ctrl-alt-feditor::MoveToNextSubwordEnd
alt-righteditor::MoveToNextWordEnd
ctrl-alt-left · ctrl-alt-beditor::MoveToPreviousSubwordStart
alt-lefteditor::MoveToPreviousWordStart
cmd-upeditor::MoveToStartOfExcerpt
cmd-downeditor::MoveToStartOfNextExcerpt
ctrl-upeditor::MoveToStartOfParagraph
up · ctrl-peditor::MoveUp
entereditor::Newline
alt-entereditor::Newline
ctrl-entereditor::Newline
ctrl-entereditor::Newline
entereditor::Newline
entereditor::Newline
ctrl-enter · shift-entereditor::Newline
shift-enter · entereditor::Newline
entereditor::Newline
entereditor::Newline
ctrl-entereditor::Newline
cmd-shift-entereditor::NewlineAbove
ctrl-shift-entereditor::NewlineBelow
cmd-entereditor::NewlineBelow
alt-tabeditor::NextEditPrediction
tabeditor::NextSnippetTabstop
menu · shift-f10editor::OpenContextMenu
alt-entereditor::OpenExcerpts
alt-entereditor::OpenExcerpts
alt-entereditor::OpenExcerpts
cmd-alt-entereditor::OpenExcerptsSplit
cmd-alt-entereditor::OpenExcerptsSplit
alt-entereditor::OpenSelectionsInMultibuffer
alt-shift-oeditor::OrganizeImports
cmd-[editor::Outdent
cmd-pagedowneditor::PageDown
cmd-pageupeditor::PageUp
cmd-veditor::Paste
alt-shift-tabeditor::PreviousEditPrediction
shift-tabeditor::PreviousSnippetTabstop
cmd-shift-zeditor::Redo
cmd-shift-ueditor::RedoSelection
f2editor::Rename
cmd-k reditor::RevealInFileManager
cmd-k reditor::RevealInFileManager
cmd-k cmd-q · cmd-k qeditor::Rewrap
ctrl-leditor::ScrollCursorCenter
cmd-aeditor::SelectAll
cmd-aeditor::SelectAll
cmd-shift-l · cmd-f2editor::SelectAllMatches
shift-down · ctrl-shift-neditor::SelectDown
cmd-alt-eeditor::SelectEnclosingSymbol
cmd-ctrl-right · ctrl-shift-righteditor::SelectLargerSyntaxNode
shift-left · ctrl-shift-beditor::SelectLeft
cmd-leditor::SelectLine
cmd-deditor::SelectNext {"replace_newest": false}
cmd-k cmd-deditor::SelectNext {"replace_newest": true}
cmd-ctrl-downeditor::SelectNextSyntaxNode
shift-pagedowneditor::SelectPageDown
shift-pageupeditor::SelectPageUp
ctrl-cmd-deditor::SelectPrevious {"replace_newest": false}
cmd-k ctrl-cmd-deditor::SelectPrevious {"replace_newest": true}
cmd-ctrl-upeditor::SelectPreviousSyntaxNode
shift-right · ctrl-shift-feditor::SelectRight
cmd-ctrl-left · ctrl-shift-lefteditor::SelectSmallerSyntaxNode
cmd-shift-upeditor::SelectToBeginning
cmd-shift-left · shift-home · ctrl-shift-aeditor::SelectToBeginningOfLine {"stop_at_soft_wraps": true, "stop_at…
cmd-shift-downeditor::SelectToEnd
cmd-shift-right · shift-end · ctrl-shift-eeditor::SelectToEndOfLine {"stop_at_soft_wraps": true}
ctrl-shift-downeditor::SelectToEndOfParagraph
ctrl-alt-shift-right · ctrl-alt-shift-feditor::SelectToNextSubwordEnd
alt-shift-righteditor::SelectToNextWordEnd
ctrl-alt-shift-left · ctrl-alt-shift-beditor::SelectToPreviousSubwordStart
alt-shift-lefteditor::SelectToPreviousWordStart
cmd-shift-upeditor::SelectToStartOfExcerpt
cmd-shift-downeditor::SelectToStartOfNextExcerpt
ctrl-shift-upeditor::SelectToStartOfParagraph
shift-up · ctrl-shift-peditor::SelectUp
ctrl-cmd-spaceeditor::ShowCharacterPalette
ctrl-spaceeditor::ShowCompletions
alt-tabeditor::ShowEditPrediction
cmd-ieditor::ShowSignatureHelp
ctrl-shift-spaceeditor::ShowWordCompletions
downeditor::SignatureHelpNext
upeditor::SignatureHelpPrevious
tabeditor::Tab
cmd-k cmd-/ · shift-alt-aeditor::ToggleBlockComments
f9editor::ToggleBreakpoint
cmd-.editor::ToggleCodeActions
cmd-/editor::ToggleComments {"advance_downwards": false}
ctrl-cmd-eeditor::ToggleEditPrediction
cmd-k cmd-leditor::ToggleFold
cmd-shift-entereditor::ToggleFoldAll
ctrl-:editor::ToggleInlayHints
cmd-;editor::ToggleLineNumbers
cmd-'editor::ToggleSelectedDiffHunks
cmd-k zeditor::ToggleSoftWrap
ctrl-teditor::Transpose
cmd-zeditor::Undo
cmd-ueditor::UndoSelection
cmd-k cmd-jeditor::UnfoldAll
alt-cmd-]editor::UnfoldLines
cmd-k cmd-]editor::UnfoldRecursive

Navigation & Search

129

Workspace — finding files, symbols and panels

cmd-1workspace::ActivatePane 0
cmd-2workspace::ActivatePane 1
cmd-3workspace::ActivatePane 2
cmd-4workspace::ActivatePane 3
cmd-5workspace::ActivatePane 4
cmd-6workspace::ActivatePane 5
cmd-7workspace::ActivatePane 6
cmd-8workspace::ActivatePane 7
cmd-9workspace::ActivatePane 8
cmd-k cmd-downworkspace::ActivatePaneDown
cmd-k cmd-leftworkspace::ActivatePaneLeft
cmd-k cmd-rightworkspace::ActivatePaneRight
cmd-k cmd-upworkspace::ActivatePaneUp
cmd-shift-aworkspace::AddFolderToProject
cmd-wworkspace::CloseActiveDock
cmd-k cmd-wworkspace::CloseAllItemsAndPanes
ctrl-alt-cmd-wworkspace::CloseInactiveTabsAndPanes
cmd-shift-wworkspace::CloseWindow
cmd-w · escapeworkspace::CloseWindow
cmd-wworkspace::CloseWindow
cmd-wworkspace::CloseWindow
cmd-alt-cworkspace::CopyPath
cmd-alt-cworkspace::CopyPath
cmd-alt-cworkspace::CopyPath
alt-cmd-shift-cworkspace::CopyRelativePath
alt-cmd-shift-cworkspace::CopyRelativePath
alt-cmd-shift-cworkspace::CopyRelativePath
ctrl-alt--workspace::DecreaseActiveDockSize {"px": 0}
ctrl-alt-_workspace::DecreaseOpenDocksSize {"px": 0}
f6 · cmd-f6workspace::FocusNextPart
shift-f6workspace::FocusPreviousPart
ctrl-alt-cmd-fworkspace::FollowNextCollaborator
ctrl-alt-=workspace::IncreaseActiveDockSize {"px": 0}
ctrl-alt-+workspace::IncreaseOpenDocksSize {"px": 0}
cmd-nworkspace::NewFile
new · ctrl-nworkspace::NewFile
cmd-nworkspace::NewFile
cmd-nworkspace::NewTerminal
ctrl-~workspace::NewTerminal
cmd-shift-nworkspace::NewWindow
cmd-oworkspace::Open
ctrl-k ctrl-oworkspace::Open
ctrl-oworkspace::OpenFiles
ctrl-shift-enterworkspace::OpenWithSystem
ctrl-shift-enterworkspace::OpenWithSystem
cmd-k cmd-pworkspace::ReopenLastPicker
ctrl-alt-0workspace::ResetActiveDockSize
ctrl-alt-)workspace::ResetOpenDocksSize
cmd-sworkspace::Save
cmd-alt-sworkspace::SaveAll
cmd-shift-sworkspace::SaveAs
cmd-k sworkspace::SaveWithoutFormat
cmd-k shift-downworkspace::SwapPaneDown
cmd-k shift-leftworkspace::SwapPaneLeft
cmd-k shift-rightworkspace::SwapPaneRight
cmd-k shift-upworkspace::SwapPaneUp
alt-cmd-yworkspace::ToggleAllDocks
cmd-jworkspace::ToggleBottomDock
cmd-bworkspace::ToggleLeftDock
cmd-alt-b · cmd-rworkspace::ToggleRightDock
ctrl-cmd-sworkspace::ToggleWorktreeSecurity
shift-escapeworkspace::ToggleZoom
escapeworkspace::Unfollow

Buffer search

cmd-fbuffer_search::Deploy
cmd-alt-lbuffer_search::Deploy {"selection_search_enabled": true}
cmd-fbuffer_search::Deploy
cmd-fbuffer_search::Deploy
ctrl-hbuffer_search::DeployReplace
escapebuffer_search::Dismiss
tabbuffer_search::FocusEditor
cmd-ebuffer_search::UseSelectionForFind

Project search

alt-cmd-fproject_search::OpenTextFinder
alt-cmd-fproject_search::OpenTextFinder
cmd-enterproject_search::SearchInNew
ctrl-shift-enterproject_search::ToggleAllSearchResults
cmd-shift-enterproject_search::ToggleAllSearchResults
cmd-shift-enterproject_search::ToggleAllSearchResults
alt-find · alt-ctrl-fproject_search::ToggleFilters
cmd-shift-jproject_search::ToggleFilters
cmd-shift-jproject_search::ToggleFilters
cmd-fproject_search::ToggleFocus
escapeproject_search::ToggleFocus
escapeproject_search::ToggleFocus

Search bar

cmd-fsearch::FocusSearch
cmd-fsearch::FocusSearch
cmd-fsearch::FocusSearch
cmd-shift-fsearch::FocusSearch
cmd-fsearch::FocusSearch
downsearch::NextHistoryQuery
downsearch::NextHistoryQuery
upsearch::PreviousHistoryQuery
upsearch::PreviousHistoryQuery
cmd-entersearch::ReplaceAll
cmd-entersearch::ReplaceAll
entersearch::ReplaceNext
entersearch::ReplaceNext
alt-entersearch::SelectAllMatches
alt-entersearch::SelectAllMatches
entersearch::SelectNextMatch
cmd-gsearch::SelectNextMatch
shift-entersearch::SelectPreviousMatch
shift-entersearch::SelectPreviousMatch
cmd-shift-gsearch::SelectPreviousMatch
alt-cmd-csearch::ToggleCaseSensitive
alt-cmd-csearch::ToggleCaseSensitive
cmd-shift-isearch::ToggleIncludeIgnored
alt-cmd-xsearch::ToggleRegex
alt-cmd-xsearch::ToggleRegex
alt-cmd-g · alt-cmd-xsearch::ToggleRegex
alt-cmd-g · alt-cmd-xsearch::ToggleRegex
ctrl-hsearch::ToggleReplace
cmd-shift-hsearch::ToggleReplace
cmd-shift-hsearch::ToggleReplace
cmd-shift-hsearch::ToggleReplace
cmd-alt-lsearch::ToggleSelection
cmd-alt-lsearch::ToggleSelection
alt-cmd-wsearch::ToggleWholeWord
alt-cmd-wsearch::ToggleWholeWord

Tab switcher

ctrl-backspacetab_switcher::CloseSelectedItem
ctrl-tabtab_switcher::Toggle
ctrl-shift-tabtab_switcher::Toggle {"select_last": true}

Outline panel

leftoutline_panel::CollapseSelectedEntry
alt-copy · ctrl-alt-coutline_panel::CopyPath
rightoutline_panel::ExpandSelectedEntry
spaceoutline_panel::OpenSelectedEntry
alt-cmd-routline_panel::RevealInFileManager
cmd-shift-boutline_panel::ToggleFocus

Call hierarchy

cmd-k cmd-hcall_hierarchy::ShowIncomingCalls
cmd-k cmd-hcall_hierarchy::ToggleDirection

Panes, Tabs & Windows

132

Pane and tab management

ctrl-1pane::ActivateItem 0
ctrl-2pane::ActivateItem 1
ctrl-3pane::ActivateItem 2
ctrl-4pane::ActivateItem 3
ctrl-5pane::ActivateItem 4
ctrl-6pane::ActivateItem 5
ctrl-7pane::ActivateItem 6
ctrl-8pane::ActivateItem 7
ctrl-9pane::ActivateItem 8
ctrl-0pane::ActivateLastItem
alt-cmd-right · cmd-}pane::ActivateNextItem
ctrl-tabpane::ActivateNextItem
alt-cmd-left · cmd-{pane::ActivatePreviousItem
ctrl-shift-tabpane::ActivatePreviousItem
cmd-wpane::CloseActiveItem {"close_pinned": false}
ctrl-shift-wpane::CloseActiveItem
cmd-k wpane::CloseAllItems {"close_pinned": false}
cmd-k upane::CloseCleanItems {"close_pinned": false}
cmd-k epane::CloseItemsToTheLeft {"close_pinned": false}
cmd-k tpane::CloseItemsToTheRight {"close_pinned": false}
alt-cmd-tpane::CloseOtherItems {"close_pinned": false}
cmd-shift-fpane::DeploySearch
cmd-shift-fpane::DeploySearch
cmd-shift-hpane::DeploySearch {"replace_enabled": true}
ctrl--pane::GoBack
ctrl--pane::GoBack
ctrl--pane::GoBack
ctrl-_pane::GoForward
cmd-shift-tpane::ReopenClosedItem
cmd-shift-epane::RevealInProjectPanel
cmd-k downpane::SplitDown
ctrl-alt-downpane::SplitDown
cmd-k leftpane::SplitLeft
ctrl-alt-leftpane::SplitLeft
cmd-\pane::SplitRight
cmd-k rightpane::SplitRight
ctrl-alt-right · cmd-dpane::SplitRight
cmd-k uppane::SplitUp
ctrl-alt-uppane::SplitUp
ctrl-shift-pageuppane::SwapItemLeft
ctrl-shift-pagedownpane::SwapItemRight
cmd-k shift-enterpane::TogglePinTab

Application

cmd--zed::DecreaseBufferFontSize {"persist": false}
cmd--zed::DecreaseUiFontSize {"persist": false}
cmd--zed::DecreaseUiFontSize {"persist": false}
cmd-shift-xzed::Extensions
cmd-hzed::Hide
alt-cmd-hzed::HideOthers
cmd-= · cmd-+zed::IncreaseBufferFontSize {"persist": false}
cmd-= · cmd-+zed::IncreaseUiFontSize {"persist": false}
cmd-= · cmd-+zed::IncreaseUiFontSize {"persist": false}
cmd-mzed::Minimize
cmd-k cmd-szed::OpenKeymap
cmd-ezed::OpenKeymapFile
cmd-,zed::OpenSettings
cmd-alt-,zed::OpenSettingsFile
cmd-shift-czed::OpenWorktreeSetupTasks
cmd-qzed::Quit
cmd-0zed::ResetBufferFontSize {"persist": false}
cmd-0zed::ResetUiFontSize {"persist": false}
cmd-0zed::ResetUiFontSize {"persist": false}
fn-f · ctrl-cmd-fzed::ToggleFullScreen

Menus and pickers

cmd-escape · ctrl-escape · ctrl-c · escapemenu::Cancel
escapemenu::Cancel
f10menu::Cancel
escapemenu::Cancel
escapemenu::Cancel
escapemenu::Cancel
escapemenu::Cancel
escapemenu::Cancel
escapemenu::Cancel
escapemenu::Cancel
escapemenu::Cancel
escapemenu::Cancel
entermenu::Confirm
cmd-entermenu::Confirm
entermenu::Confirm
entermenu::Confirm
spacemenu::Confirm
cmd-entermenu::Confirm
entermenu::Confirm
entermenu::Confirm
entermenu::Confirm
cmd-entermenu::Confirm
entermenu::Confirm
spacemenu::Confirm
alt-shift-entermenu::Restart
ctrl-enter · cmd-entermenu::SecondaryConfirm
alt-entermenu::SecondaryConfirm
cmd-k rightmenu::SelectChild
rightmenu::SelectChild
rightmenu::SelectChild
home · shift-pageup · pageup · cmd-upmenu::SelectFirst
end · shift-pagedown · pagedown · cmd-downmenu::SelectLast
tab · ctrl-n · downmenu::SelectNext
down · shift-downmenu::SelectNext
downmenu::SelectNext
downmenu::SelectNext
shift-downmenu::SelectNext
downmenu::SelectNext
downmenu::SelectNext
shift-downmenu::SelectNext
right · lmenu::SelectNext
ctrl-downmenu::SelectNext
cmd-k leftmenu::SelectParent
leftmenu::SelectParent
leftmenu::SelectParent
shift-tab · ctrl-p · upmenu::SelectPrevious
up · shift-upmenu::SelectPrevious
upmenu::SelectPrevious
upmenu::SelectPrevious
shift-upmenu::SelectPrevious
upmenu::SelectPrevious
upmenu::SelectPrevious
shift-upmenu::SelectPrevious
left · hmenu::SelectPrevious
ctrl-shift-tab · ctrl-upmenu::SelectPrevious

Pickers

tabpicker::ConfirmCompletion
alt-enterpicker::ConfirmInput {"secondary": false}
ctrl-alt-enterpicker::ConfirmInput {"secondary": true}
alt-enterpicker::ConfirmInput {"secondary": false}
cmd-alt-enterpicker::ConfirmInput {"secondary": true}

Multiple workspaces

cmd-alt-;multi_workspace::FocusWorkspaceSidebar
cmd-alt-jmulti_workspace::ToggleWorkspaceSidebar

Recent projects

cmd-shift-enterrecent_projects::AddToWorkspace
shift-backspacerecent_projects::RemoveSelected
cmd-krecent_projects::ToggleActionsMenu

Projects

alt-cmd-o · ctrl-rprojects::OpenRecent
ctrl-cmd-oprojects::OpenRemote {"from_existing_connection": false}
ctrl-cmd-shift-oprojects::OpenRemote {"from_existing_connection": true}

Worktrees

cmd-shift-backspaceworktree_picker::DeleteWorktree
cmd-alt-shift-backspaceworktree_picker::ForceDeleteWorktree

Project Panel

23

The file tree

cmd-leftproject_panel::CollapseAllEntries
leftproject_panel::CollapseSelectedEntry
alt-dproject_panel::CompareMarkedFiles
cmd-cproject_panel::Copy
alt-copy · ctrl-alt-cproject_panel::CopyPath
cmd-xproject_panel::Cut
cmd-delete · cmd-alt-backspaceproject_panel::Delete {"skip_prompt": false}
cmd-dproject_panel::Duplicate
cmd-rightproject_panel::ExpandAllEntries
rightproject_panel::ExpandSelectedEntry
alt-cmd-nproject_panel::NewDirectory
cmd-nproject_panel::NewFile
cmd-alt-shift-fproject_panel::NewSearchInDirectory
spaceproject_panel::Open
cmd-vproject_panel::Paste
cmd-shift-zproject_panel::Redo
enter · f2project_panel::Rename
alt-cmd-rproject_panel::RevealInFileManager
cmd-shift-eproject_panel::ToggleFocus
cmd-shift-eproject_panel::ToggleFocus
backspace · deleteproject_panel::Trash {"skip_prompt": false}
cmd-backspaceproject_panel::Trash {"skip_prompt": true}
cmd-zproject_panel::Undo

Git

72

Git actions

cmd-shift-entergit::Amend
cmd-shift-entergit::Amend
cmd-shift-entergit::Amend
cmd-shift-entergit::Amend
ctrl-spacegit::ApplyCurrentStash
cmd-alt-g bgit::Blame
escapegit::Cancel
cmd-entergit::Commit
cmd-entergit::Commit
cmd-entergit::Commit
cmd-entergit::Commit
shift-ctrl-dgit::Diff
ctrl-g dgit::Diff
ctrl-shift-backspacegit::DropCurrentStash
shift-escapegit::ExpandCommitEditor
ctrl-g ctrl-ggit::Fetch
ctrl-g shift-upgit::ForcePush
alt-tabgit::GenerateCommitMessage
alt-tabgit::GenerateCommitMessage
cmd-alt-g mgit::OpenModifiedFiles
ctrl-shift-spacegit::PopCurrentStash
ctrl-g downgit::Pull
ctrl-g shift-downgit::PullRebase
ctrl-g upgit::Push
ctrl-k ctrl-rgit::Restore
cmd-alt-zgit::Restore
cmd-alt-zgit::RestoreAndNext
backspace · deletegit::RestoreFile {"skip_prompt": false}
cmd-backspace · cmd-deletegit::RestoreFile {"skip_prompt": true}
ctrl-g backspacegit::RestoreTrackedFiles
cmd-alt-g rgit::ReviewDiff
cmd-ctrl-ygit::StageAll
cmd-ctrl-ygit::StageAll
alt-ygit::StageAndNext
cmd-ygit::StageAndNext
cmd-ygit::StageFile
shift-spacegit::StageRange
alt-shift-escapegit::ToggleFillCommitEditor
ctrl-alt-ygit::ToggleStaged
cmd-alt-ygit::ToggleStaged
cmd-alt-y · spacegit::ToggleStaged
ctrl-g shift-backspacegit::TrashUntrackedFiles
cmd-ctrl-shift-ygit::UnstageAll
cmd-ctrl-shift-ygit::UnstageAll
alt-shift-ygit::UnstageAndNext
cmd-shift-ygit::UnstageAndNext
cmd-shift-ygit::UnstageFile
cmd-ctrl-wgit::Worktree

Git panel

cmd-1git_panel::ActivateChangesTab
cmd-2git_panel::ActivateHistoryTab
leftgit_panel::CollapseSelectedEntry
rightgit_panel::ExpandSelectedEntry
cmd-upgit_panel::FirstEntry
tab · shift-tab · alt-upgit_panel::FocusChanges
alt-down · tab · shift-tabgit_panel::FocusEditor
cmd-downgit_panel::LastEntry
downgit_panel::NextEntry
upgit_panel::PreviousEntry
ctrl-shift-ggit_panel::ToggleFocus

Git graph

tabgit_graph::FocusNextTabStop
tabgit_graph::FocusNextTabStop
shift-tabgit_graph::FocusPreviousTabStop
shift-tabgit_graph::FocusPreviousTabStop

Branch and ref pickers

cmd-1git_picker::ActivateBranchesTab
cmd-2git_picker::ActivateStashTab

Branch picker

cmd-shift-ibranch_picker::CycleBranchFilter
cmd-shift-backspacebranch_picker::DeleteBranch
cmd-alt-shift-backspacebranch_picker::ForceDeleteBranch
cmd-kbranch_picker::ToggleFilterMenu

Branches

cmd-ctrl-bbranches::OpenRecent

Stash

ctrl-shift-backspacestash_picker::DropStashItem
ctrl-shift-vstash_picker::ShowStashItem

AI & the Agent Panel

124

Agent panel and threads

cmd->agent::AddSelectionToThread
cmd->agent::AddSelectionToThread
cmd->agent::AddSelectionToThread
cmd-alt-yagent::AllowAlways
cmd-yagent::AllowOnce
backspaceagent::ArchiveSelectedThread
shift-backspaceagent::ArchiveSelectedThread
enteragent::Chat
cmd-enteragent::Chat
cmd-enteragent::ChatWithFollow
cmd-alt-backspaceagent::ClearMessageQueue
alt-tabagent::CycleFavoriteModels
alt-tabagent::CycleFavoriteModels
alt-tabagent::CycleFavoriteModels
shift-tabagent::CycleModeSelector
shift-tabagent::CycleModeSelector
ctrl-]agent::CycleNextInlineAssist
ctrl-]agent::CycleNextInlineAssist
ctrl-[agent::CyclePreviousInlineAssist
ctrl-[agent::CyclePreviousInlineAssist
ctrl-'agent::CycleThinkingEffort
escapeagent::DismissThreadSearch
cmd-ctrl-eagent::EditFirstQueuedMessage
shift-alt-escapeagent::ExpandMessageEditor
cmd-y · cmd-alt-yagent::Keep
cmd-y · cmd-alt-yagent::Keep
shift-alt-yagent::KeepAll
shift-alt-yagent::KeepAll
shift-alt-yagent::KeepAll
cmd-alt-pagent::ManageProfiles
cmd-alt-lagent::ManageSkills
cmd-nagent::NewThread
cmd-nagent::NewThread
cmd-nagent::NewThread
ctrl-;agent::OpenAddContextMenu
shift-ctrl-ragent::OpenAgentDiff
shift-ctrl-ragent::OpenAgentDiff
cmd-alt-aagent::OpenPermissionDropdown
cmd-alt-cagent::OpenSettings
cmd-shift-vagent::PasteRaw
cmd-alt-zagent::Reject
cmd-alt-zagent::Reject
shift-alt-zagent::RejectAll
shift-alt-zagent::RejectAll
shift-alt-zagent::RejectAll
cmd-alt-zagent::RejectOnce
cmd-shift-backspaceagent::RemoveFirstQueuedMessage
backspaceagent::RemoveSelectedThread
shift-backspaceagent::RemoveSelectedThread
cmd-shift-backspaceagent::RemoveSelectedThread
shift-ragent::RenameSelectedThread
down · ctrl-alt-downagent::ScrollOutputLineDown
ctrl-alt-downagent::ScrollOutputLineDown
up · ctrl-alt-upagent::ScrollOutputLineUp
ctrl-alt-upagent::ScrollOutputLineUp
pagedown · ctrl-pagedownagent::ScrollOutputPageDown
ctrl-pagedownagent::ScrollOutputPageDown
pagedown · ctrl-pagedownagent::ScrollOutputPageDown
pageup · ctrl-pageupagent::ScrollOutputPageUp
ctrl-pageupagent::ScrollOutputPageUp
pageup · ctrl-pageupagent::ScrollOutputPageUp
end · ctrl-endagent::ScrollOutputToBottom
ctrl-endagent::ScrollOutputToBottom
ctrl-endagent::ScrollOutputToBottom
shift-pagedown · ctrl-alt-pagedownagent::ScrollOutputToNextMessage
ctrl-alt-pagedownagent::ScrollOutputToNextMessage
shift-pageup · ctrl-alt-pageupagent::ScrollOutputToPreviousMessage
ctrl-alt-pageupagent::ScrollOutputToPreviousMessage
home · ctrl-homeagent::ScrollOutputToTop
ctrl-homeagent::ScrollOutputToTop
ctrl-homeagent::ScrollOutputToTop
cmd-gagent::SelectNextThreadMatch
enteragent::SelectNextThreadMatch
cmd-shift-gagent::SelectPreviousThreadMatch
shift-enteragent::SelectPreviousThreadMatch
shift-enteragent::SelectPreviousThreadMatch
cmd-shift-enteragent::SendImmediately
cmd-shift-alt-enteragent::SendNextQueuedMessage
cmd-alt-.agent::ToggleFastMode
cmd-?agent::ToggleFocus
cmd-alt-/agent::ToggleModelSelector
cmd-alt-/agent::ToggleModelSelector
cmd-alt-shift-nagent::ToggleNewThreadMenu
cmd-alt-magent::ToggleOptionsMenu
cmd-iagent::ToggleProfileSelector
cmd-iagent::ToggleProfileSelector
cmd-fagent::ToggleSearch
cmd-fagent::ToggleSearch
cmd-fagent::ToggleSearch
cmd-ctrl-sagent::ToggleSteerFirstQueuedMessage
cmd-alt-'agent::ToggleThinkingEffortMenu
cmd-alt-kagent::ToggleThinkingMode
shift-alt-uagent::UndoLastReject

Agents sidebar

cmd-fagents_sidebar::FocusSidebarFilter
cmd-nagents_sidebar::NewThreadInGroup
cmd-gagents_sidebar::ToggleThreadHistory
ctrl-tabagents_sidebar::ToggleThreadSwitcher
ctrl-shift-tabagents_sidebar::ToggleThreadSwitcher {"select_last": true}
ctrl-tabagents_sidebar::ToggleThreadSwitcher
ctrl-shift-tabagents_sidebar::ToggleThreadSwitcher {"select_last": true}
ctrl-tabagents_sidebar::ToggleThreadSwitcher
ctrl-shift-tabagents_sidebar::ToggleThreadSwitcher {"select_last": true}

Assistant

ctrl-enterassistant::InlineAssist
ctrl-enterassistant::InlineAssist

Inline assistant

ctrl-shift-backspaceinline_assistant::ThumbsDownResult
cmd-shift-backspaceinline_assistant::ThumbsDownResult
ctrl-shift-enterinline_assistant::ThumbsUpResult
cmd-shift-enterinline_assistant::ThumbsUpResult

Edit prediction (Zeta)

escapezeta::FocusPredictions
shift-downzeta::NextEdit
rightzeta::PreviewPrediction
shift-upzeta::PreviousEdit
cmd-shift-backspacezeta::ThumbsDownActivePrediction
cmd-shift-backspacezeta::ThumbsDownActivePrediction
cmd-shift-enterzeta::ThumbsUpActivePrediction
cmd-shift-enterzeta::ThumbsUpActivePrediction

Edit prediction

ctrl-cmd-zedit_prediction::RatePredictions
ctrl-cmd-iedit_prediction::ToggleMenu

Skills

tabskill_creator::FocusNextField
tabskill_creator::FocusNextField
shift-tabskill_creator::FocusPreviousField
shift-tabskill_creator::FocusPreviousField
cmd-enterskill_creator::SaveSkill
cmd-enterskill_creator::SaveSkill

Terminal & Tasks

45

Terminal

cmd-kterminal::Clear
cmd-cterminal::Copy
cmd-vterminal::Paste
ctrl-cmd-vterminal::PasteText
cmd-alt-rterminal::RerunTask
shift-downterminal::ScrollLineDown
shift-upterminal::ScrollLineUp
shift-pagedown · cmd-downterminal::ScrollPageDown
shift-pageup · cmd-upterminal::ScrollPageUp
shift-end · cmd-endterminal::ScrollToBottom
shift-home · cmd-hometerminal::ScrollToTop
cmd-leftterminal::SendKeystroke "ctrl-a"
ctrl-bterminal::SendKeystroke "ctrl-b"
ctrl-cterminal::SendKeystroke "ctrl-c"
cmd-rightterminal::SendKeystroke "ctrl-e"
cmd-deleteterminal::SendKeystroke "ctrl-k"
ctrl-oterminal::SendKeystroke "ctrl-o"
ctrl-qterminal::SendKeystroke "ctrl-q"
ctrl-rterminal::SendKeystroke "ctrl-r"
cmd-backspaceterminal::SendKeystroke "ctrl-u"
ctrl-backspaceterminal::SendKeystroke "ctrl-w"
downterminal::SendKeystroke "down"
enterterminal::SendKeystroke "enter"
escapeterminal::SendKeystroke "escape"
pagedownterminal::SendKeystroke "pagedown"
pageupterminal::SendKeystroke "pageup"
upterminal::SendKeystroke "up"
alt-.terminal::SendText "\u001b."
ctrl-deleteterminal::SendText "\u001b[3;5~"
alt-left · alt-bterminal::SendText "\u001bb"
alt-deleteterminal::SendText "\u001bd"
alt-right · alt-fterminal::SendText "\u001bf"
ctrl-cmd-spaceterminal::ShowCharacterPalette
ctrl-shift-spaceterminal::ToggleViMode

Tasks

ctrl-alt-r · alt-ttask::Rerun
ctrl-shift-rtask::Rerun {"reevaluate_context": false}
cmd-alt-rtask::Rerun {"reevaluate_context": false}
alt-shift-ttask::Spawn
alt-shift-rtask::Spawn {"reveal_target": "center"}
cmd-shift-rtask::Spawn
ctrl-alt-shift-rtask::Spawn {"reveal_target": "center"}

New process modal

cmd-3new_process_modal::ActivateAttachTab
cmd-2new_process_modal::ActivateDebugTab
cmd-4new_process_modal::ActivateLaunchTab
cmd-1new_process_modal::ActivateTaskTab

Debugger

23

Debug session

f5debugger::Continue
rightdebugger::NextBreakpointProperty
f6debugger::Pause
leftdebugger::PreviousBreakpointProperty
f5debugger::Rerun
shift-cmd-f5debugger::RerunSession
f4debugger::Start
f11 · ctrl-f11debugger::StepInto
shift-f11debugger::StepOut
f7 · f10debugger::StepOver
shift-f5debugger::Stop
spacedebugger::ToggleEnableBreakpoint
shift-alt-escapedebugger::ToggleExpandItem
cmd-idebugger::ToggleSessionPicker
cmd-tdebugger::ToggleThreadPicker
backspacedebugger::UnsetBreakpoint

Variable list

alt-entervariable_list::AddWatch
leftvariable_list::CollapseSelectedEntry
cmd-alt-cvariable_list::CopyVariableName
cmd-cvariable_list::CopyVariableValue
entervariable_list::EditVariable
rightvariable_list::ExpandSelectedEntry
delete · backspacevariable_list::RemoveWatch

Diagnostics, Notebooks & Viewers

46

Diagnostics

cmd-shift-mdiagnostics::Deploy
ctrl-rdiagnostics::ToggleDiagnosticsRefresh

Notebooks

cmd-mnotebook::AddCodeBlock
cmd-mnotebook::AddCodeBlock
cmd-shift-mnotebook::AddMarkdownBlock
cmd-shift-mnotebook::AddMarkdownBlock
d d · backspacenotebook::DeleteCell
escapenotebook::EnterCommandMode
enternotebook::EnterEditMode
cmd-cnotebook::InterruptKernel
alt-downnotebook::MoveCellDown
alt-downnotebook::MoveCellDown
alt-upnotebook::MoveCellUp
alt-upnotebook::MoveCellUp
cmd-shift-rnotebook::RestartKernel
cmd-shift-rnotebook::RestartKernel
cmd-enternotebook::Run
cmd-enternotebook::Run
cmd-shift-enternotebook::RunAll
cmd-shift-enternotebook::RunAll
shift-enternotebook::RunAndAdvance
shift-enternotebook::RunAndAdvance

REPL

ctrl-shift-enterrepl::Run
ctrl-alt-enterrepl::RunInPlace

Markdown preview

cmd-shift-vmarkdown::CloseAndReturnToEditor
cmd-cmarkdown::Copy
cmd-cmarkdown::CopyAsMarkdown
cmd-shift-vmarkdown::OpenPreview
cmd-k vmarkdown::OpenPreviewToTheSide
downmarkdown::ScrollDown
alt-downmarkdown::ScrollDownByItem
pagedownmarkdown::ScrollPageDown
pageupmarkdown::ScrollPageUp
cmd-downmarkdown::ScrollToBottom
cmd-upmarkdown::ScrollToTop
upmarkdown::ScrollUp
alt-upmarkdown::ScrollUpByItem

Image viewer

cmd-shift-0image_viewer::FitToView
cmd-0image_viewer::ResetZoom
cmd-= · cmd-+image_viewer::ZoomIn
cmd--image_viewer::ZoomOut
cmd-1image_viewer::ZoomToActualSize

SVG viewer

cmd-shift-vsvg::OpenPreview
cmd-k vsvg::OpenPreviewToTheSide

Tabular data

cmd-shift-vtabular_data::OpenPreview
cmd-k vtabular_data::OpenPreviewToTheSide

Settings, Keymap & Collaboration

54

Settings window

leftsettings_editor::CollapseNavEntry
rightsettings_editor::ExpandNavEntry
ctrl-1settings_editor::FocusFile 0
ctrl-2settings_editor::FocusFile 1
ctrl-3settings_editor::FocusFile 2
ctrl-4settings_editor::FocusFile 3
ctrl-5settings_editor::FocusFile 4
ctrl-6settings_editor::FocusFile 5
ctrl-7settings_editor::FocusFile 6
ctrl-8settings_editor::FocusFile 7
ctrl-9settings_editor::FocusFile 8
ctrl-0settings_editor::FocusFile 9
homesettings_editor::FocusFirstNavEntry
endsettings_editor::FocusLastNavEntry
cmd-}settings_editor::FocusNextFile
down · tabsettings_editor::FocusNextNavEntry
pagedownsettings_editor::FocusNextRootNavEntry
cmd-{settings_editor::FocusPreviousFile
up · shift-tabsettings_editor::FocusPreviousNavEntry
pageupsettings_editor::FocusPreviousRootNavEntry
cmd-msettings_editor::Minimize
cmd-,settings_editor::OpenCurrentFile
left · cmd-shift-esettings_editor::ToggleFocusNav

Keymap editor

cmd-ckeymap_editor::CopyAction
cmd-shift-ckeymap_editor::CopyContext
alt-enterkeymap_editor::CreateBinding
enterkeymap_editor::EditBinding
cmd-kkeymap_editor::OpenCreateKeybindingModal
cmd-tkeymap_editor::ShowMatchingKeybinds
cmd-alt-ckeymap_editor::ToggleConflictFilter
cmd-alt-fkeymap_editor::ToggleKeystrokeSearch
cmd-alt-fkeymap_editor::ToggleKeystrokeSearch

Keystroke input

deletekeystroke_input::ClearKeystrokes
enterkeystroke_input::StartRecording
escape escape escapekeystroke_input::StopRecording

Collaboration panel

spacecollab_panel::InsertSpace
alt-downcollab_panel::MoveChannelDown
alt-upcollab_panel::MoveChannelUp
alt-entercollab_panel::OpenSelectedChannelNotes
ctrl-backspacecollab_panel::Remove
cmd-shift-ccollab_panel::ToggleFocus
ctrl-shift-ccollab_panel::ToggleFocus
shift-entercollab_panel::ToggleSelectedChannelFavorite

Application menu

leftapp_menu::ActivateMenuLeft
rightapp_menu::ActivateMenuRight
f10app_menu::OpenApplicationMenu "Zed"

Onboarding

cmd-enteronboarding::Finish
alt-shift-aonboarding::OpenAccount
alt-tabonboarding::SignIn

Developer tools

alt-leftdev::EditPredictionContextGoBack
alt-rightdev::EditPredictionContextGoForward
ctrl-alt-shift-odev::ResetFrameOverlayStats
ctrl-alt-shift-pdev::ToggleFpsOverlay
cmd-alt-idev::ToggleInspector

Vim & Helix Mode

38

Zed’s own additions, and the settings block

"vim_mode": trueturn it on
gd / gD / gygo to definition / declaration / type definition
g.code actions menu
cdrename the symbol under the cursor
]c / [cnext / previous git hunk
do / dpexpand a diff hunk / restore it
]m / [mnext / previous method — via tree-sitter, not a regex
]s / [snext / previous section
]x / [xselect a smaller / larger syntax node
af / ifaround / inside a function
ac / icaround / inside a class or definition
at / itaround / inside an HTML-like tag
ai / ii / aIindent-level text objects
gl / gL / gaadd a cursor at the next / previous / every copy of the word
g/project-wide search
ctrl-w gdgo to definition in a split
ys / cs / dssurround: add, change, delete
gcc / gccomment a line / a selection
cxexchange two regions
gRreplace with register
ctrl-x ctrl-oopen the completion menu without leaving insert mode
:w :q :wqa :vs :spthe ex commands Zed implements
:E :G :te :AIopen the project, git, terminal and agent panels
:cn / :cpnext / previous diagnostic
:s/foo/bar/gsubstitute — but in Zed regex, not Vim regex
"vim": {"use_system_clipboard"}always / never / on_yank
"vim": {"default_mode"}the mode a buffer opens in
"vim": {"use_smartcase_find"}lowercase f/t ignores case
"vim": {"use_regex_search"}treat / patterns as regex — on by default
"vim": {"gdefault"}:s is global without /g
"vim": {"toggle_relative_line_numbers"}relative in normal, absolute in insert
"vim": {"highlight_on_yank_duration"}yank flash, in ms; 0 disables — default 200
"vim": {"custom_digraphs"}your own ctrl-k digraphs
vim::PushSneaktwo-character sneak motion — unbound by default
vim::NextSubwordStartcamelCase-aware w — unbound by default
vim::AnyQuotes / vim::AnyBracketsinnermost-first quote and bracket objects
vim::HelixJumpToWordHelix-style jump labels
command_aliasesmap :W to :w and friends

Settings

282

Top-level keys of settings.json

active_pane_modifiersStyling settings applied to the active pane.
bottom_dock_layoutControl the layout of the bottom dock, relative to the left and right docks.
agent_font_sizeThe font size for text in the agent panel. Inherits the UI font size if unset.
allow_rewrapControls where the {#action editor::Rewrap} action is allowed in the current language scope
auto_indentWhether indentation should be adjusted based on context while typing. This can be specified on a per-language basis.
auto_indent_on_pasteWhether indentation of pasted content should be adjusted based on the context
auto_install_extensionsDefine extensions to install automatically or never install.
auto_update_extensionsDisable auto-updates for specific extensions.
autosaveWhen to automatically save edited buffers.
autoscroll_on_clicksWhether to scroll when clicking near the edge of the visible text area.
auto_signature_helpShow method signatures in the editor when inside parentheses.
auto_updateWhether or not to automatically check for updates.
base_keymapBase key bindings scheme. Base keymaps can be overridden with user keymaps.
buffer_font_familyThe name of a font to use for rendering text in the editor.
buffer_font_featuresThe OpenType features to enable for text in the editor.
buffer_font_fallbacksSet the buffer text's font fallbacks, this will be merged with the platform's default fallbacks.
buffer_font_sizeThe default font size for text in the editor.
buffer_font_weightThe default font weight for text in the editor.
buffer_line_heightThe default line height for text in the editor.
centered_layoutConfiguration for the centered layout mode.
close_on_file_deleteWhether to automatically close editor tabs when their corresponding files are deleted from disk.
close_panel_on_toggleWhether invoking a panel's `ToggleFocus` action while the panel is already focused closes the panel, instead of just moving focus back to the editor. This only applies to a panel's focus-toggle action, not to its regular visibility-toggle action.
code_lensWhether and how to display code lenses from language servers. Code lenses show contextual information such as reference counts, implementations, and other metadata provided by the language server.
confirm_quitWhether or not to prompt the user to confirm before closing the application.
diagnostics_max_severityWhich level to use to filter out diagnostics displayed in the editor
diff_view_styleHow to display diffs in the editor.
disable_aiWhether to disable all AI features in Zed
load_direnvSettings for [direnv](https://direnv.net/) integration. Requires `direnv` to be installed. `direnv` integration makes it possible to use the environment variables set by a `direnv` configuration to detect some language servers in `$PATH` instead of installing them. It also allows for those environment variables to be used in tasks.
double_click_in_multibufferWhat to do when multibuffer is double clicked in some of its excerpts (parts of singleton buffers)
drop_target_sizeRelative size of the drop target in the editor that will open dropped file as a split pane (0-0.5). For example, 0.25 means if you drop onto the top/bottom quarter of the pane a new vertical split will be used, if you drop onto the left/right quarter of the pane a new horizontal split will be used.
edit_predictionsSettings for edit predictions.
edit_predictions_disabled_inA list of language scopes in which edit predictions should be disabled.
current_line_highlightHow to highlight the current line in the editor.
selection_highlightWhether to highlight all occurrences of the selected text in an editor.
rounded_selectionWhether the text selection should have rounded corners.
cursor_blinkWhether or not the cursor blinks.
cursor_shapeCursor shape for the default editor.
gutterSettings for the editor gutter
reduce_motionWhether to reduce non-essential motion in the UI, such as loading spinners and pulsating labels, by rendering them in a static state.
snippet_sort_orderDetermines how snippets are sorted relative to other completion items.
scrollbarWhether or not to show the editor scrollbar and various elements in it.
minimapSettings related to the editor's minimap, which provides an overview of your document.
tabsConfiguration for the editor tabs.
toolbarWhether or not to show various elements in the editor toolbar.
use_system_window_tabsWhether to allow windows to tab together based on the user’s tabbing preference (macOS only).
fullscreen_modeWhich fullscreen mode the `zed::ToggleFullScreen` action enters (macOS only).
enable_language_serverWhether or not to use language servers to provide code intelligence.
ensure_final_newline_on_saveRemoves any lines containing only whitespace at the end of the file and ensures just one newline at the end.
line_endingHow line endings should be handled for new files and during format and save. This can be specified on a per-language basis.
expand_excerpt_linesThe default number of lines to expand excerpts in the multibuffer by
excerpt_context_linesThe number of lines of context to provide when showing excerpts in the multibuffer.
extend_comment_on_newlineWhether to start a new line with a comment when a previous line is a comment as well.
status_barControl various elements in the status bar. Note that some items in the status bar have their own settings set elsewhere.
lspConfiguration for language servers.
global_lsp_settingsConfiguration for global LSP settings that apply to all language servers
lsp_highlight_debounceThe debounce delay in milliseconds before querying highlights from the language server based on the current cursor location.
featuresFeatures that can be globally enabled or disabled
focus_follows_mouseWhether the focused panel follows the mouse location.
format_on_saveWhether or not to perform a buffer format before saving.
formatterHow to perform a buffer format.
use_autocloseWhether to automatically add matching closing characters when typing opening parenthesis, bracket, brace, single or double quote characters.
always_treat_brackets_as_autoclosedControls how the editor handles the autoclosed characters.
file_scan_exclusionsFiles or globs of files that will be excluded by Zed entirely. They will be skipped during file scans, file searches, and not be displayed in the project file tree. Overrides `file_scan_inclusions`.
file_scan_inclusionsFiles or globs of files that will be included by Zed, even when ignored by git. This is useful for files that are not tracked by git, but are still important to your project. Note that globs that are overly broad can slow down Zed's file scanning. `file_scan_exclusions` takes precedence over these inclusions.
file_scan_depthMaximum directory depth that Zed eagerly indexes outside of git repositories. Directories at this depth or deeper are indexed on demand: when expanded in the project panel or when a file inside them is opened. Contents of directories that were not indexed yet are invisible to the file finder and project search. When directories get deferred, the status bar of the affected window shows a brief "Partial file index" message. Set to `0` to always index everything eagerly and activate all git repositories immediately.
scan_symlinksWhen to scan content of linked directories.
file_typesConfigure how Zed selects a language for a file based on its filename or extension. Supports glob entries.
diagnosticsConfiguration for diagnostics-related features.
gitConfiguration for git-related features.
go_to_definition_fallbackWhat to do when the {#action editor::GoToDefinition} action fails to find a definition
go_to_definition_scroll_strategyHow to scroll the target into view when navigating to a definition or reference (e.g. {#action editor::GoToDefinition}, {#action editor::GoToTypeDefinition}, {#action editor::FindAllReferences}).
hard_tabsWhether to indent lines using tab characters or multiple spaces.
helix_modeWhether or not to enable Helix mode. Enabling `helix_mode` also enables `vim_mode`. See the [Helix documentation](../helix.md) for more details.
indent_guidesConfiguration related to indent guides. Indent guides can be configured separately for each language.
hover_popover_enabledWhether or not to show the informational hover box when moving the mouse over symbols in the editor.
hover_popover_delayTime to wait in milliseconds before showing the informational hover box. This delay also applies to auto signature help when `auto_signature_help` is enabled.
hover_popover_stickyWhether the hover popover sticks when the mouse moves toward it, allowing interaction with its contents before it disappears.
hover_popover_hiding_delayTime to wait in milliseconds before hiding the hover popover after the mouse moves away from the hover target. Only applies when `hover_popover_sticky` is enabled.
icon_themeThe icon theme setting can be specified in two forms - either as the name of an icon theme or as an object containing the `mode`, `dark`, and `light` icon themes for files/folders inside Zed.
image_viewerSettings for image viewer functionality
inlay_hintsConfiguration for displaying extra text with hints in the editor.
journalConfiguration for the journal.
jsx_tag_auto_closeWhether to automatically close JSX tags
language_detectionWhether to automatically detect the language of an untitled buffer from its contents. Languages explicitly selected from the language selector are not changed.
languagesConfiguration for specific languages.
language_modelsConfiguration for language model providers
line_indicator_formatFormat for line indicator in the status bar
linked_editsWhether to perform linked edits of associated ranges, if the language server supports it. For example, when editing opening `<html>` tag, the contents of the closing `</html>` tag will be edited as well.
lsp_document_colorsHow to render LSP `textDocument/documentColor` colors in the editor
lsp_document_linksWhether to query and display LSP `textDocument/documentLink` links in the editor
max_tabsMaximum number of tabs to show in the tab bar
middle_click_pasteEnable middle-click paste on Linux
multi_cursor_modifierDetermines the modifier to be used to add multiple cursors with the mouse. The open hover link mouse gestures will adapt such that it does not conflict with the multicursor modifier.
nodeConfiguration for Node.js integration
proxyConfigure a network proxy for Zed.
on_last_window_closedWhat to do when the last window is closed
on_new_windowWhat to show when opening a new window.
instrumentationConfiguration for developer-oriented instrumentation tools (profilers, tracers, etc.) that can be toggled at runtime.
profilesConfiguration profiles that can be temporarily applied on top of existing settings or Zed's defaults.
preview_tabs
pane_split_direction_horizontalThe direction that you want to split panes horizontally
pane_split_direction_verticalThe direction that you want to split panes vertically
preferred_line_lengthThe column at which to soft-wrap lines, for buffers where soft-wrap is enabled.
private_filesGlobs to match against file paths to determine if a file is private
projects_online_by_defaultWhether or not to show the online projects view by default.
read_ssh_configWhether to read SSH configuration files
redact_private_valuesHide the values of variables from visual display in private files
relative_line_numbersWhether to show relative line numbers in the gutter
remove_trailing_whitespace_on_saveWhether or not to remove any trailing whitespace from lines of a buffer before saving it.
resize_all_panels_in_dockWhether to resize all the panels in a dock when resizing the dock. Can be a combination of "left", "right" and "bottom".
restore_on_file_reopenWhether to attempt to restore previous file's state when opening it again. The state is stored per pane.
restore_on_startupControls session restoration on startup.
scroll_beyond_last_lineWhether the editor will scroll beyond the last line
scroll_sensitivityScroll sensitivity multiplier. This multiplier is applied to both the horizontal and vertical delta values while scrolling.
searchSearch options to enable by default when opening new project and buffer searches.
search_wrapIf `search_wrap` is disabled, search results do not wrap around the end of the file
seed_search_query_from_cursorWhen to populate a new search's query based on the text under the cursor.
semantic_tokensControls how semantic tokens from language servers are used for syntax highlighting.
document_folding_rangesControls whether folding ranges from language servers are used instead of tree-sitter and indent-based folding. Tree-sitter and indent-based folding is the default; it is used as a fallback when LSP folding data is not returned or this setting is turned off.
document_symbolsControls the source of document symbols used for outlines and breadcrumbs. This is an LSP feature — when enabled, tree-sitter is not used for document symbols, and the language server's `textDocument/documentSymbol` response is used instead.
use_smartcase_searchWhen enabled, automatically adjusts search case sensitivity based on your query. If your search query contains any uppercase letters, the search becomes case-sensitive; if it contains only lowercase letters, the search becomes case-insensitive. \ This applies to both in-file searches and project-wide searches.
show_call_status_iconWhether or not to show the call status icon in the status bar.
completionsControls how completions are processed for this language.
show_completions_on_inputWhether or not to show completions as you type.
show_completion_documentationWhether to display inline and alongside documentation for items in the completions menu.
show_edit_predictionsWhether to show edit predictions as you type or manually by triggering `editor::ShowEditPrediction`.
show_whitespacesWhether or not to render whitespace characters in the editor.
whitespace_mapSpecify the characters used to render whitespace when show_whitespaces is enabled.
soft_wrapWhether or not to automatically wrap lines of text to fit editor / preferred width.
show_wrap_guidesWhether to show wrap guides (vertical rulers) in the editor. Setting this to true will show a guide at the 'preferred_line_length' value if 'soft_wrap' is set to 'preferred_line_length', and will show any additional guides as specified by the 'wrap_guides' setting.
use_on_type_formatWhether to use additional LSP queries to format (and amend) the code after every "trigger" symbol input, defined by LSP server capabilities
use_auto_surroundWhether to automatically surround selected text when typing opening parenthesis, bracket, brace, single or double quote characters. For example, when you select text and type '(', Zed will surround the text with ().
use_system_path_promptsWhether to use the system provided dialogs for Open and Save As. When set to false, Zed will use the built-in keyboard-first pickers.
use_system_promptsWhether to use the system provided dialogs for prompts, such as confirmation prompts. When set to false, Zed will use its built-in prompts. Note that on Linux, this option is ignored and Zed will always use the built-in prompts.
wrap_guidesWhere to display vertical rulers as wrap-guides. Disable by setting `show_wrap_guides` to `false`.
tab_sizeThe number of spaces to use for each tab character.
tasksConfiguration for tasks that can be run within Zed
telemetryControl what info is collected by Zed.
terminalConfiguration for the terminal.
detect_venvActivate the [Python Virtual Environment](https://docs.python.org/3/library/venv.html), if one is found, in the terminal's working directory (as resolved by the `working_directory` setting), automatically activating the virtual environment.
toolbarWhether or not to show various elements in the terminal toolbar.
replRepl settings.
themeThe theme setting can be specified in two forms - either as the name of a theme or as an object containing the `mode`, `dark`, and `light` themes for the Zed UI.
title_barWhether or not to show various elements in the title bar
window_title_formatTemplate for the window title. Use `${separator}` to insert a separator that is omitted when adjacent variables are empty. The collaboration indicator, when present, is appended after the rendered template. If the template renders to nothing (for example `${branch}` outside a Git repository), the default template is used instead.
window_title_separatorThe string substituted for `${separator}` in the window title format. Include any surrounding whitespace in the value.
window_decorationsControls whether Zed or the window manager or compositor draws window decorations.
vim_modeWhether or not to enable vim mode.
which_keyShow matching bindings while a multi-stroke binding is pending.
when_closing_with_no_tabsWhether the window should be closed when using 'close active item' on a window with no tabs
project_panelCustomize project panel
collaboration_panelCustomizations for the collaboration panel.
debuggerConfiguration for debugger panel and settings
git_panelSetting to customize the behavior of the git panel.
git.worktree_directoryDirectory where git worktrees are created, relative to the repository working directory.
git_hosting_providersRegister self-hosted GitHub, GitLab, or Bitbucket instances so commit hashes, issue references, and permalinks resolve to the right host.
outline_panelCustomize outline Panel
callsCustomize behavior when participating in a call
colorize_bracketsWhether to use tree-sitter bracket queries to detect and colorize the brackets in the editor (also known as "rainbow brackets").
unnecessary_code_fadeHow much to fade out unused code.
ui_font_familyThe name of the font to use for text in the UI.
ui_font_featuresThe OpenType features to enable for text in the UI.
ui_font_fallbacksThe font fallbacks to use for text in the UI.
ui_font_sizeThe default font size for text in the UI.
ui_font_weightThe default font weight for text in the UI.
profilesConfigure any number of settings profiles that are temporarily applied when selected from {#action settings_profile_selector::Toggle}.

Nested keys, inside the objects above

border_sizeSize of the border surrounding the active pane. When set to 0, the active pane doesn't have any border. The border is drawn inset.
inactive_opacityOpacity of inactive panels. When set to 1.0, inactive panes have the same opacity as the active pane. If set to 0, inactive pane content is not visible. Values are clamped to the [0.0, 1.0] range.
show_signature_help_after_editsWhether to show the signature help after completion or a bracket pair inserted. If `auto_signature_help` is enabled, this setting will be treated as enabled also.
disabled_globsA list of globs for which edit predictions should be disabled for. This list adds to a pre-existing, sensible default set of globs. Any additional ones you add are combined with them.
edit_predictions.<provider>.prediction_debounceHow long Zed waits after you stop typing before automatically requesting an edit prediction.
showWhen to show the editor scrollbar.
cursorsWhether to show cursor positions in the scrollbar.
git_diffWhether to show git diff indicators in the scrollbar.
search_resultsWhether to show buffer search results in the scrollbar.
selected_textWhether to show selected text occurrences in the scrollbar.
selected_symbolWhether to show selected symbol occurrences in the scrollbar.
diagnosticsWhich diagnostic indicators to show in the scrollbar.
axesForcefully enable or disable the scrollbar for each axis
horizontalWhen false, forcefully disables the horizontal scrollbar. Otherwise, obey other settings.
verticalWhen false, forcefully disables the vertical scrollbar. Otherwise, obey other settings.
showWhen to show the minimap in the editor.
thumbWhen to show the minimap thumb (the visible editor area) in the minimap.
thumb_borderHow the minimap thumb border should look.
current_line_highlightHow to highlight the current line in the minimap.
showWhether or not to show the tab bar in the editor.
show_nav_history_buttonsWhether or not to show the navigation history buttons.
show_tab_bar_buttonsWhether or not to show the tab bar buttons.
close_positionWhere to display close button within a tab.
file_iconsWhether to show the file icon for a tab.
git_statusWhether or not to show Git file status in tab.
activate_on_closeWhat to do after closing the current tab.
show_close_buttonControls the appearance behavior of the tab's close button.
show_diagnosticsWhether to show diagnostics indicators in tabs. This setting only works when file icons are active and controls which files with diagnostic issues to mark.
inline_code_actionsWhether to show code action button at start of buffer line.
sessionControls Zed lifecycle-related behavior.
drag_and_drop_selectionWhether to allow drag and drop text selection in buffer. `delay` is the milliseconds that must elapse before drag and drop is allowed. Otherwise, a new text selection is created.
edit_prediction_providerWhich edit prediction provider to use
enabledWhether hovering over a dock or pane moves focus to it.
debounce_msHow long the mouse must hover over a panel before it is focused, in milliseconds.
inlineWhether or not to show diagnostics information inline.
git_gutterWhether or not to show the git gutter.
gutter_debounceSets the debounce threshold (in milliseconds) after which changes are reflected in the git gutter.
inline_blameWhether or not to show git blame information inline, on the currently focused line.
branch_pickerConfiguration related to the branch picker.
hunk_styleWhat styling we should use for the diff hunks.
diff_baseWhether git features show changes relative to HEAD (uncommitted changes) or to the default branch (all changes on the current branch). Also available in the editor controls menu as "Diff Against Default Branch".
icon_themeSpecify the icon theme using an object that includes the `mode`, `dark`, and `light`.
modeSpecify the icon theme mode.
darkThe name of the dark icon theme.
lightThe name of the light icon theme.
unitThe unit for image file sizes
pathThe path of the directory where journal entries are stored. If an invalid path is specified, the journal will fall back to using `~` (the home directory).
hour_formatThe format to use for displaying hours in the journal.
document_symbolsControls the source of document symbols used for outlines and breadcrumbs.
instrumentation.performance_profiler.enabledCollects timing data for foreground and background executor tasks so they can be inspected via the {#action zed::OpenPerformanceProfiler} action. Enabling this may lead to increased memory usage, hence it's disabled by default for regular builds.
enable_preview_from_project_panelDetermines whether to open files in preview mode when opened from the project panel with a single click.
enable_preview_from_file_finderDetermines whether to open files in preview mode when selected from the file finder.
enable_preview_from_multibufferDetermines whether to open files in preview mode when opened from a multibuffer.
enable_preview_multibuffer_from_code_navigationDetermines whether to open tabs in preview mode when code navigation is used to open a multibuffer.
enable_preview_file_from_code_navigationDetermines whether to open tabs in preview mode when code navigation is used to open a single file.
enable_keep_preview_on_code_navigationDetermines whether to keep tabs in preview mode when code navigation is used to navigate away from them. If `enable_preview_file_from_code_navigation` or `enable_preview_multibuffer_from_code_navigation` is also true, the new tab may replace the existing one.
modal_max_widthMax-width of the call hierarchy modal. It can take one of these values: `small`, `medium`, `large`, `xlarge`, and `full`.
file_iconsWhether to show file icons in the file finder.
modal_max_widthMax-width of the file finder modal. It can take one of these values: `small`, `medium`, `large`, `xlarge`, and `full`.
skip_focus_for_active_in_searchDetermines whether the file finder should skip focus for the active file in search results.
mouse_wheel_zoomWhether to zoom the editor font size with the mouse wheel while holding the primary modifier key (Cmd on macOS, Ctrl on other platforms).
fast_scroll_sensitivityScroll sensitivity multiplier for fast scrolling. This multiplier is applied to both the horizontal and vertical delta values while scrolling. Fast scrolling happens when a user holds the alt or option key while scrolling.
horizontal_scroll_marginThe number of characters to keep on either side when scrolling with the mouse
vertical_scroll_marginThe number of lines to keep above/below the cursor when scrolling with the keyboard
buttonWhether to show the project search button in the status bar.
whole_wordWhether to only match on whole words.
case_sensitiveWhether to match case sensitively. This setting affects both searches and editor actions like "Select Next Occurrence", "Select Previous Occurrence", and "Select All Occurrences".
include_ignoredWhether to include gitignored files in search results.
regexWhether to interpret the search query as a regular expression.
center_on_matchWhether to center the cursor on each search match when navigating.
search_on_typeStart searching as you type in project search, without pressing Enter.
wordsControls how words are completed. For large documents, not all words may be fetched for completion.
words_min_lengthMinimum number of characters required to automatically trigger word-based completions. Before that value, it's still possible to trigger the words-based completion manually with the corresponding editor command.
lspWhether to fetch LSP completions or not.
lsp_fetch_timeout_msWhen fetching LSP completions, determines how long to wait for a response of a particular server. When set to 0, waits indefinitely.
lsp_insert_modeControls what range to replace when accepting LSP completions.
diagnosticsSetting for sending debug-related data, such as crash reports.
metricsSetting for sending anonymized usage data, such as what languages you're using Zed with.
dockControl the position of the dock
starts_openWhether the terminal panel should open on startup.
alternate_scrollSet whether Alternate Scroll mode (DECSET code: `?1007`) is active by default. Alternate Scroll mode converts mouse scroll events into up / down key presses when in the alternate screen (e.g. when running applications like vim or less). The terminal can still set and unset this mode with ANSI escape codes.
blinkingSet the cursor blinking behavior in the terminal
copy_on_selectWhether or not selecting text in the terminal will automatically copy to the system clipboard.
cursor_shapeControls the visual shape of the cursor in the terminal. When not explicitly set, it defaults to a block shape.
keep_selection_on_copyWhether or not to keep the selection in the terminal after copying text.
open_links_in_mouse_modeWhether cmd-click (ctrl-click on Linux and Windows) opens hyperlinks even when the terminal application has enabled mouse reporting (e.g. vim with `mouse=a`, htop). When `false`, these clicks are forwarded to the application instead, and hyperlinks can still be opened with shift-cmd-click (shift-ctrl-click).
envAny key-value pairs added to this object will be added to the terminal's environment. Keys must be unique, use `:` to separate multiple values in a single variable
font_sizeWhat font size to use for the terminal. When not set defaults to matching the editor's font size
font_familyWhat font to use for the terminal. When not set, defaults to matching the editor's font.
font_featuresWhat font features to use for the terminal. When not set, defaults to matching the editor's font features.
line_heightSet the terminal's line height.
minimum_contrastControls the minimum contrast between foreground and background colors in the terminal. Uses the APCA (Accessible Perceptual Contrast Algorithm) for color adjustments. Set this to 0 to disable this feature.
option_as_metaRe-interprets the option keys to act like a 'meta' key, like in Emacs.
shellWhat shell to use when launching the terminal.
scroll_multiplierThe multiplier for scrolling speed in the terminal when using mouse wheel or trackpad.
buttonControl to show or hide the terminal button in the status bar
working_directoryWhat working directory to use when launching the terminal.
path_hyperlink_regexesRegexes used to identify path hyperlinks. The regexes can be specified in two forms - a single regex string, or an array of strings (which will be collected into a single multi-line regex string).
path_hyperlink_timeout_msMaximum time to search for a path hyperlink. When set to 0, path hyperlinks are disabled.
themeSpecify the theme using an object that includes the `mode`, `dark`, and `light` themes.
modeSpecify theme mode.
darkThe name of the dark Zed theme to use for the UI.
lightThe name of the light Zed theme to use for the UI.
dockControl the position of the dock
entry_spacingSpacing between worktree entries
git_statusIndicates newly created and updated files
default_widthCustomize default width taken by project panel
auto_reveal_entriesWhether to reveal it in the project panel automatically, when a corresponding project entry becomes active. Gitignored entries are never auto revealed.
auto_fold_dirsWhether to fold directories automatically when directory has only one directory inside.
bold_folder_labelsWhether to show folder names with bold text in the project panel.
indent_sizeAmount of indentation (in pixels) for nested items.
indent_guidesWhether to show indent guides in the project panel.
scrollbarScrollbar-related settings for the project panel.
sort_modeSort order for entries in the project panel
sort_orderWhether to sort file and folder names case-sensitively in the project panel. This setting works in combination with `sort_mode`. `sort_mode` controls how files and directories are grouped (e.g., directories first), while this setting controls how names are compared within those groups.
auto_openControl whether files are opened automatically after different creation flows in the project panel.

Keymap Contexts

23

Predicates, key syntax and the keymap file

Workspacethe whole window — the root of the context tree
Pane / Panesa tab group
Editorany editor, including single-line inputs
Editor && mode == fulla real file editor, not a search box or a commit message
Editor && multibuffera multibuffer, e.g. project-search results
Terminalthe integrated terminal
ProjectPanel / OutlinePanelthe file tree / the symbol outline
GitPanel / GitDiff / GitCommitthe git surfaces
AgentPanel / AcpThreadthe agent panel and one agent thread
BufferSearchBar / ProjectSearchBarthe two search bars
Picker / menua modal picker / any open menu
VimControlvim normal, visual or operator-pending
vim_mode == normalone specific vim mode
vim_operator == athe pending operator, by key
os == macosplatform predicate
X && Y · X || Y · !Xboolean operators on predicates
X > YY with X anywhere above it in the tree
"key": nullunbind — and do not fall through to the parent context
"cmd-k cmd-s"a multi-key sequence
secondary-cmd on macOS, ctrl elsewhere
["pane::DeploySearch", {…}]an action with arguments
base_keymapZed · VSCode · JetBrains · Sublime · Atom · Emacs · TextMate · Cursor · None
dev: open key context viewlive view of the context tree at the cursor

Tasks

26

Variables and the fields of a task definition

$ZED_FILEabsolute path of the current file
$ZED_FILENAME / $ZED_STEMfile name / file name without extension
$ZED_DIRNAMEthe file’s directory, absolute
$ZED_RELATIVE_FILE / $ZED_RELATIVE_DIRthe same, relative to the worktree root
$ZED_ROW / $ZED_COLUMNcursor position
$ZED_SYMBOLthe symbol under the cursor, as the breadcrumb shows it
$ZED_SELECTED_TEXTthe current selection
$ZED_LANGUAGEthe buffer’s language name
$ZED_WORKTREE_ROOTabsolute path of the worktree root
$ZED_MAIN_GIT_WORKTREEthe main working directory, for linked git worktrees
${ZED_SELECTED_TEXT:default}a default when the variable is unset
$ZED_CUSTOM_<NAME>a capture from the language’s runnables.scm
$ZED_GIT_SHA / _SHORTthe selected commit, in a git-graph task
$ZED_GIT_REFthe clicked branch, remote ref or tag
"label"the task name shown in the palette
"command" / "args"what to run
"cwd"working directory; task variables are expanded in it
"env"extra environment variables
"use_new_terminal"a fresh terminal each run, or reuse one
"allow_concurrent_runs"let a second run start before the first finishes
"reveal"always / no_focus / never
"hide"never / always / on_success
"tags"bind the task to a runnables.scm capture
"shell"system, a program, or with_arguments
task::Spawnthe action; bind a key to a named task
task::Rerunrun the last task again

CLI & Files

29

The zed command

zed .open the current directory as a workspace
zed file:42:10open a file at line 42, column 10
zed -w / --waitblock until the opened files are closed
zed -n / --newforce a new workspace window
zed -a / --addadd the paths to the focused workspace instead
zed -r / --reusereuse the current window rather than opening one
zed -e / --existingonly open in an already running Zed
zed --diff OLD NEWopen a two-pane diff of two files
zed --foregroundrun in the foreground with verbose logging
zed --user-data-dir DIRuse a separate profile directory
zed --completions SHELLemit shell completions
zed --uninstallremove Zed and optionally its data
zed -v / --versionprint the version
zed ssh://host/pathopen a remote project over SSH
cli::InstallCliBinaryinstall the zed CLI to /usr/local/bin

Where everything lives

~/Library/Application Support/Zed/macOS config root
~/.config/zed/Linux config root
%APPDATA%\Zed\Windows config root
settings.jsonuser settings
keymap.jsonuser keybindings
tasks.jsonuser task definitions
debug.jsonuser debug scenarios
snippets/*.jsonuser snippets, one file per language
themes/*.jsonlocally installed themes
extensions/installed extensions and their WASM blobs
.zed/settings.jsonproject-local settings, checked into the repo
.editorconfighonoured for indentation and line endings
AGENTS.mdproject rules the agent reads automatically
~/.config/zed/logs/Zed.logthe log file