1# How to Migrate from PyCharm to Zed
2
3This guide covers how to set up Zed if you're coming from PyCharm, including keybindings, settings, and the differences you should expect.
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 PyCharm, 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 PyCharm 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. |
63| `soft_wrap` | Wrap long lines. Options: `"none"`, `"editor_width"`, `"preferred_line_length"` |
64| `preferred_line_length` | Column width for wrapping and rulers. Default is 80, PEP 8 recommends 79. |
65| `inlay_hints` | Show parameter names and type hints inline, like PyCharm's hints. |
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 PyCharm.
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 PyCharm, there's no project configuration wizard, no interpreter selection dialog, and no project structure setup required.
75
76To start a new project, create a directory using your terminal or file manager, then open it in Zed. The editor will treat that folder as the root of your project.
77
78You can also launch Zed from the terminal inside any folder with:
79`zed .`
80
81Once inside a project:
82
83- Use `Cmd+Shift+O` or `Cmd+E` to jump between files quickly (like PyCharm's "Recent Files")
84- Use `Cmd+Shift+A` or `Shift Shift` to open the Command Palette (like PyCharm's "Search Everywhere")
85- Use `Cmd+O` to search for symbols (like PyCharm's "Go to Symbol")
86
87Open buffers appear as tabs across the top. The sidebar shows your file tree and Git status. Toggle it with `Cmd+1` (just like PyCharm's Project tool window).
88
89## Differences in Keybindings
90
91If 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 PyCharm.
92
93### Common Shared Keybindings
94
95| Action | Shortcut |
96| ----------------------------- | ----------------------- |
97| Search Everywhere | `Shift Shift` |
98| Find Action / Command Palette | `Cmd + Shift + A` |
99| Go to File | `Cmd + Shift + O` |
100| Go to Symbol | `Cmd + O` |
101| Recent Files | `Cmd + E` |
102| Go to Definition | `Cmd + B` |
103| Find Usages | `Alt + F7` |
104| Rename Symbol | `Shift + F6` |
105| Reformat Code | `Cmd + Alt + L` |
106| Toggle Project Panel | `Cmd + 1` |
107| Toggle Terminal | `Alt + F12` |
108| Duplicate Line | `Cmd + D` |
109| Delete Line | `Cmd + Backspace` |
110| Move Line Up/Down | `Shift + Alt + Up/Down` |
111| Expand/Shrink Selection | `Alt + Up/Down` |
112| Comment Line | `Cmd + /` |
113| Go Back / Forward | `Cmd + [` / `Cmd + ]` |
114| Toggle Breakpoint | `Ctrl + F8` |
115
116### Different Keybindings (PyCharm → Zed)
117
118| Action | PyCharm | Zed (JetBrains keymap) |
119| ---------------------- | ----------- | ------------------------ |
120| File Structure | `Cmd + F12` | `Cmd + F12` (outline) |
121| Navigate to Next Error | `F2` | `F2` |
122| Run | `Ctrl + R` | `Ctrl + Alt + R` (tasks) |
123| Debug | `Ctrl + D` | `Alt + Shift + F9` |
124| Stop | `Cmd + F2` | `Ctrl + F2` |
125
126### Unique to Zed
127
128| Action | Shortcut | Notes |
129| ----------------- | -------------------------- | ------------------------------ |
130| Toggle Right Dock | `Cmd + R` | Assistant panel, notifications |
131| Split Panes | `Cmd + K`, then arrow keys | Create splits in any direction |
132
133### How to Customize Keybindings
134
135- Open the Command Palette (`Cmd+Shift+A` or `Shift Shift`)
136- Run `Zed: Open Keymap Editor`
137
138This opens a list of all available bindings. You can override individual shortcuts or remove conflicts.
139
140Zed also supports key sequences (multi-key shortcuts).
141
142## Differences in User Interfaces
143
144### No Indexing
145
146If you've used PyCharm on large projects, you know the wait: "Indexing..." can take anywhere from 30 seconds to several minutes depending on project size and dependencies. PyCharm builds a comprehensive index of your entire codebase to power its code intelligence, and it re-indexes when dependencies change or when you install new packages.
147
148Zed doesn't index. You open a folder and start working immediately. File search and navigation work instantly regardless of project size. For many PyCharm users, this alone is reason enough to switch—no more waiting, no more "Indexing paused" interruptions.
149
150PyCharm's index powers features like finding all usages across your entire codebase, understanding class hierarchies, and detecting unused imports project-wide. Zed delegates this work to language servers, which may not analyze as deeply or as broadly.
151
152**How to adapt:**
153
154- For project-wide symbol search, use `Cmd+O` / Go to Symbol (relies on your language server)
155- For finding files by name, use `Cmd+Shift+O` / Go to File
156- For text search across files, use `Cmd+Shift+F`—this is fast even on large codebases
157- For deep static analysis, consider running tools like `mypy`, `pylint`, or `ruff check` from the terminal
158
159### LSP vs. Native Language Intelligence
160
161PyCharm has its own language analysis engine built specifically for Python. This engine understands your code deeply: it resolves types without annotations, tracks data flow, knows about Django models and Flask routes, and offers specialized refactorings.
162
163Zed uses the Language Server Protocol (LSP) for code intelligence. For Python, Zed provides several language servers out of the box:
164
165- **basedpyright** (default) — Fast type checking and completions
166- **Ruff** (default) — Linting and formatting
167- **Ty** — Up-and-coming language server from Astral, built for speed
168- **Pyright** — Microsoft's type checker
169- **PyLSP** — Plugin-based server with tool integrations
170
171The LSP experience for Python is strong. basedpyright provides accurate completions, type checking, and navigation. Ruff handles formatting and linting with excellent performance.
172
173Where you might notice differences:
174
175- Framework-specific intelligence (Django ORM, Flask routes) isn't built-in
176- Some complex refactorings (extract method with proper scope analysis) may be less sophisticated
177- Auto-import suggestions depend on what the language server knows about your environment
178
179**How to adapt:**
180
181- Use `Alt+Enter` for available code actions—the list will vary by language server
182- Ensure your virtual environment is selected so the language server can resolve your dependencies
183- Use Ruff for fast, consistent formatting (it's enabled by default)
184- For code inspection similar to PyCharm's "Inspect Code," run `ruff check .` or check the Diagnostics panel (`Cmd+6`)—basedpyright and Ruff together catch many of the same issues
185
186### Virtual Environments and Interpreters
187
188In PyCharm, you select a Python interpreter through a GUI, and PyCharm manages the connection between your project and that interpreter. It shows available packages, lets you install new ones, and keeps track of which environment each project uses.
189
190Zed handles virtual environments through its toolchain system:
191
192- Zed automatically discovers virtual environments in common locations (`.venv`, `venv`, `.env`, `env`)
193- When a virtual environment is detected, the terminal auto-activates it
194- Language servers are automatically configured to use the discovered environment
195- You can manually select a toolchain if auto-detection picks the wrong one
196
197**How to adapt:**
198
199- Create your virtual environment with `python -m venv .venv` or `uv sync`
200- Open the folder in Zed—it will detect the environment automatically
201- If you need to switch environments, use the toolchain selector
202- For conda environments, ensure they're activated in your shell before launching Zed
203
204> **Tip:** If basedpyright shows import errors for packages you've installed, check that Zed has selected the correct virtual environment. Use the toolchain selector to verify or change the active environment.
205
206### No Project Model
207
208PyCharm manages projects through `.idea` folders containing XML configuration files, interpreter assignments, and run configurations. This model lets PyCharm remember your interpreter choice, manage dependencies through the UI, and persist complex run/debug setups.
209
210Zed has no project model. A project is a folder. There's no wizard, no interpreter selection screen, no project structure configuration.
211
212This means:
213
214- Run configurations don't exist. You define tasks or use the terminal. Your existing PyCharm run configs in `.idea/` won't be read—you'll recreate the ones you need in `tasks.json`.
215- Interpreter management is external. Zed discovers environments but doesn't create them.
216- Dependencies are managed through pip, uv, poetry, or conda—not through the editor.
217- There's no Python Console (interactive REPL) panel. Use `python` or `ipython` in the terminal instead.
218
219**How to adapt:**
220
221- Create a `.zed/settings.json` in your project root for project-specific settings
222- Define common commands in `tasks.json` (open via Command Palette: `zed: open tasks`):
223
224```json
225[
226 {
227 "label": "run",
228 "command": "python main.py"
229 },
230 {
231 "label": "test",
232 "command": "pytest"
233 },
234 {
235 "label": "test current file",
236 "command": "pytest $ZED_FILE"
237 }
238]
239```
240
241- Use `Ctrl+Alt+R` to run tasks quickly
242- Lean on your terminal (`Alt+F12`) for anything tasks don't cover
243
244### No Framework Integration
245
246PyCharm Professional's value for web development comes largely from its framework integration. Django templates are understood and navigable. Flask routes are indexed. SQLAlchemy models get special treatment. Template variables autocomplete.
247
248Zed has none of this. The language server sees Python code as Python code—it doesn't understand that `@app.route` defines an endpoint or that a Django model class creates database tables.
249
250**How to adapt:**
251
252- Use grep and file search liberally. `Cmd+Shift+F` with a regex can find route definitions, model classes, or template usages.
253- Rely on your language server's "find references" (`Alt+F7`) for navigation—it works, just without framework context
254- Consider using framework-specific CLI tools (`python manage.py`, `flask routes`) from Zed's terminal
255
256> **Tip:** For database work, pick up a dedicated tool like DataGrip, DBeaver, or TablePlus. Many developers who switch to Zed keep DataGrip around specifically for SQL.
257
258### Tool Windows vs. Docks
259
260PyCharm organizes auxiliary views into numbered tool windows (Project = 1, Python Console = 4, Terminal = Alt+F12, etc.). Zed uses a similar concept called "docks":
261
262| PyCharm Tool Window | Zed Equivalent | Shortcut (JetBrains keymap) |
263| ------------------- | -------------- | --------------------------- |
264| Project (1) | Project Panel | `Cmd + 1` |
265| Git (9 or Cmd+0) | Git Panel | `Cmd + 0` |
266| Terminal (Alt+F12) | Terminal Panel | `Alt + F12` |
267| Structure (7) | Outline Panel | `Cmd + 7` |
268| Problems (6) | Diagnostics | `Cmd + 6` |
269| Debug (5) | Debug Panel | `Cmd + 5` |
270
271Zed has three dock positions: left, bottom, and right. Panels can be moved between docks by dragging or through settings.
272
273### Debugging
274
275Both PyCharm and Zed offer integrated debugging, but the experience differs:
276
277- Zed uses `debugpy` (the same debug adapter that VS Code uses)
278- Set breakpoints with `Ctrl+F8`
279- Start debugging with `Alt+Shift+F9` or press `F4` and select a debug target
280- Step through code with `F7` (step into), `F8` (step over), `Shift+F8` (step out)
281- Continue execution with `F9`
282
283Zed can automatically detect debuggable entry points. Press `F4` to see available options, including:
284
285- Python scripts
286- Modules
287- pytest tests
288
289For more control, create a `.zed/debug.json` file:
290
291```json
292[
293 {
294 "label": "Debug Current File",
295 "adapter": "Debugpy",
296 "program": "$ZED_FILE",
297 "request": "launch"
298 },
299 {
300 "label": "Debug Flask App",
301 "adapter": "Debugpy",
302 "request": "launch",
303 "module": "flask",
304 "args": ["run", "--debug"],
305 "env": {
306 "FLASK_APP": "app.py"
307 }
308 }
309]
310```
311
312### Running Tests
313
314PyCharm has a dedicated test runner with a visual interface showing pass/fail status for each test. Zed provides test running through:
315
316- **Gutter icons** — Click the play button next to test functions or classes
317- **Tasks** — Define pytest or unittest commands in `tasks.json`
318- **Terminal** — Run `pytest` directly
319
320The test output appears in the terminal panel. For pytest, use `--tb=short` for concise tracebacks or `-v` for verbose output.
321
322### Extensions vs. Plugins
323
324PyCharm has a plugin ecosystem covering everything from additional language support to database tools to deployment integrations.
325
326Zed's extension ecosystem is smaller and more focused:
327
328- Language support and syntax highlighting
329- Themes
330- Slash commands for AI
331- Context servers
332
333Several features that require plugins in PyCharm are built into Zed:
334
335- Real-time collaboration with voice chat
336- AI coding assistance
337- Built-in terminal
338- Task runner
339- LSP-based code intelligence
340- Ruff formatting and linting
341
342### What's Not in Zed
343
344To set expectations clearly, here's what PyCharm offers that Zed doesn't have:
345
346- **Scientific Mode / Jupyter integration** — For notebooks and data science workflows, use JupyterLab or VS Code with the Jupyter extension alongside Zed for your Python editing
347- **Database tools** — Use DataGrip, DBeaver, or TablePlus
348- **Django/Flask template navigation** — Use file search and grep
349- **Visual package manager** — Use pip, uv, or poetry from the terminal
350- **Remote interpreters** — Zed has remote development, but it works differently
351- **Profiler integration** — Use cProfile, py-spy, or similar tools externally
352
353## Collaboration in Zed vs. PyCharm
354
355PyCharm offers Code With Me as a separate plugin for collaboration. Zed has collaboration built into the core experience.
356
357- Open the Collab Panel in the left dock
358- Create a channel and [invite your collaborators](https://zed.dev/docs/collaboration#inviting-a-collaborator) to join
359- [Share your screen or your codebase](https://zed.dev/docs/collaboration#share-a-project) directly
360
361Once 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.
362
363## Using AI in Zed
364
365If you're used to AI assistants in PyCharm (like GitHub Copilot or JetBrains AI Assistant), Zed offers similar capabilities with more flexibility.
366
367### Configuring GitHub Copilot
368
3691. Open Settings with `Cmd+,` (macOS) or `Ctrl+,` (Linux/Windows)
3702. Navigate to **AI → Edit Predictions**
3713. Click **Configure** next to "Configure Providers"
3724. Under **GitHub Copilot**, click **Sign in to GitHub**
373
374Once signed in, just start typing. Zed will offer suggestions inline for you to accept.
375
376### Additional AI Options
377
378To use other AI models in Zed, you have several options:
379
380- 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).
381- Bring your own [API keys](https://zed.dev/docs/ai/llm-providers.html), no authentication needed
382- Use [external agents like Claude Code](https://zed.dev/docs/ai/external-agents.html)
383
384## Advanced Config and Productivity Tweaks
385
386Zed exposes advanced settings for power users who want to fine-tune their environment.
387
388Here are a few useful tweaks:
389
390**Format on Save:**
391
392```json
393"format_on_save": "on"
394```
395
396**Enable direnv support (useful for Python projects using direnv):**
397
398```json
399"load_direnv": "shell_hook"
400```
401
402**Customize virtual environment detection:**
403
404```json
405{
406 "terminal": {
407 "detect_venv": {
408 "on": {
409 "directories": [".venv", "venv", ".env", "env"],
410 "activate_script": "default"
411 }
412 }
413 }
414}
415```
416
417**Configure basedpyright type checking strictness:**
418
419If you find basedpyright too strict or too lenient, configure it in your project's `pyrightconfig.json`:
420
421```json
422{
423 "typeCheckingMode": "basic"
424}
425```
426
427Options are `"off"`, `"basic"`, `"standard"` (default), `"strict"`, or `"all"`.
428
429## Next Steps
430
431Now that you're set up, here are some resources to help you get the most out of Zed:
432
433- [Configuring Zed](../configuring-zed.md) — Customize settings, themes, and editor behavior
434- [Key Bindings](../key-bindings.md) — Learn how to customize and extend your keymap
435- [Tasks](../tasks.md) — Set up build and run commands for your projects
436- [AI Features](../ai/overview.md) — Explore Zed's AI capabilities beyond code completion
437- [Collaboration](../collaboration/overview.md) — Share your projects and code together in real time
438- [Python in Zed](../languages/python.md) — Python-specific setup and configuration