1# Completions
  2
  3Zed supports two sources for completions:
  4
  51. "Code Completions" provided by Language Servers (LSPs) automatically installed by Zed or via [Zed Language Extensions](languages.md).
  62. "Edit Predictions" provided by Zed's own Zeta model or by external providers like [GitHub Copilot](#github-copilot) or [Supermaven](#supermaven).
  7
  8## Language Server Code Completions {#code-completions}
  9
 10When there is an appropriate language server available, Zed will provide completions of variable names, functions, and other symbols in the current file. You can disable these by adding the following to your Zed `settings.json` file:
 11
 12```json
 13"show_completions_on_input": false
 14```
 15
 16You can manually trigger completions with `ctrl-space` or by triggering the `editor::ShowCompletions` action from the command palette.
 17
 18For more information, see:
 19
 20- [Configuring Supported Languages](./configuring-languages.md)
 21- [List of Zed Supported Languages](./languages.md).
 22
 23## Edit Predictions {#edit-predictions}
 24
 25Zed has built-in support for predicting multiple edits at a time via its [Zeta model](https://huggingface.co/zed-industries/zeta). Clicking "Introducing: Edit Prediction" on the top right will open a brief prompt setting up this feature.
 26
 27Edit predictions appear as you type, and most of the time, you can accept them by pressing `tab`.
 28
 29### Conflict With Other `tab` Actions {#edit-predictions-conflict}
 30
 31By default, when `tab` would normally perform a different action, Zed requires a modifier key to accept predictions:
 32
 331. When the language server completions menu is visible.
 342. When your cursor isn't at the right indentation level.
 35
 36In these cases, `alt-tab` is used instead to accept the prediction. When the language server completions menu is open, holding `alt` first will cause it to temporarily disappear in order to preview the prediction within the buffer.
 37
 38On Linux, `alt-tab` is often used by the window manager for switching windows, so `alt-l` is provided as the default binding for accepting predictions. `tab` and `alt-tab` also work, but aren't displayed by default.
 39
 40{#action editor::AcceptPartialEditPrediction} ({#kb editor::AcceptPartialEditPrediction}) can be used to accept the current edit prediction up to the next word boundary.
 41
 42See the [Configuring GitHub Copilot](#github-copilot) and [Configuring Supermaven](#supermaven) sections below for configuration of other providers. Only text insertions at the current cursor are supported for these providers, whereas the Zeta model provides multiple predictions including deletions.
 43
 44## Configuring Edit Prediction Keybindings {#edit-predictions-keybinding}
 45
 46By default, `tab` is used to accept edit predictions. You can use another keybinding by inserting this in your keymap:
 47
 48```json
 49{
 50  "context": "Editor && edit_prediction",
 51  "bindings": {
 52    // Here we also allow `alt-enter` to accept the prediction
 53    "alt-enter": "editor::AcceptEditPrediction"
 54  }
 55}
 56```
 57
 58When there's a [conflict with the `tab` key](#edit-predictions-conflict), Zed uses a different context to accept keybindings (`edit_prediction_conflict`). If you want to use a different one, you can insert this in your keymap:
 59
 60```json
 61{
 62  "context": "Editor && edit_prediction_conflict",
 63  "bindings": {
 64    "ctrl-enter": "editor::AcceptEditPrediction" // Example of a modified keybinding
 65  }
 66}
 67```
 68
 69If your keybinding contains a modifier (`ctrl` in the example above), it will also be used to preview the edit prediction and temporarily hide the language server completion menu.
 70
 71You can also bind this action to keybind without a modifier. In that case, Zed will use the default modifier (`alt`) to preview the edit prediction.
 72
 73```json
 74{
 75  "context": "Editor && edit_prediction_conflict",
 76  "bindings": {
 77    // Here we bind tab to accept even when there's a language server completion
 78    // or the cursor isn't at the correct indentation level
 79    "tab": "editor::AcceptEditPrediction"
 80  }
 81}
 82```
 83
 84To maintain the use of the modifier key for accepting predictions when there is a language server completions menu, but allow `tab` to accept predictions regardless of cursor position, you can specify the context further with `showing_completions`:
 85
 86```json
 87{
 88  "context": "Editor && edit_prediction_conflict && !showing_completions",
 89  "bindings": {
 90    // Here we don't require a modifier unless there's a language server completion
 91    "tab": "editor::AcceptEditPrediction"
 92  }
 93}
 94```
 95
 96### Keybinding Example: Always Use Alt-Tab
 97
 98The keybinding example below causes `alt-tab` to always be used instead of sometimes using `tab`. You might want this in order to have just one keybinding to use for accepting edit predictions, since the behavior of `tab` varies based on context.
 99
100```json
101  {
102    "context": "Editor && edit_prediction",
103    "bindings": {
104      "alt-tab": "editor::AcceptEditPrediction"
105    }
106  },
107  // Bind `tab` back to its original behavior.
108  {
109    "context": "Editor",
110    "bindings": {
111      "tab": "editor::Tab"
112    }
113  },
114  {
115    "context": "Editor && showing_completions",
116    "bindings": {
117      "tab": "editor::ComposeCompletion"
118    }
119  },
120```
121
122If `"vim_mode": true` is set within `settings.json`, then additional bindings are needed after the above to return `tab` to its original behavior:
123
124```json
125  {
126    "context": "(VimControl && !menu) || vim_mode == replace || vim_mode == waiting",
127    "bindings": {
128      "tab": "vim::Tab"
129    }
130  },
131  {
132    "context": "vim_mode == literal",
133    "bindings": {
134      "tab": ["vim::Literal", ["tab", "\u0009"]]
135    }
136  },
137```
138
139### Keybinding Example: Displaying Tab and Alt-Tab on Linux
140
141While `tab` and `alt-tab` are supported on Linux, `alt-l` is displayed instead. If your window manager does not reserve `alt-tab`, and you would prefer to use `tab` and `alt-tab`, include these bindings in `keymap.json`:
142
143```json
144  {
145    "context": "Editor && edit_prediction",
146    "bindings": {
147      "tab": "editor::AcceptEditPrediction",
148      // Optional: This makes the default `alt-l` binding do nothing.
149      "alt-l": null
150    }
151  },
152  {
153    "context": "Editor && edit_prediction_conflict",
154    "bindings": {
155      "alt-tab": "editor::AcceptEditPrediction",
156      // Optional: This makes the default `alt-l` binding do nothing.
157      "alt-l": null
158    }
159  },
160```
161
162### Missing keybind {#edit-predictions-missing-keybinding}
163
164Zed requires at least one keybinding for the {#action editor::AcceptEditPrediction} action in both the `Editor && edit_prediction` and `Editor && edit_prediction_conflict` contexts ([learn more above](#edit-predictions-keybinding)).
165
166If you have previously bound the default keybindings to different actions in the global context, you will not be able to preview or accept edit predictions. For example:
167
168```json
169[
170  // Your keymap
171  {
172    "bindings": {
173      // Binds `alt-tab` to a different action globally
174      "alt-tab": "menu::SelectNext"
175    }
176  }
177]
178```
179
180To fix this, you can specify your own keybinding for accepting edit predictions:
181
182```json
183[
184  // ...
185  {
186    "context": "Editor && edit_prediction_conflict",
187    "bindings": {
188      "alt-l": "editor::AcceptEditPrediction"
189    }
190  }
191]
192```
193
194If you would like to use the default keybinding, you can free it up by either moving yours to a more specific context or changing it to something else.
195
196## Disabling Automatic Edit Prediction
197
198To disable predictions that appear automatically as you type, set this within `settings.json`:
199
200```json
201{
202  "show_edit_predictions": false
203}
204```
205
206You can trigger edit predictions manually by executing {#action editor::ShowEditPrediction} ({#kb editor::ShowEditPrediction}).
207
208You can also add this as a language-specific setting in your `settings.json` to disable edit predictions for a specific language:
209
210```json
211{
212  "language": {
213    "python": {
214      "show_edit_predictions": false
215    }
216  }
217}
218```
219
220## Configuring GitHub Copilot {#github-copilot}
221
222To use GitHub Copilot, set this within `settings.json`:
223
224```json
225{
226  "features": {
227    "edit_prediction_provider": "copilot"
228  }
229}
230```
231
232You should be able to sign-in to GitHub Copilot by clicking on the Copilot icon in the status bar and following the setup instructions.
233
234Copilot can provide multiple completion alternatives, and these can be navigated with the following actions:
235
236- {#action editor::NextEditPrediction} ({#kb editor::NextEditPrediction}): To cycle to the next edit prediction
237- {#action editor::PreviousEditPrediction} ({#kb editor::PreviousEditPrediction}): To cycle to the previous edit prediction
238
239## Configuring Supermaven {#supermaven}
240
241To use Supermaven, set this within `settings.json`:
242
243```json
244{
245  "features": {
246    "edit_prediction_provider": "supermaven"
247  }
248}
249```
250
251You should be able to sign-in to Supermaven by clicking on the Supermaven icon in the status bar and following the setup instructions.
252
253## See also
254
255You may also use the Assistant Panel or the Inline Assistant to interact with language models, see the [assistant](assistant/assistant.md) documentation for more information.