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