Katie Geer created
docs/.rules | 1 +
docs/src/migrate/rustrover.md | 35 +++++++++++++----------------------
docs/src/migrate/webstorm.md | 23 +++++++++++++----------
3 files changed, 27 insertions(+), 32 deletions(-)
@@ -17,6 +17,7 @@
- Apologetic tone for missing features—state the limitation and move on
- Comparisons that disparage other tools—be factual, not competitive
- Meta-commentary about honesty ("the honest take is...", "to be frank...", "honestly...")—let honesty show through frank assessments, not announcements
+- LLM-isms and filler words ("entirely," "certainly," "definitely," "actually")—these add nothing
## Content Structure
@@ -102,7 +102,7 @@ Open buffers appear as tabs across the top. The sidebar shows your file tree and
If 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.
-### Common Shared Keybindings (Zed with JetBrains keymap ↔ RustRover)
+### Common Shared Keybindings
| Action | Shortcut |
| ----------------------------- | ----------------------- |
@@ -158,14 +158,14 @@ Zed also supports key sequences (multi-key shortcuts).
RustRover 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.
-Zed 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.
+Zed 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.
**How to adapt:**
-- For project-wide symbol search, use `Cmd+O` / Go to Symbol (powered by rust-analyzer)
-- For finding files by name, use `Cmd+Shift+O` / Go to File
-- For text search across files, use `Cmd+Shift+F`—this is fast even on large codebases
-- For deep static analysis, run `cargo clippy` from the terminal
+- Use `Cmd+O` to search symbols across your crate (rust-analyzer handles this)
+- Jump to files by name with `Cmd+Shift+O`
+- `Cmd+Shift+F` gives you fast text search across the entire project
+- For linting and deeper checks, run `cargo clippy` in the terminal
### rust-analyzer: Shared Foundation, Different Integration
@@ -197,13 +197,13 @@ Where you might notice differences:
RustRover 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.
-Zed 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.
+Zed keeps it simpler: a project is a folder with a `Cargo.toml`. No project wizard, no toolchain dialogs, no visual Cargo management layer.
-This means:
+In practice:
-- Run configurations don't exist. You define tasks or use the terminal.
-- Toolchain management is external. Use `rustup` from the terminal.
-- Dependencies are managed through `Cargo.toml` directly—no GUI.
+- Run configurations don't carry over. Your `.idea/` setup stays behind—define the commands you need in `tasks.json` instead.
+- Toolchains are managed externally via `rustup`.
+- Dependencies live in `Cargo.toml`. Edit the file directly; rust-analyzer provides completions for crate names and versions.
**How to adapt:**
@@ -370,17 +370,8 @@ To set expectations clearly, here's what RustRover offers that Zed doesn't have:
If you're moving from RustRover partly due to licensing concerns or telemetry policies, you should know:
- **Zed is open source** (MIT licensed for the editor, AGPL for collaboration services)
-- **Telemetry is optional** and can be disabled in settings
-- **No license tiers** — all features are available to everyone
-
-```json
-{
- "telemetry": {
- "diagnostics": false,
- "metrics": false
- }
-}
-```
+- **Telemetry is optional** and can be disabled during onboarding or in settings
+- **No license tiers**: All features are available to everyone
## Collaboration in Zed vs. RustRover
@@ -148,14 +148,16 @@ If you've used WebStorm on large projects, you know the wait. Opening a project
> "I work for AWS and the applications I deal with are massive. Often I need to keep many projects open due to tight dependencies. I'm talking about complex microservices and micro frontend infrastructure which oftentimes lead to 2-15 minutes of indexing wait time whenever I open a project or build the system locally."
> — Developer working on large-scale microservices
-Zed doesn't index. You open a folder and start working immediately. File search and navigation work instantly regardless of project size. The trade-off is real: WebStorm's index powers features like finding all usages across your entire codebase, understanding import hierarchies, and detecting unused exports project-wide. Zed delegates this work to language servers, which may not analyze as deeply or as broadly.
+Zed doesn't index. You open a folder and start coding immediately—no progress bars, no "Indexing paused" banners. File search and navigation stay fast regardless of project size or how many `node_modules` dependencies you have.
+
+The trade-off: WebStorm's index enables features like finding all usages across your entire codebase, tracking import hierarchies, and flagging unused exports project-wide. Zed relies on language servers for this analysis, which may not cover as much ground.
**How to adapt:**
-- For project-wide symbol search, use `Cmd+O` / Go to Symbol (relies on your language server)
-- For finding files by name, use `Cmd+Shift+O` / Go to File
-- For text search across files, use `Cmd+Shift+F`—this is fast even on large codebases
-- For deep static analysis, consider running ESLint, TypeScript compiler checks, or other tools from the terminal
+- Search symbols across the project with `Cmd+O` (powered by the TypeScript language server)
+- Find files by name with `Cmd+Shift+O`
+- Use `Cmd+Shift+F` for text search—it stays fast even in large monorepos
+- Run `tsc --noEmit` or `eslint .` from the terminal when you need deeper project-wide analysis
### LSP vs. Native Language Intelligence
@@ -181,18 +183,19 @@ Where you might notice differences:
- Use `Alt+Enter` for available code actions—the list will vary by language server
- Ensure your `tsconfig.json` is properly configured so the language server understands your project structure
- Use Prettier for consistent formatting (it's enabled by default for JS/TS)
+- For code inspection similar to WebStorm's "Inspect Code," check the Diagnostics panel (`Cmd+6`)—ESLint and TypeScript together catch many of the same issues
### No Project Model
WebStorm manages projects through `.idea` folders containing XML configuration files, framework detection, and run configurations. This model lets WebStorm remember your project settings, manage npm scripts through the UI, and persist run/debug setups.
-Zed has no project model. A project is a folder. There's no wizard, no framework detection screen, no project structure configuration.
+Zed takes a different approach: a project is just a folder. There's no setup wizard, no framework detection dialog, no project structure to configure.
-This means:
+What this means in practice:
-- Run configurations don't exist. You define tasks or use the terminal.
-- npm script management is external. Use `npm run`, `pnpm`, or `yarn` from the terminal.
-- Framework detection doesn't happen. Zed treats all JavaScript/TypeScript the same.
+- Run configurations aren't a thing. Define reusable commands in `tasks.json` instead. Note that your existing `.idea/` configurations won't carry over—you'll set up the ones you need fresh.
+- npm scripts live in the terminal. Run `npm run dev`, `pnpm build`, or `yarn test` directly—there's no dedicated npm panel.
+- No framework detection. Zed treats React, Angular, Vue, and vanilla JS/TS the same way.
**How to adapt:**