Ruff

Visit Website

Introduction

Ruff is an extremely fast Python linter and code formatter written in Rust, built by Astral, the company behind the uv package manager. The README claims it is 10 to 100 times faster than existing linters like Flake8 and formatters like Black.

Speed is the headline, but consolidation is the bigger practical win. Ruff ships over 900 built-in rules, including native re-implementations of popular Flake8 plugins such as flake8-bugbear, along with rules from isort, pyupgrade, pydocstyle, pycodestyle and others. The README says it can replace Flake8 plus dozens of plugins, isort, pydocstyle, pyupgrade and autoflake, and that its formatter is a drop-in replacement for Black.

Configuration lives in pyproject.toml or ruff.toml. You select rule families by prefix, such as E, F, B or UP, and set per-file ignores. Fix support automatically corrects many problems, for example removing unused imports or upgrading syntax for newer Python versions. Ruff caches results and respects .gitignore.

Editor integration comes through a language server, and it runs well as a pre-commit hook or a CI step that finishes in seconds even on large monorepos. Ruff has become one of the most widely adopted Python tools, with more than 51,000 GitHub stars.

In the quality loop Ruff is the first gate for Python code. It does not do full type checking, so many teams pair it with mypy or Pyright, and some keep Pylint for deeper checks Ruff does not yet cover.

The source code is at astral-sh/ruff on GitHub under the MIT licence, with about 51,100 stars; the most recent commit was on 11 November 2026.

A practical migration path is to start Ruff alongside existing tools, enabling rule sets that mirror what you already enforce, such as the pycodestyle (E, W), Pyflakes (F) and isort (I) groups. Once results match, remove Flake8, isort and their plugins from the toolchain and from pre-commit, which usually shortens local hooks noticeably.

After that, widen coverage gradually: bugbear-style checks (B), pyupgrade (UP) and simplification rules (SIM) are common next steps. Use ruff check --fix for safe fixes and review unsafe fixes explicitly. Pin the Ruff version in pyproject.toml or pre-commit so that new rules in fast-moving releases do not change results unexpectedly.

Ruff’s formatter can also replace Black in many projects. Run ruff format --check in CI next to ruff check, and resolve any differences on a dedicated commit so that formatting changes do not hide real code changes in review.

Because Ruff is a single binary, it is also simple to run in editors and in containers without a Python environment.

Features

1. 900+ rules: Native re-implementations of Flake8 plugins and other tools.
2. Formatter: Black-compatible formatting via ruff format.
3. Auto-fix: Fixes for many rules, with safe and unsafe fix levels.
4. Import sorting: isort-compatible rules.
5. pyupgrade rules: Modernise syntax for target Python versions.
6. Caching: Fast incremental runs.
7. Monorepo support: Hierarchical configuration.
8. Language server: Editor diagnostics and fixes.
9. Notebook support: Lint and format Jupyter notebooks.
10. Single binary: No Python environment needed to run it.

Pros

1. Speed: Lints large codebases in seconds.
2. Tool consolidation: Replaces many separate linters and formatters.
3. Free to use: Open source under the MIT licence, so the core tool costs nothing to use.
4. Actively maintained: The repository had commits as recent as 11 November 2026.
5. Community: About 51,100 GitHub stars.

Cons

1. Not a type checker: Pair it with mypy or Pyright.
2. Plugin model: No arbitrary third-party plugins like Flake8.
3. Rule parity gaps: Some Pylint checks are not implemented.
4. Pre-1.0 versioning: Rule behaviour can change between minor versions.

Usage and Links (Example)

# pyproject.toml
[tool.ruff]
line-length = 100
target-version = "py312"

[tool.ruff.lint]
select = ["E", "F", "B", "I", "UP"]
ignore = ["E501"]

ruff check . --fix
ruff format .

Practical tips:

1. Start with E, F and I, then add rule families gradually.
2. Pin the Ruff version so rule changes arrive deliberately.
3. Run ruff format --check in CI to enforce formatting.

Resources:

• Ruff website
• GitHub repository

Pricing

Ruff is free and open source under the MIT licence.

Recommended for?

1. Python teams of any size wanting fast lint and format.
2. Monorepos where Flake8 or Pylint runs are slow.
3. Projects consolidating tooling into one config.
4. Keep a type checker alongside it.

Conclusion

Ruff has reset expectations for Python linting: hundreds of rules and a Black-compatible formatter in a tool fast enough to run on every keystroke.

Pair it with a type checker, pin its version, and it becomes a low-friction default gate for Python code.

On CheckOps, Ruff is filed under the Release & CI gates stage. Related tools listed here include Pylint, mypy, Pyright, Bandit, pre-commit and MegaLinter. Before standardising on one, compare recent maintenance activity, the pricing model as your usage grows, and the integrations you rely on today. Information on this page was verified against the official website, documentation and repository on 11 November 2026.