1# How to Migrate from RustRover to Zed
2
3This guide covers how to set up Zed if you're coming from RustRover, including keybindings, settings, and the differences you should expect as a Rust developer.
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 RustRover, 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 RustRover 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 (uses rustfmt by default). |
63| `soft_wrap` | Wrap long lines. Options: `"none"`, `"editor_width"`, `"preferred_line_length"` |
64| `preferred_line_length` | Column width for wrapping and rulers. Rust convention is 100. |
65| `inlay_hints` | Show type hints, parameter names, and chaining hints inline. |
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 RustRover.
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 RustRover, there's no project configuration wizard, no toolchain selection dialog, and no Cargo project setup screen.
75
76To start a new project, use Cargo from the terminal:
77
78```sh
79cargo new my_project
80cd my_project
81zed .
82```
83
84Or for a library:
85
86```sh
87cargo new --lib my_library
88```
89
90You can also launch Zed from the terminal inside any existing Cargo project with:
91`zed .`
92
93Once inside a project:
94
95- Use `Cmd+Shift+O` or `Cmd+E` to jump between files quickly (like RustRover's "Recent Files")
96- Use `Cmd+Shift+A` or `Shift Shift` to open the Command Palette (like RustRover's "Search Everywhere")
97- Use `Cmd+O` to search for symbols (like RustRover's "Go to Symbol")
98
99Open buffers appear as tabs across the top. The sidebar shows your file tree and Git status. Toggle it with `Cmd+1` (just like RustRover's Project tool window).
100
101## Differences in Keybindings
102
103If 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 RustRover.
104
105### Common Shared Keybindings (Zed with JetBrains keymap ↔ RustRover)
106
107| Action | Shortcut |
108| ----------------------------- | ----------------------- |
109| Search Everywhere | `Shift Shift` |
110| Find Action / Command Palette | `Cmd + Shift + A` |
111| Go to File | `Cmd + Shift + O` |
112| Go to Symbol | `Cmd + O` |
113| Recent Files | `Cmd + E` |
114| Go to Definition | `Cmd + B` |
115| Find Usages | `Alt + F7` |
116| Rename Symbol | `Shift + F6` |
117| Reformat Code | `Cmd + Alt + L` |
118| Toggle Project Panel | `Cmd + 1` |
119| Toggle Terminal | `Alt + F12` |
120| Duplicate Line | `Cmd + D` |
121| Delete Line | `Cmd + Backspace` |
122| Move Line Up/Down | `Shift + Alt + Up/Down` |
123| Expand/Shrink Selection | `Alt + Up/Down` |
124| Comment Line | `Cmd + /` |
125| Go Back / Forward | `Cmd + [` / `Cmd + ]` |
126| Toggle Breakpoint | `Ctrl + F8` |
127
128### Different Keybindings (RustRover → Zed)
129
130| Action | RustRover | Zed (JetBrains keymap) |
131| ---------------------- | ----------- | ------------------------ |
132| File Structure | `Cmd + F12` | `Cmd + F12` (outline) |
133| Navigate to Next Error | `F2` | `F2` |
134| Run | `Ctrl + R` | `Ctrl + Alt + R` (tasks) |
135| Debug | `Ctrl + D` | `Alt + Shift + F9` |
136| Stop | `Cmd + F2` | `Ctrl + F2` |
137| Expand Macro | `Alt+Enter` | `Cmd + Shift + M` |
138
139### Unique to Zed
140
141| Action | Shortcut | Notes |
142| ----------------- | -------------------------- | ------------------------------ |
143| Toggle Right Dock | `Cmd + R` | Assistant panel, notifications |
144| Split Panes | `Cmd + K`, then arrow keys | Create splits in any direction |
145
146### How to Customize Keybindings
147
148- Open the Command Palette (`Cmd+Shift+A` or `Shift Shift`)
149- Run `Zed: Open Keymap Editor`
150
151This opens a list of all available bindings. You can override individual shortcuts or remove conflicts.
152
153Zed also supports key sequences (multi-key shortcuts).
154
155## Differences in User Interfaces
156
157### No Indexing
158
159RustRover indexes your project when you first open it to build a model of your codebase. This process runs whenever you open a project or when dependencies change via Cargo.
160
161Zed doesn't index. You open a folder and start working immediately. Because both editors use rust-analyzer under the hood for Rust intelligence, the "indexing" you experience in Zed is rust-analyzer's own analysis, which happens in the background without blocking the UI.
162
163**How to adapt:**
164
165- For project-wide symbol search, use `Cmd+O` / Go to Symbol (powered by rust-analyzer)
166- For finding files by name, use `Cmd+Shift+O` / Go to File
167- For text search across files, use `Cmd+Shift+F`—this is fast even on large codebases
168- For deep static analysis, run `cargo clippy` from the terminal
169
170### rust-analyzer: Shared Foundation, Different Integration
171
172Here's what makes the RustRover-to-Zed transition unique: **both editors use rust-analyzer** for Rust language intelligence. This means the core code analysis—completions, go-to-definition, find references, type inference—is fundamentally the same.
173
174RustRover integrates rust-analyzer into its JetBrains platform, adding a GUI layer, additional refactorings, and its own indexing on top. Zed uses rust-analyzer more directly through the Language Server Protocol (LSP).
175
176What this means for you:
177
178- **Completions** — Same quality, powered by rust-analyzer
179- **Type inference** — Identical, it's the same engine
180- **Go to definition / Find usages** — Works the same way
181- **Macro expansion** — Available in both (use `Cmd+Shift+M` in Zed)
182- **Inlay hints** — Both support type hints, parameter hints, and chaining hints
183
184Where you might notice differences:
185
186- Some refactorings available in RustRover may not have rust-analyzer equivalents
187- RustRover's GUI for configuring rust-analyzer is replaced by JSON configuration in Zed
188- RustRover-specific inspections (beyond Clippy) won't exist in Zed
189
190**How to adapt:**
191
192- Use `Alt+Enter` for available code actions—rust-analyzer provides many
193- Configure rust-analyzer settings in `.zed/settings.json` for project-specific needs
194- Run `cargo clippy` for linting (it integrates with rust-analyzer diagnostics)
195
196### No Project Model
197
198RustRover manages projects through `.idea` folders containing XML configuration files, toolchain assignments, and run configurations. The Cargo tool window provides a visual interface for your project structure, targets, and dependencies.
199
200Zed has no project model. A project is a folder containing a `Cargo.toml`. There's no wizard, no toolchain selection screen, no visual Cargo management.
201
202This means:
203
204- Run configurations don't exist. You define tasks or use the terminal.
205- Toolchain management is external. Use `rustup` from the terminal.
206- Dependencies are managed through `Cargo.toml` directly—no GUI.
207
208**How to adapt:**
209
210- Create a `.zed/settings.json` in your project root for project-specific settings
211- Define common commands in `tasks.json` (open via Command Palette: `zed: open tasks`):
212
213```json
214[
215 {
216 "label": "cargo run",
217 "command": "cargo run"
218 },
219 {
220 "label": "cargo build",
221 "command": "cargo build"
222 },
223 {
224 "label": "cargo test",
225 "command": "cargo test"
226 },
227 {
228 "label": "cargo clippy",
229 "command": "cargo clippy"
230 },
231 {
232 "label": "cargo run --release",
233 "command": "cargo run --release"
234 }
235]
236```
237
238- Use `Ctrl+Alt+R` to run tasks quickly
239- Lean on your terminal (`Alt+F12`) for anything tasks don't cover
240
241### No Cargo Integration UI
242
243RustRover's Cargo tool window provides visual access to your project's targets, dependencies, and common Cargo commands. You can run builds, tests, and benchmarks with a click.
244
245Zed doesn't have a Cargo GUI. You work with Cargo through:
246
247- **Terminal** — Run any Cargo command directly
248- **Tasks** — Define shortcuts for common commands
249- **Gutter icons** — Run tests and binaries with clickable icons
250
251**How to adapt:**
252
253- Get comfortable with Cargo CLI commands: `cargo build`, `cargo run`, `cargo test`, `cargo clippy`, `cargo doc`
254- Use tasks for commands you run frequently
255- For dependency management, edit `Cargo.toml` directly (rust-analyzer provides completions for crate names and versions)
256
257### Tool Windows vs. Docks
258
259RustRover organizes auxiliary views into numbered tool windows (Project = 1, Cargo = Alt+1, Terminal = Alt+F12, etc.). Zed uses a similar concept called "docks":
260
261| RustRover Tool Window | Zed Equivalent | Shortcut (JetBrains keymap) |
262| --------------------- | -------------- | --------------------------- |
263| Project (1) | Project Panel | `Cmd + 1` |
264| Git (9 or Cmd+0) | Git Panel | `Cmd + 0` |
265| Terminal (Alt+F12) | Terminal Panel | `Alt + F12` |
266| Structure (7) | Outline Panel | `Cmd + 7` |
267| Problems (6) | Diagnostics | `Cmd + 6` |
268| Debug (5) | Debug Panel | `Cmd + 5` |
269
270Zed has three dock positions: left, bottom, and right. Panels can be moved between docks by dragging or through settings.
271
272Note that there's no dedicated Cargo tool window in Zed. Use the terminal or define tasks for your common Cargo commands.
273
274### Debugging
275
276Both RustRover and Zed offer integrated debugging for Rust, but using different backends:
277
278- RustRover uses its own debugger integration
279- Zed uses **CodeLLDB** (the same debug adapter popular in VS Code)
280
281To debug Rust code in Zed:
282
283- Set breakpoints with `Ctrl+F8`
284- Start debugging with `Alt+Shift+F9` or press `F4` and select a debug target
285- Step through code with `F7` (step into), `F8` (step over), `Shift+F8` (step out)
286- Continue execution with `F9`
287
288Zed can automatically detect debuggable targets in your Cargo project. Press `F4` to see available options.
289
290For more control, create a `.zed/debug.json` file:
291
292```json
293[
294 {
295 "label": "Debug Binary",
296 "adapter": "CodeLLDB",
297 "request": "launch",
298 "program": "${workspaceFolder}/target/debug/my_project"
299 },
300 {
301 "label": "Debug Tests",
302 "adapter": "CodeLLDB",
303 "request": "launch",
304 "cargo": {
305 "args": ["test", "--no-run"],
306 "filter": {
307 "kind": "test"
308 }
309 }
310 },
311 {
312 "label": "Debug with Arguments",
313 "adapter": "CodeLLDB",
314 "request": "launch",
315 "program": "${workspaceFolder}/target/debug/my_project",
316 "args": ["--config", "dev.toml"]
317 }
318]
319```
320
321> **Note:** Some users have reported that RustRover's debugger can have issues with variable inspection and breakpoints in certain scenarios. CodeLLDB in Zed provides a solid alternative, though debugging Rust can be challenging in any editor due to optimizations and macro-generated code.
322
323### Running Tests
324
325RustRover has a dedicated test runner with a visual interface showing pass/fail status for each test. Zed provides test running through:
326
327- **Gutter icons** — Click the play button next to `#[test]` functions or test modules
328- **Tasks** — Define `cargo test` commands in `tasks.json`
329- **Terminal** — Run `cargo test` directly
330
331The test output appears in the terminal panel. For more detailed output, use:
332
333- `cargo test -- --nocapture` to see println! output
334- `cargo test -- --test-threads=1` for sequential test execution
335- `cargo test specific_test_name` to run a single test
336
337### Extensions vs. Plugins
338
339RustRover has a plugin ecosystem, though it's more limited than other JetBrains IDEs since Rust support is built-in.
340
341Zed's extension ecosystem is smaller and more focused:
342
343- Language support and syntax highlighting
344- Themes
345- Slash commands for AI
346- Context servers
347
348Several features that might require plugins in other editors are built into Zed:
349
350- Real-time collaboration with voice chat
351- AI coding assistance
352- Built-in terminal
353- Task runner
354- rust-analyzer integration
355- rustfmt formatting
356
357### What's Not in Zed
358
359To set expectations clearly, here's what RustRover offers that Zed doesn't have:
360
361- **Cargo.toml GUI editor** — Edit the file directly (rust-analyzer helps with completions)
362- **Visual dependency management** — Use `cargo add`, `cargo remove`, or edit `Cargo.toml`
363- **Profiler integration** — Use `cargo flamegraph`, `perf`, or external profiling tools
364- **Database tools** — Use DataGrip, DBeaver, or TablePlus
365- **HTTP Client** — Use tools like `curl`, `httpie`, or Postman
366- **Coverage visualization** — Use `cargo tarpaulin` or `cargo llvm-cov` externally
367
368## A Note on Licensing and Telemetry
369
370If you're moving from RustRover partly due to licensing concerns or telemetry policies, you should know:
371
372- **Zed is open source** (MIT licensed for the editor, AGPL for collaboration services)
373- **Telemetry is optional** and can be disabled in settings
374- **No license tiers** — all features are available to everyone
375
376```json
377{
378 "telemetry": {
379 "diagnostics": false,
380 "metrics": false
381 }
382}
383```
384
385## Collaboration in Zed vs. RustRover
386
387RustRover offers Code With Me as a separate feature for collaboration. Zed has collaboration built into the core experience.
388
389- Open the Collab Panel in the left dock
390- Create a channel and [invite your collaborators](https://zed.dev/docs/collaboration#inviting-a-collaborator) to join
391- [Share your screen or your codebase](https://zed.dev/docs/collaboration#share-a-project) directly
392
393Once 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.
394
395## Using AI in Zed
396
397If you're used to AI assistants in RustRover (like JetBrains AI Assistant), Zed offers similar capabilities with more flexibility.
398
399### Configuring GitHub Copilot
400
4011. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows)
4022. Navigate to **AI → Edit Predictions**
4033. Click **Configure** next to "Configure Providers"
4044. Under **GitHub Copilot**, click **Sign in to GitHub**
405
406Once signed in, just start typing. Zed will offer suggestions inline for you to accept.
407
408### Additional AI Options
409
410To use other AI models in Zed, you have several options:
411
412- 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).
413- Bring your own [API keys](https://zed.dev/docs/ai/llm-providers.html), no authentication needed
414- Use [external agents like Claude Code](https://zed.dev/docs/ai/external-agents.html)
415
416## Advanced Config and Productivity Tweaks
417
418Zed exposes advanced settings for power users who want to fine-tune their environment.
419
420Here are a few useful tweaks for Rust developers:
421
422**Format on Save (uses rustfmt by default):**
423
424```json
425"format_on_save": "on"
426```
427
428**Configure inlay hints for Rust:**
429
430```json
431{
432 "inlay_hints": {
433 "enabled": true,
434 "show_type_hints": true,
435 "show_parameter_hints": true,
436 "show_other_hints": true
437 }
438}
439```
440
441**Configure rust-analyzer settings:**
442
443```json
444{
445 "lsp": {
446 "rust-analyzer": {
447 "initialization_options": {
448 "checkOnSave": {
449 "command": "clippy"
450 },
451 "cargo": {
452 "allFeatures": true
453 },
454 "procMacro": {
455 "enable": true
456 }
457 }
458 }
459 }
460}
461```
462
463**Use a separate target directory for rust-analyzer (faster builds):**
464
465```json
466{
467 "lsp": {
468 "rust-analyzer": {
469 "initialization_options": {
470 "rust-analyzer.cargo.targetDir": true
471 }
472 }
473 }
474}
475```
476
477This tells rust-analyzer to use `target/rust-analyzer` instead of `target`, so IDE analysis doesn't conflict with your manual `cargo build` commands.
478
479**Enable direnv support (useful for Rust projects using direnv):**
480
481```json
482"load_direnv": "shell_hook"
483```
484
485**Configure linked projects for workspaces:**
486
487If you work with multiple Cargo projects that aren't in a workspace, you can tell rust-analyzer about them:
488
489```json
490{
491 "lsp": {
492 "rust-analyzer": {
493 "initialization_options": {
494 "linkedProjects": [
495 "./project-a/Cargo.toml",
496 "./project-b/Cargo.toml"
497 ]
498 }
499 }
500 }
501}
502```
503
504## Next Steps
505
506Now that you're set up, here are some resources to help you get the most out of Zed:
507
508- [Configuring Zed](../configuring-zed.md) — Customize settings, themes, and editor behavior
509- [Key Bindings](../key-bindings.md) — Learn how to customize and extend your keymap
510- [Tasks](../tasks.md) — Set up build and run commands for your projects
511- [AI Features](../ai/overview.md) — Explore Zed's AI capabilities beyond code completion
512- [Collaboration](../collaboration/overview.md) — Share your projects and code together in real time
513- [Rust in Zed](../languages/rust.md) — Rust-specific setup and configuration