Python | Zed Code Editor Documentation
Description: Learn how to use and customize Zed, the fast, collaborative code editor. Official docs on features, configuration, AI tools, and workflows.

# Python

Python support is available natively in Zed.

- Tree-sitter: tree-sitter-python
- Language Servers:
  - microsoft/pyright
  - python-lsp/python-lsp-server (PyLSP)
- Debug Adapter: debugpy

## Language Servers

Zed supports multiple Python language servers some of which may require configuration to work properly.

See: Working with Language Servers for more information.

## Virtual Environments in the Terminal

Zed will detect Python virtual environments and automatically activate them in terminal if available. See: detect_venv documentation for more.

## PyLSP

python-lsp-server, more commonly known as PyLSP, by default integrates with a number of external tools (autopep8, mccabe, pycodestyle, yapf) while others are optional and must be explicitly enabled and configured (flake8, pylint).

See Python Language Server Configuration for more.

## PyRight

### PyRight Configuration

The pyright language server offers flexible configuration options specified in a JSON-formatted text configuration. By default, the file is called `pyrightconfig.json` and is located within the root directory of your project. Pyright settings can also be specified in a `[tool.pyright]` section of a `pyproject.toml` file. A `pyrightconfig.json` file always takes precedence over `pyproject.toml` if both are present.

For more information, see the Pyright configuration documentation.

### PyRight Settings

The pyright language server also accepts specific LSP-related settings, not necessarily connected to a project. These can be changed in the `lsp` section of your `settings.json`.

For example, in order to:

- use strict type-checking level
- diagnose all files in the workspace instead of the only open files default
- provide the path to a specific Python interpreter

    {
      "lsp": {
        "pyright": {
          "settings": {
            "python.analysis": {
              "diagnosticMode": "workspace",
              "typeCheckingMode": "strict"
            },
            "python": {
              "pythonPath": ".venv/bin/python"
            }
          }
        }
      }
    }

For more information, see the Pyright settings documentation.

### Pyright Virtual environments

A Python virtual environment allows you to store all of a project's dependencies, including the Python interpreter and package manager, in a single directory that's isolated from any other Python projects on your computer.

By default, the Pyright language server will look for Python packages in the default global locations. But you can also configure Pyright to use the packages installed in a given virtual environment.

To do this, create a JSON file called `pyrightconfig.json` at the root of your project. This file must include two keys:

- `venvPath`: a relative path from your project directory to any directory that contains one or more virtual environment directories
- `venv`: the name of a virtual environment directory

For example, a common approach is to create a virtual environment directory called `.venv` at the root of your project directory with the following commands:

    # create a virtual environment in the .venv directory
    python3 -m venv .venv
    # set up the current shell to use that virtual environment
    source .venv/bin/activate

Having done that, you would create a `pyrightconfig.json` with the following content:

    {
      "venvPath": ".",
      "venv": ".venv"
    }

If you prefer to use a `pyproject.toml` file, you can add the following section:

    [tool.pyright]
    venvPath = "."
    venv = ".venv"

You can also configure this option directly in your `settings.json` file (pyright settings), as recommended in Configuring Your Python Environment.

    {
      "lsp": {
        "pyright": {
          "settings": {
            "python": {
              "pythonPath": ".venv/bin/python"
            }
          }
        }
      }
    }

### Code formatting & Linting

The Pyright language server does not provide code formatting or linting. If you want to detect lint errors and reformat your Python code upon saving, you'll need to set up.

A common tool for formatting Python code is Ruff. It is another tool written in Rust, an extremely fast Python linter and code formatter. It is available through the Ruff extension. To configure the Ruff extension to work within Zed, see the setup documentation here.

## Debugging

Zed supports zero-configuration debugging of Python module entry points and pytest tests. Run `debugger: start` (`f4|f4`) to see a contextual list for the current project. For greater control, you can add debug configurations to `.zed/debug.json`. See the examples below.

### Debug Active File

    [
      {
        "label": "Python Active File",
        "adapter": "Debugpy",
        "program": "$ZED_FILE",
        "request": "launch"
      }
    ]

### Flask App

For a common Flask Application with a file structure similar to the following:

    .venv/
    app/
      init.py
      main.py
      routes.py
    templates/
      index.html
    static/
      style.css
    requirements.txt

…the following configuration can be used:

    [
      {
        "label": "Python: Flask",
        "adapter": "Debugpy",
        "request": "launch",
        "module": "app",
        "cwd": "$ZED_WORKTREE_ROOT",
        "env": {
          "FLASK_APP": "app",
          "FLASK_DEBUG": "1"
        },
        "args": [
          "run",
          "--reload", // Enables Flask reloader that watches for file changes
          "--debugger" // Enables Flask debugger
        ],
        "autoReload": {
          "enable": true
        },
        "jinja": true,
        "justMyCode": true
      }
    ]