Python in Astral's Developer Tooling Ecosystem

Astral publishes three projects for the Python ecosystem, documented together at docs.astral.sh. Each is written in Rust and addresses a different part of the Python workflow: package and project management, linting and formatting, and type checking. Astral also points readers to its GitHub repositories, its Discord community for questions and support, and its blog for news and announcements.

• uv — Python package and project manager
• Ruff — Python linter and code formatter
• ty — Python type checker and language server
• Repositories published as open source on GitHub
• Discord community for questions and support

uv is described as an extremely fast Python package and project manager, intended as a single tool to replace pip, pip-tools, pipx, poetry, pyenv, twine, virtualenv and more. It provides project management with a universal lockfile, runs scripts with inline dependency metadata, installs and manages Python versions, and runs or installs tools published as Python packages. A pip-compatible interface is included for a familiar CLI, alongside Cargo-style workspaces and a global cache for dependency deduplication. uv can be installed with a standalone installer via curl or PowerShell, and also via pip, Homebrew and other methods, without requiring Rust or Python.

• Stated as 10-100x faster than pip
• Installs and manages Python versions
• Runs single-file scripts in isolated environments
• Supports macOS, Linux and Windows
• Commands include uv init, uv add, uv run, uv lock and uv sync

Ruff is an extremely fast Python linter and code formatter, installable via pip and usable as a drop-in replacement for Flake8 (plus dozens of plugins), isort, pydocstyle, pyupgrade, autoflake and Black. The documentation states it is 10-100x faster than existing linters and formatters, with built-in caching to avoid re-analysing unchanged files. Fix support allows automatic error correction, such as automatically removing unused imports. Ruff is described as being used in open-source projects including Apache Airflow, Apache Superset, FastAPI, Hugging Face, Pandas and SciPy.

• Over 900 built-in lint rules, each re-implemented in Rust
• ruff check for linting, with --fix and --watch options
• ruff format for formatting, with --check for verification
• Python 3.14 compatibility
• First-party editor integrations for VS Code and more
• Monorepo-friendly hierarchical and cascading configuration

Ruff is configured through a pyproject.toml, ruff.toml or .ruff.toml file, with the same configuration strategy and semantics whether it is used as a linter, a formatter, or both. Enabled rules are controlled via the lint.select, lint.extend-select and lint.ignore settings, using Flake8-style rule codes such as F401 or prefixes such as F. By default Ruff enables rules from the F, E, B, UP and RUF categories, omitting stylistic rules that overlap with a formatter. Top-level settings include exclude patterns, cache-dir, builtins and line-length, with the default configuration using a line length of 88 and a target version of Python 3.10.

• Configuration files: pyproject.toml, ruff.toml, .ruff.toml
• ALL selector enables every rule, with conflicting rules auto-disabled
• Default line-length 88 and indent-width 4
• Formatter defaults mirror Black: double quotes, space indentation
• Docstring and Markdown code-block formatting options

ty is an extremely fast Python type checker and language server, written in Rust and backed by Astral. The documentation states it is 10x to 100x faster than mypy and Pyright, and provides comprehensive diagnostics with contextual information, configurable rule levels, per-file overrides and suppression comments. It is designed for gradual adoption, supporting redeclarations and partially typed code, and performs fine-grained incremental analysis for fast updates while editing. Running `uvx ty check` checks all Python files in the working directory or project; an online playground is available for trying it on snippets.

• Language server with completions, code actions, auto-import and inlay hints
• Editor integrations for VS Code, PyCharm, Neovim and more
• Advanced typing features including intersection types and type narrowing
• Quick start with uvx ty check
• Online playground for sharing snippets

Ruff's FAQ states that the linter is compatible with Black out of the box, provided the line-length setting is consistent between the two, and that Ruff defers implementing stylistic rules obviated by automated formatting. The formatter is designed as a drop-in replacement for Black and emits near-identical output over Black-formatted code; across projects such as Django and Zulip, more than 99.9% of lines are formatted identically. Ruff can act as a drop-in replacement for Flake8 when used without or with few plugins, alongside Black, and on Python 3 code, implementing all F rules and a subset of E and W rules. Many popular Flake8 plugins and related tools, including autoflake, eradicate and flake8-bugbear, are re-implemented natively.

• Black-compatible formatting via ruff format
• Flake8 rule code system mirrored, including E501 line-too-long
• Native re-implementations of popular Flake8 plugins
• Rust installation not required to use Ruff

Ruff's contributing guide explains how community members can take part in development. Issues suitable for newcomers are labelled good first issue, while help wanted marks opportunities for subsequent contributions; issues labelled needs-decision or needs-design are not suitable for pull requests. Contributors are asked to flag their intent on an issue to avoid duplicate work and to discuss new features before opening a pull request. All use of AI in contributions must follow Astral's AI Policy, and a separate contributing guide covers ty.

• good first issue and help wanted labels for community work
• Prior discussion required for new features
• AI Policy applies to all contributions
• Codebase organised into crates such as ruff_linter and ruff_formatter