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