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