1# How to Migrate from IntelliJ IDEA to Zed
2
3This guide covers how to set up Zed if you're coming from IntelliJ IDEA, including keybindings, settings, and the differences you should expect.
4
5## Install Zed
6
7Zed is available on macOS, Windows, and Linux.
8
9For macOS, you can download it from zed.dev/download, or install via Homebrew:
10
11```sh
12brew install --cask zed
13```
14
15For Windows, download the installer from zed.dev/download, or install via winget:
16
17```sh
18winget install Zed.Zed
19```
20
21For most Linux users, the easiest way to install Zed is through our installation script:
22
23```sh
24curl -f https://zed.dev/install.sh | sh
25```
26
27After installation, you can launch Zed from your Applications folder (macOS), Start menu (Windows), or directly from the terminal using:
28`zed .`
29This opens the current directory in Zed.
30
31## Set Up the JetBrains Keymap
32
33If 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:
34
351. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows)
362. Search for `Base Keymap`
373. Select `JetBrains`
38
39Or add this directly to your `settings.json`:
40
41```json
42{
43 "base_keymap": "JetBrains"
44}
45```
46
47This maps familiar shortcuts like `Shift Shift` for Search Everywhere, `Cmd+O` for Go to Class, and `Cmd+Shift+A` for Find Action.
48
49## Set Up Editor Preferences
50
51You can configure settings manually in the Settings Editor.
52
53To edit your settings:
54
551. `Cmd+,` to open the Settings Editor.
562. Run `zed: open settings` in the Command Palette.
57
58Settings IntelliJ users typically configure first:
59
60| Zed Setting | What it does |
61| ----------------------- | ------------------------------------------------------------------------------- |
62| `format_on_save` | Auto-format when saving. Set to `"on"` to enable. |
63| `soft_wrap` | Wrap long lines. Options: `"none"`, `"editor_width"`, `"preferred_line_length"` |
64| `preferred_line_length` | Column width for wrapping and rulers. Default is 80. |
65| `inlay_hints` | Show parameter names and type hints inline, like IntelliJ's hints. |
66| `relative_line_numbers` | Useful if you're coming from IdeaVim. |
67
68Zed 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.
69
70> **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.
71
72## Open or Create a Project
73
74After 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.
75
76To 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.
77
78You can also launch Zed from the terminal inside any folder with:
79`zed .`
80
81Once inside a project:
82
83- Use `Cmd+Shift+O` or `Cmd+E` to jump between files quickly (like IntelliJ's "Recent Files")
84- Use `Cmd+Shift+A` or `Shift Shift` to open the Command Palette (like IntelliJ's "Search Everywhere")
85- Use `Cmd+O` to search for symbols (like IntelliJ's "Go to Class")
86
87Open buffers appear as tabs across the top. The sidebar shows your file tree and Git status. Toggle it with `Cmd+1` (just like IntelliJ's Project tool window).
88
89## Differences in Keybindings
90
91If 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.
92
93### Common Shared Keybindings (Zed with JetBrains keymap ↔ IntelliJ)
94
95| Action | Shortcut |
96| ----------------------------- | ----------------------- |
97| Search Everywhere | `Shift Shift` |
98| Find Action / Command Palette | `Cmd + Shift + A` |
99| Go to File | `Cmd + Shift + O` |
100| Go to Symbol / Class | `Cmd + O` |
101| Recent Files | `Cmd + E` |
102| Go to Definition | `Cmd + B` |
103| Find Usages | `Alt + F7` |
104| Rename Symbol | `Shift + F6` |
105| Reformat Code | `Cmd + Alt + L` |
106| Toggle Project Panel | `Cmd + 1` |
107| Toggle Terminal | `Alt + F12` |
108| Duplicate Line | `Cmd + D` |
109| Delete Line | `Cmd + Backspace` |
110| Move Line Up/Down | `Shift + Alt + Up/Down` |
111| Expand/Shrink Selection | `Alt + Up/Down` |
112| Comment Line | `Cmd + /` |
113| Go Back / Forward | `Cmd + [` / `Cmd + ]` |
114| Toggle Breakpoint | `Ctrl + F8` |
115
116### Different Keybindings (IntelliJ → Zed)
117
118| Action | IntelliJ | Zed (JetBrains keymap) |
119| ---------------------- | ----------- | ------------------------ |
120| File Structure | `Cmd + F12` | `Cmd + F12` (outline) |
121| Navigate to Next Error | `F2` | `F2` |
122| Run | `Ctrl + R` | `Ctrl + Alt + R` (tasks) |
123| Debug | `Ctrl + D` | `Alt + Shift + F9` |
124| Stop | `Cmd + F2` | `Ctrl + F2` |
125
126### Unique to Zed
127
128| Action | Shortcut | Notes |
129| ----------------- | -------------------------- | ------------------------------ |
130| Toggle Right Dock | `Cmd + R` | Assistant panel, notifications |
131| Split Panes | `Cmd + K`, then arrow keys | Create splits in any direction |
132
133### How to Customize Keybindings
134
135- Open the Command Palette (`Cmd+Shift+A` or `Shift Shift`)
136- Run `Zed: Open Keymap Editor`
137
138This opens a list of all available bindings. You can override individual shortcuts or remove conflicts.
139
140Zed also supports key sequences (multi-key shortcuts).
141
142## Differences in User Interfaces
143
144### No Indexing
145
146If 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.
147
148Zed doesn't index. You open a folder and start working immediately. File search and navigation work instantly regardless of project size.
149
150IntelliJ'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.
151
152**How to adapt:**
153
154- For project-wide symbol search, use `Cmd+O` / Go to Symbol (relies on your language server)
155- For finding files by name, use `Cmd+Shift+O` / Go to File
156- For text search across files, use `Cmd+Shift+F`—this is fast even on large codebases
157- 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
158
159### LSP vs. Native Language Intelligence
160
161IntelliJ 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.
162
163Zed 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.
164
165For 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:
166
167- Spring and Jakarta EE annotation processing
168- Complex refactorings (extract interface, pull members up, change signature with all callers)
169- Framework-aware inspections
170- Automatic import optimization with custom ordering rules
171
172**How to adapt:**
173
174- Use `Alt+Enter` for available code actions—the list will vary by language server
175- For Java, ensure `jdtls` is properly configured with your JDK path in settings
176
177### No Project Model
178
179IntelliJ 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.
180
181Zed has no project model. A project is a folder. There's no wizard, no SDK selection screen, no module configuration.
182
183This means:
184
185- Build commands are manual. Zed doesn't detect Maven or Gradle projects.
186- Run configurations don't exist. You define tasks or use the terminal.
187- SDK management is external. Your language server uses whatever JDK is on your PATH.
188- There are no module boundaries. Zed sees folders, not project structure.
189
190**How to adapt:**
191
192- Create a `.zed/settings.json` in your project root for project-specific settings
193- Define common commands in `tasks.json` (open via Command Palette: `zed: open tasks`):
194
195```json
196[
197 {
198 "label": "build",
199 "command": "./gradlew build"
200 },
201 {
202 "label": "run",
203 "command": "./gradlew bootRun"
204 },
205 {
206 "label": "test current file",
207 "command": "./gradlew test --tests $ZED_STEM"
208 }
209]
210```
211
212- Use `Ctrl+Alt+R` to run tasks quickly
213- Lean on your terminal (`Alt+F12`) for anything tasks don't cover
214- For multi-module projects, you can open each module as a separate Zed window, or open the root and navigate via file finder
215
216### No Framework Integration
217
218IntelliJ'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.
219
220Zed 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.
221
222Similarly for other ecosystems: no Rails integration, no Django awareness, no Angular/React-specific tooling beyond what the TypeScript language server provides.
223
224**How to adapt:**
225
226- Use grep and file search liberally. `Cmd+Shift+F` with a regex can find endpoint definitions, bean names, or annotation usages.
227- Rely on your language server's "find references" (`Alt+F7`) for navigation—it works, just without framework context
228- For Spring Boot, keep the Actuator endpoints or a separate tool for understanding bean wiring
229- Consider using framework-specific CLI tools (Spring CLI, Rails generators) from Zed's terminal
230
231> **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.
232
233If 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.
234
235### Tool Windows vs. Docks
236
237IntelliJ organizes auxiliary views into numbered tool windows (Project = 1, Git = 9, Terminal = Alt+F12, etc.). Zed uses a similar concept called "docks":
238
239| IntelliJ Tool Window | Zed Equivalent | Shortcut (JetBrains keymap) |
240| -------------------- | -------------- | --------------------------- |
241| Project (1) | Project Panel | `Cmd + 1` |
242| Git (9 or Cmd+0) | Git Panel | `Cmd + 0` |
243| Terminal (Alt+F12) | Terminal Panel | `Alt + F12` |
244| Structure (7) | Outline Panel | `Cmd + 7` |
245| Problems (6) | Diagnostics | `Cmd + 6` |
246| Debug (5) | Debug Panel | `Cmd + 5` |
247
248Zed has three dock positions: left, bottom, and right. Panels can be moved between docks by dragging or through settings.
249
250> **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.
251
252### Debugging
253
254Both IntelliJ and Zed offer integrated debugging, but the experience differs:
255
256- Zed's debugger uses the Debug Adapter Protocol (DAP), supporting multiple languages
257- Set breakpoints with `Ctrl+F8`
258- Start debugging with `Alt+Shift+F9`
259- Step through code with `F7` (step into), `F8` (step over), `Shift+F8` (step out)
260- Continue execution with `F9`
261
262The Debug Panel (`Cmd+5`) shows variables, call stack, and breakpoints—similar to IntelliJ's Debug tool window.
263
264### Extensions vs. Plugins
265
266IntelliJ has a massive plugin ecosystem covering everything from language support to database tools to deployment integrations.
267
268Zed's extension ecosystem is smaller and more focused:
269
270- Language support and syntax highlighting
271- Themes
272- Slash commands for AI
273- Context servers
274
275Several features that require plugins in other editors are built into Zed:
276
277- Real-time collaboration with voice chat
278- AI coding assistance
279- Built-in terminal
280- Task runner
281- LSP-based code intelligence
282
283You 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.
284
285## Collaboration in Zed vs. IntelliJ
286
287IntelliJ offers Code With Me as a separate plugin for collaboration. Zed has collaboration built into the core experience.
288
289- Open the Collab Panel in the left dock
290- Create a channel and [invite your collaborators](https://zed.dev/docs/collaboration#inviting-a-collaborator) to join
291- [Share your screen or your codebase](https://zed.dev/docs/collaboration#share-a-project) directly
292
293Once 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.
294
295## Using AI in Zed
296
297If you're used to AI assistants in IntelliJ (like GitHub Copilot or JetBrains AI), Zed offers similar capabilities with more flexibility.
298
299### Configuring GitHub Copilot
300
3011. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows)
3022. Navigate to **AI → Edit Predictions**
3033. Click **Configure** next to "Configure Providers"
3044. Under **GitHub Copilot**, click **Sign in to GitHub**
305
306Once signed in, just start typing. Zed will offer suggestions inline for you to accept.
307
308### Additional AI Options
309
310To use other AI models in Zed, you have several options:
311
312- Use Zed's hosted models, with higher rate limits. Requires [authentication](https://zed.dev/docs/accounts.html) and subscription to [Zed Pro](https://zed.dev/docs/ai/subscription.html).
313- Bring your own [API keys](https://zed.dev/docs/ai/llm-providers.html), no authentication needed
314- Use [external agents like Claude Code](https://zed.dev/docs/ai/external-agents.html)
315
316## Advanced Config and Productivity Tweaks
317
318Zed exposes advanced settings for power users who want to fine-tune their environment.
319
320Here are a few useful tweaks:
321
322**Format on Save:**
323
324```json
325"format_on_save": "on"
326```
327
328**Enable direnv support:**
329
330```json
331"load_direnv": "shell_hook"
332```
333
334**Configure language servers**: For Java development, you may want to configure the Java language server in your settings:
335
336```json
337{
338 "lsp": {
339 "jdtls": {
340 "settings": {
341 "java_home": "/path/to/jdk"
342 }
343 }
344 }
345}
346```
347
348## Next Steps
349
350Now that you're set up, here are some resources to help you get the most out of Zed:
351
352- [Configuring Zed](../configuring-zed.md) — Customize settings, themes, and editor behavior
353- [Key Bindings](../key-bindings.md) — Learn how to customize and extend your keymap
354- [Tasks](../tasks.md) — Set up build and run commands for your projects
355- [AI Features](../ai/overview.md) — Explore Zed's AI capabilities beyond code completion
356- [Collaboration](../collaboration/overview.md) — Share your projects and code together in real time
357- [Languages](../languages.md) — Language-specific setup guides, including Java and Kotlin