1---
2title: How to Migrate from IntelliJ IDEA to Zed
3description: "Guide for migrating from IntelliJ IDEA to Zed, including settings and keybindings."
4---
5
6# How to Migrate from IntelliJ IDEA to Zed
7
8This guide covers how to set up Zed if you're coming from IntelliJ IDEA, including keybindings, settings, and the differences you should expect.
9
10## Install Zed
11
12Zed is available on macOS, Windows, and Linux.
13
14For macOS, you can download it from zed.dev/download, or install via Homebrew:
15
16```sh
17brew install --cask zed
18```
19
20For Windows, download the installer from zed.dev/download, or install via winget:
21
22```sh
23winget install Zed.Zed
24```
25
26For most Linux users, the easiest way to install Zed is through our installation script:
27
28```sh
29curl -f https://zed.dev/install.sh | sh
30```
31
32After installation, you can launch Zed from your Applications folder (macOS), Start menu (Windows), or directly from the terminal using:
33`zed .`
34This opens the current directory in Zed.
35
36## Set Up the JetBrains Keymap
37
38If you're coming from IntelliJ, the fastest way to feel at home is to use the JetBrains keymap. During onboarding, you can select it as your base keymap. If you missed that step, you can change it anytime:
39
401. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows)
412. Search for `Base Keymap`
423. Select `JetBrains`
43
44This maps familiar shortcuts like `Shift Shift` for Search Everywhere, `Cmd+O` for Go to Class, and `Cmd+Shift+A` for Find Action.
45
46In editors, the JetBrains keymap also makes `Alt+Left` / `Alt+Right` and `Shift+Alt+Left` / `Shift+Alt+Right` move and select by subword, so identifiers like `camelCase` and `snake_case` behave like IntelliJ's CamelHumps navigation.
47
48## Set Up Editor Preferences
49
50You can configure most settings in the Settings Editor ({#kb zed::OpenSettings}). For advanced settings, run `zed: open settings file` from the Command Palette to edit your settings file directly.
51
52Settings IntelliJ users typically configure first:
53
54| Zed Setting | What it does |
55| ----------------------- | ------------------------------------------------------------------------------- |
56| `format_on_save` | Auto-format when saving. Set to `"on"` to enable. |
57| `soft_wrap` | Wrap long lines. Options: `"none"`, `"editor_width"`, `"preferred_line_length"` |
58| `preferred_line_length` | Column width for wrapping and rulers. Default is 80. |
59| `inlay_hints` | Show parameter names and type hints inline, like IntelliJ's hints. |
60| `relative_line_numbers` | Useful if you're coming from IdeaVim. |
61
62Zed also supports per-project settings. Create a `.zed/settings.json` file in your project root to override global settings for that project, similar to how you might use `.idea` folders in IntelliJ.
63
64> **Tip:** If you're joining an existing project, check `format_on_save` before making your first commit. Otherwise you might accidentally reformat an entire file when you only meant to change one line.
65
66## Open or Create a Project
67
68After setup, press `Cmd+Shift+O` (with JetBrains keymap) to open a folder. This becomes your workspace in Zed. Unlike IntelliJ, there's no project configuration wizard, no `.iml` files, and no SDK setup required.
69
70To start a new project, create a directory using your terminal or file manager, then open it in Zed. The editor will treat that folder as the root of your project.
71
72You can also launch Zed from the terminal inside any folder with:
73`zed .`
74
75Once inside a project:
76
77- Use `Cmd+Shift+O` or `Cmd+E` to jump between files quickly (like IntelliJ's "Recent Files")
78- Use `Cmd+Shift+A` or `Shift Shift` to open the Command Palette (like IntelliJ's "Search Everywhere")
79- Use `Cmd+O` to search for symbols (like IntelliJ's "Go to Class")
80
81Open buffers appear as tabs across the top. The Project Panel shows your file tree and Git status. Toggle it with `Cmd+1` (just like IntelliJ's Project tool window).
82
83## Differences in Keybindings
84
85If you chose the JetBrains keymap during onboarding, most of your shortcuts should already feel familiar. Here's a quick reference for how Zed compares to IntelliJ.
86
87### Common Shared Keybindings (Zed with JetBrains keymap ↔ IntelliJ)
88
89| Action | Shortcut |
90| ----------------------------- | -------------------------- |
91| Search Everywhere | `Shift Shift` |
92| Find Action / Command Palette | `Cmd + Shift + A` |
93| Go to File | `Cmd + Shift + O` |
94| Go to Symbol / Class | `Cmd + O` |
95| Recent Files | `Cmd + E` |
96| Go to Definition | `Cmd + B` |
97| Find Usages | `Alt + F7` |
98| Rename Symbol | `Shift + F6` |
99| Reformat Code | `Cmd + Alt + L` |
100| Toggle Project Panel | `Cmd + 1` |
101| Toggle Terminal | `Alt + F12` |
102| Duplicate Line | `Cmd + D` |
103| Delete Line | `Cmd + Backspace` |
104| Move Line Up/Down | `Shift + Alt + Up/Down` |
105| Expand/Shrink Selection | `Alt + Up/Down` |
106| Move by subword | `Alt + Left/Right` |
107| Select by subword | `Shift + Alt + Left/Right` |
108| Comment Line | `Cmd + /` |
109| Go Back / Forward | `Cmd + [` / `Cmd + ]` |
110| Toggle Breakpoint | `Ctrl + F8` |
111
112### Different Keybindings (IntelliJ → Zed)
113
114| Action | IntelliJ | Zed (JetBrains keymap) |
115| ---------------------- | ----------- | ------------------------ |
116| File Structure | `Cmd + F12` | `Cmd + F12` (outline) |
117| Navigate to Next Error | `F2` | `F2` |
118| Run | `Ctrl + R` | `Ctrl + Alt + R` (tasks) |
119| Debug | `Ctrl + D` | `Alt + Shift + F9` |
120| Stop | `Cmd + F2` | `Ctrl + F2` |
121
122### Unique to Zed
123
124| Action | Shortcut | Notes |
125| ----------------- | -------------------------- | ------------------------------ |
126| Toggle Right Dock | `Cmd + R` | Assistant panel, notifications |
127| Split Panes | `Cmd + K`, then arrow keys | Create splits in any direction |
128
129### How to Customize Keybindings
130
131- Open the Command Palette (`Cmd+Shift+A` or `Shift Shift`)
132- Run `Zed: Open Keymap Editor`
133
134This opens a list of all available bindings. You can override individual shortcuts or remove conflicts.
135
136Zed also supports key sequences (multi-key shortcuts).
137
138## Differences in User Interfaces
139
140### No Indexing
141
142If you've used IntelliJ on large projects, you know the wait: "Indexing..." can take anywhere from 30 seconds to 15 minutes depending on project size. IntelliJ builds a comprehensive index of your entire codebase to power its code intelligence, and it re-indexes when dependencies change or after builds.
143
144Zed doesn't index. You open a folder and start working immediately. File search and navigation work instantly regardless of project size.
145
146IntelliJ's index powers features like finding all usages across your entire codebase, understanding class hierarchies, and detecting dead code. Zed delegates this work to language servers, which may not analyze at the same depth.
147
148**How to adapt:**
149
150- For project-wide symbol search, use `Cmd+O` / Go to Symbol (relies on your language server)
151- For finding files by name, use `Cmd+Shift+O` / Go to File
152- For text search across files, use `Cmd+Shift+F`—this is fast even on large codebases
153- If you need deep static analysis for JVM code, consider running IntelliJ's inspections as a separate step or using standalone tools like Checkstyle, PMD, or SpotBugs
154
155### LSP vs. Native Language Intelligence
156
157IntelliJ has its own language analysis engine built from scratch for each supported language. For Java, Kotlin, and other JVM languages, this engine understands your code thoroughly: it resolves types, tracks data flow, knows about framework annotations, and offers dozens of specialized refactorings.
158
159Zed uses the Language Server Protocol (LSP) for code intelligence. Each language has its own server: `jdtls` for Java, `rust-analyzer` for Rust, and so on.
160
161For some languages, the LSP experience is excellent. TypeScript, Rust, and Go have mature language servers that provide fast, accurate completions, diagnostics, and refactorings. For JVM languages, the gap might be more noticeable. The Eclipse-based Java language server is capable, but it won't match IntelliJ's depth for things like:
162
163- Spring and Jakarta EE annotation processing
164- Complex refactorings (extract interface, pull members up, change signature with all callers)
165- Framework-aware inspections
166- Automatic import optimization with custom ordering rules
167
168**How to adapt:**
169
170- Use `Alt+Enter` for available code actions—the list will vary by language server
171- For Java, ensure `jdtls` is properly configured with your JDK path in settings
172
173### No Project Model
174
175IntelliJ manages projects through `.idea` folders containing XML configuration files, `.iml` module definitions, SDK assignments, and run configurations. This model enables IntelliJ to understand multi-module projects, manage dependencies automatically, and persist complex run/debug setups.
176
177Zed has no project model. A project is a folder. There's no wizard, no SDK selection screen, no module configuration.
178
179This means:
180
181- Build commands are manual. Zed doesn't detect Maven or Gradle projects.
182- Run configurations don't exist. You define tasks or use the terminal.
183- SDK management is external. Your language server uses whatever JDK is on your PATH.
184- There are no module boundaries. Zed sees folders, not project structure.
185
186**How to adapt:**
187
188- Create a `.zed/settings.json` in your project root for project-specific settings
189- Define common commands in `tasks.json` (open via Command Palette: `zed: open tasks`):
190
191```json
192[
193 {
194 "label": "build",
195 "command": "./gradlew build"
196 },
197 {
198 "label": "run",
199 "command": "./gradlew bootRun"
200 },
201 {
202 "label": "test current file",
203 "command": "./gradlew test --tests $ZED_STEM"
204 }
205]
206```
207
208- Use `Ctrl+Alt+R` to run tasks quickly
209- Lean on your terminal (`Alt+F12`) for anything tasks don't cover
210- For multi-module projects, you can open each module as a separate Zed window, or open the root and navigate via file finder
211
212### No Framework Integration
213
214IntelliJ's value for enterprise Java development comes largely from its framework integration. Spring beans are understood and navigable. JPA entities get special treatment. Endpoints are indexed and searchable. Jakarta EE annotations modify how the IDE analyzes your code.
215
216Zed has none of this. The language server sees Java code as Java code, so it doesn't understand that `@Autowired` means something special or that this class is a REST controller.
217
218Similarly for other stacks: no Rails integration, no Django awareness, no Angular/React-specific tooling beyond what the TypeScript language server provides.
219
220**How to adapt:**
221
222- Use grep and file search liberally. `Cmd+Shift+F` with a regex can find endpoint definitions, bean names, or annotation usages.
223- Rely on your language server's "find references" (`Alt+F7`) for navigation—it works, just without framework context
224- For Spring Boot, keep the Actuator endpoints or a separate tool for understanding bean wiring
225- Consider using framework-specific CLI tools (Spring CLI, Rails generators) from Zed's terminal
226
227> **Tip:** For database work, pick up a dedicated tool like DataGrip, DBeaver, or TablePlus. Many developers who switch to Zed keep DataGrip around specifically for SQL—it integrates well with your existing JetBrains license.
228
229If your daily work depends heavily on framework-aware navigation and refactoring, you'll feel the gap. Zed works best when you're comfortable navigating code through search rather than specialized tooling, or when your language has strong LSP support that covers most of what you need.
230
231### Tool Windows vs. Docks
232
233IntelliJ organizes auxiliary views into numbered tool windows (Project = 1, Git = 9, Terminal = Alt+F12, etc.). Zed uses a similar concept called "docks":
234
235| IntelliJ Tool Window | Zed Equivalent | Shortcut (JetBrains keymap) |
236| -------------------- | -------------- | --------------------------- |
237| Project (1) | Project Panel | `Cmd + 1` |
238| Git (9 or Cmd+0) | Git Panel | `Cmd + 0` |
239| Terminal (Alt+F12) | Terminal Panel | `Alt + F12` |
240| Structure (7) | Outline Panel | `Cmd + 7` |
241| Problems (6) | Diagnostics | `Cmd + 6` |
242| Debug (5) | Debug Panel | `Cmd + 5` |
243
244Zed has three dock positions: left, bottom, and right. Panels can be moved between docks by dragging or through settings.
245
246> **Tip:** IntelliJ has an "Override IDE shortcuts" setting that lets terminal shortcuts like `Ctrl+Left/Right` work normally. In Zed, terminal keybindings are separate—check your keymap if familiar shortcuts aren't working in the terminal panel.
247
248### Debugging
249
250Both IntelliJ and Zed offer integrated debugging, but the experience differs:
251
252- Zed's debugger uses the Debug Adapter Protocol (DAP), supporting multiple languages
253- Set breakpoints with `Ctrl+F8`
254- Start debugging with `Alt+Shift+F9`
255- Step through code with `F7` (step into), `F8` (step over), `Shift+F8` (step out)
256- Continue execution with `F9`
257
258The Debug Panel (`Cmd+5`) shows variables, call stack, and breakpoints—similar to IntelliJ's Debug tool window.
259
260### Extensions vs. Plugins
261
262IntelliJ has a large plugin catalog covering everything from language support to database tools to deployment integrations.
263
264Zed's extension catalog is smaller and more focused:
265
266- Language support and syntax highlighting
267- Themes
268- Slash commands for AI
269- Context servers
270
271Several features that require plugins in other editors are built into Zed:
272
273- Real-time collaboration with voice chat
274- AI coding assistance
275- Built-in terminal
276- Task runner
277- LSP-based code intelligence
278
279You won't find one-to-one replacements for every IntelliJ plugin, especially for framework-specific tools, database clients, or application server integrations. For those workflows, you may need to use external tools alongside Zed.
280
281## Collaboration in Zed vs. IntelliJ
282
283IntelliJ offers Code With Me as a separate plugin for collaboration. Zed has collaboration built into the core experience.
284
285- Open the Collab Panel in the left dock
286- Create a channel and [invite your collaborators](https://zed.dev/docs/collaboration#inviting-a-collaborator) to join
287- [Share your screen or your codebase](https://zed.dev/docs/collaboration#share-a-project) directly
288
289Once connected, you'll see each other's cursors, selections, and edits in real time. Voice chat is included. There's no need for separate tools or third-party logins.
290
291## Using AI in Zed
292
293If you're used to AI assistants in IntelliJ (like GitHub Copilot or JetBrains AI), Zed offers similar capabilities with more flexibility.
294
295### Configuring GitHub Copilot
296
2971. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows)
2982. Navigate to **AI → Edit Predictions**
2993. Click **Configure** next to "Configure Providers"
3004. Under **GitHub Copilot**, click **Sign in to GitHub**
301
302Once signed in, just start typing. Zed will offer suggestions inline for you to accept.
303
304### Additional AI Options
305
306To use other AI models in Zed, you have several options:
307
308- Use Zed's hosted models, with higher rate limits. Requires [authentication](https://zed.dev/docs/authentication) and subscription to [Zed Pro](https://zed.dev/docs/ai/subscription.html).
309- Bring your own [API keys](https://zed.dev/docs/ai/llm-providers.html), no authentication needed
310- Use [external agents like Claude Agent](https://zed.dev/docs/ai/external-agents.html)
311
312## Advanced Config and Productivity Tweaks
313
314Zed exposes advanced settings for power users who want to fine-tune their environment.
315
316Here are a few useful tweaks:
317
318**Format on Save:**
319
320```json
321"format_on_save": "on"
322```
323
324**Enable direnv support:**
325
326```json
327"load_direnv": "shell_hook"
328```
329
330**Configure language servers** (requires manual JSON editing): For Java development, you may want to configure the Java language server in your settings:
331
332```json
333{
334 "lsp": {
335 "jdtls": {
336 "settings": {
337 "java_home": "/path/to/jdk"
338 }
339 }
340 }
341}
342```
343
344## Next Steps
345
346Now that you're set up, here are some resources to help you get the most out of Zed:
347
348- [All Settings](../reference/all-settings.md) — Customize settings, themes, and editor behavior
349- [Key Bindings](../key-bindings.md) — Learn how to customize and extend your keymap
350- [Tasks](../tasks.md) — Set up build and run commands for your projects
351- [AI Features](../ai/overview.md) — Explore Zed's AI capabilities beyond code completion
352- [Collaboration](../collaboration/overview.md) — Share your projects and code together in real time
353- [Languages](../languages.md) — Language-specific setup guides, including Java and Kotlin