Astral — Next-Gen Python Tooling (Ruff, uv, ty)

Astral states that its mission is to make the Python ecosystem more productive by building high-performance developer tools. The company describes building in the open, with tools that are open source and permissively licensed, and says it strives to advance existing standards and integrate with the broader ecosystem. Its stated values are openness, action and craft. Astral was founded by Charlie Marsh, who first released Ruff and describes the response to it as evidence of an opportunity for faster Python tooling.

• Mission: make the Python ecosystem more productive
• Tools open source and permissively licensed
• Stated values: openness, action, craft
• Founder: Charlie Marsh

Astral publishes three projects, each written in Rust and documented on docs.astral.sh. uv is a Python package manager, Ruff is a Python linter and formatter, and ty is a Python type checker and language server. ty is described as an alternative to mypy, Pyright and Pylance.

• uv — Python package manager
• Ruff — Python linter and formatter
• ty — Python type checker and language server

The Ruff linter is designed as a drop-in replacement for Flake8 and its plugins, as well as isort, pydocstyle, pyupgrade and autoflake. Its primary entrypoint is `ruff check`, which lints discovered Python files and can fix fixable errors or re-lint on change. Rule selection follows Flake8's code system, controlled through the `lint.select`, `lint.extend-select` and `lint.ignore` settings, with an `ALL` selector as a special case. Ruff supports over 900 lint rules, each re-implemented in Rust as a first-party feature, with categories covering correctness, suspicious code, complexity, performance, style, security, formatting and pedantic checks.

• Entrypoint: ruff check
• Over 900 lint rules
• Default rule set includes F, E, B, UP and RUF categories
• Rule codes mirror Flake8 prefixes, e.g. F401

The Ruff formatter is available through the `ruff format` command in the same CLI and is designed as a drop-in replacement for Black. Astral states that it aims to emit near-identical output on Black-formatted code, reporting that more than 99.9% of lines are formatted identically when run over projects such as Django and Zulip. Running `ruff format --check` avoids writing files and exits with a non-zero status when unformatted files are found. The stated philosophy is to innovate on performance and provide a unified toolchain rather than on code style.

• Entrypoint: ruff format
• Drop-in replacement for Black
• Supports docstring and Markdown code formatting
• --check mode for CI use

Ruff is configured through a `pyproject.toml` or `ruff.toml` file, with top-level settings such as `builtins`, `cache-dir`, `exclude`, `extend` and `include`, and per-rule options documented in the settings reference. The Ruff Language Server adds editor-specific options, which can be supplied as a configuration file path or as inline JSON. Editor settings resolve in a defined order: individual settings take precedence over `ruff.configuration`, which in turn takes precedence over a project configuration file. Setup instructions cover editors including VS Code, Neovim and Zed.

• Configuration via pyproject.toml or ruff.toml
• Language server settings including lineLength, fixAll and organizeImports
• configurationPreference options: editorFirst, filesystemFirst, editorOnly
• Inline JSON configuration added in Ruff 0.9.8

The Ruff tutorial walks through initialising a project with uv, adding Ruff as a development dependency, and running the linter and formatter via `uv run`. Ruff can be run in continuous integration through GitHub Actions, either directly or via the `astral-sh/ruff-action` action, and through GitLab CI/CD with a code quality report output. A pre-commit hook is available via `ruff-pre-commit`, and Docker images are published for Alpine, Debian slim and Debian bases. uv also provides the `uvx` command for invoking a tool without installing it.

• astral-sh/ruff-action for GitHub Actions, with version, args and src inputs
• GitLab CI/CD with --output-format=gitlab
• ruff-pre-commit hooks: ruff-check and ruff-format
• Docker images tagged ruff:latest and by version
• uvx for running tools without installing

Astral publishes its repositories on GitHub and runs a Discord community where users can ask questions, share ideas and get support. The documentation site also links to news, updates and announcements from the team. Ruff contributions are guided by a contributing document that labels issues as "good first issue" or "help wanted", asks contributors not to open pull requests for new features without prior discussion, and requires any use of AI to follow Astral's AI policy. ty has a separate contributing guide.

• Open-source repositories on GitHub
• Community Discord for questions and support
• Issue labels: good first issue, help wanted
• AI policy applies to all contributions

Astral describes itself as a small, distributed team of software engineers that is growing deliberately. Its early team includes the authors of ripgrep, bat, hyperfine and maturin, early core contributors to Biome and Prefect, and multiple CPython core developers. The about page notes an agreement for Astral to join OpenAI as part of the Codex team, and an announcement of ty as a Python type checker and language server.

• Small, distributed engineering team
• Includes authors of ripgrep, bat, hyperfine and maturin
• Includes multiple CPython core developers
• Agreement announced for Astral to join OpenAI's Codex team