Ruff

Ruff is an extremely fast Python linter and code formatter from Astral — the same team behind uv — written in Rust and designed to replace Flake8, Black, isort, pydocstyle, pyupgrade, autoflake and a dozen related tools behind a single binary. We rate it 95/100 — it is the clearest, simplest, and fastest way to lint and format Python code in 2026, and at this point not adopting it is the unusual choice.

What is Ruff?

Ruff is an Apache 2.0 / MIT-licensed open-source linter and formatter authored by Charlie Marsh and first released on August 9, 2022. Just three and a half years later it has accumulated 47,330 GitHub stars and 2,036 forks, and is now the standard linting and formatting toolchain for projects including Apache Airflow, FastAPI, Pandas, SciPy, Hugging Face Transformers, and Apache Superset.

Where the legacy Python tooling stack required gluing together Flake8, Black, isort, pydocstyle and pyupgrade — each with its own configuration, plugin system, and CI hook — Ruff ships 800+ built-in rules, a Black-compatible formatter, and an LSP server in a single zero-dependency binary that installs in milliseconds via pip install ruff, uv tool install ruff, or brew install ruff. The current stable line is the 0.15.x series, with v0.15.0 shipping on February 3, 2026 and bringing the new 2026 style guide, block-level suppression comments, and an expanded preview rule set of 412 default rules.

Key Features of Ruff

• 10–100x faster than the legacy stack: Ecosystem benchmarks show Ruff is 20.98x faster than autoflake, 41.66x faster than Flake8, 53.64x faster than pyflakes, and 159.43x faster than pycodestyle. On the 250K-line Dagster codebase, Pylint takes ~2.5 minutes parallelized across four M1 cores; Ruff finishes the entire repo in 0.4 seconds.
• Drop-in replacement for Flake8, Black, isort, and more: Native re-implementations of Flake8 plus dozens of its plugins (flake8-bugbear, flake8-comprehensions, flake8-simplify, etc.), Black-compatible formatting, and isort-compatible import sorting — all in one tool.
• 800+ built-in rules: Including pycodestyle (E, W), Pyflakes (F), pyupgrade (UP), pep8-naming (N), pydocstyle (D), and security rules from Bandit (S), each individually toggleable via pyproject.toml.
• Automatic fix support: Most rules ship safe automatic fixes (e.g., remove unused imports, sort imports, modernize syntax for the configured Python version), with a separate unsafe-fixes tier you opt into explicitly.
• 2026 style guide and Python 3.14 support: The v0.15 formatter understands PEP 758 unparenthesized except clauses and keeps lambda parameters on a single line for readability.
• First-party editor integrations: Official extensions for VS Code, Zed, JetBrains IDEs, Neovim, Helix, and Sublime Text, all powered by the same ruff server LSP shipped inside the main binary.
• Monorepo-friendly configuration: Hierarchical and cascading pyproject.toml / ruff.toml discovery means a 200-package monorepo can share defaults at the root and override per-package — a common pain point with Flake8.
• Built-in caching: Ruff hashes input files and skips unchanged ones, so repeat runs on a clean tree finish in milliseconds.

What Users Say About Ruff

Sentiment across Reddit's r/Python and r/learnpython, Hacker News, and the Python Discord is overwhelmingly positive — to the point that several maintainers have publicly joked that Ruff is so fast they had to add intentional bugs to verify it was actually running. Sebastián Ramírez, creator of FastAPI, said exactly that: Ruff is so fast that sometimes I add an intentional bug in the code just to confirm it's actually running and checking the code. Tim Abbott, lead developer of Zulip, summarized it bluntly: This is just ridiculously fast.

Recurring complaints, where they exist, are honest and worth knowing. Ruff covers a meaningful subset of Pylint's rules but not all of them — projects that depend on Pylint's deepest type-aware checks (especially those without separate static-typing tooling) still need it alongside Ruff. Some teams also note that the rapid release cadence (the 0.15 series alone has shipped seven point releases) occasionally introduces new lint warnings on stable code, which can be friction in CI without pinned versions. Astral's response has been to ship preview mode as the staging ground for new rules and to keep the stable rule set deliberately conservative.

Ruff Pricing

Ruff is completely free and open source under a dual MIT / Apache 2.0 license. There is no paywall, no tiered SaaS plan, no usage cap, and no telemetry — you install the binary and run it. Astral monetizes the broader stack (uv, ty, the planned managed services) rather than Ruff itself.

Plan	Price	Includes
Open Source	$0	Linter, formatter, LSP server, all 800+ rules — unlimited use

Who Should Use Ruff?

Best for: Every Python team that currently runs Flake8, Black, isort, pyupgrade or any combination of those tools. Solo developers, library maintainers, monorepo owners, and CI-conscious enterprises all benefit immediately — the migration is a one-line install plus a small pyproject.toml section.

Not ideal for: Codebases that depend specifically on Pylint's deepest dataflow rules, projects whose CI culture cannot tolerate any rule-set churn between minor releases, or strict-licensing environments that have policies against pulling in new Apache 2.0 dependencies (rare).

Pros and Cons

Pros:

• Genuine 10–100x performance improvement over the legacy stack — sub-second feedback on multi-million-line codebases.
• One binary replaces five to ten tools, collapsing CI configuration significantly.
• Black-compatible formatter means existing Black users can switch with zero diff churn.
• Active development backed by venture-funded Astral — averaging a release every two to three weeks.
• Excellent editor integration via the bundled LSP server.
• Permissive dual MIT / Apache 2.0 license; no telemetry; no upsell.

Cons:

• Does not yet cover 100% of Pylint's deeper checks — some teams still run Pylint alongside Ruff.
• Frequent releases mean new rules occasionally land in stable; pinning the version in CI is recommended.
• Stuck in 0.x versioning, which can scare conservative engineering orgs away from production adoption — though it is in fact production-grade and used by major projects.

Alternatives to Ruff

Direct competitors are essentially the legacy stack: Flake8 (slower, plugin-based, much more permissive about config sprawl), Black (formatter only, but Ruff's formatter is Black-compatible), Pylint (deeper static analysis, multiple times slower), and Meta's Pyrefly (newer, type-checker-focused, narrower scope). For teams that want a similarly fast all-in-one approach but in JavaScript-land, see our Biome review.

Verdict: Is Ruff Worth It?

Ruff is the clearest "yes" we have written this year. It is genuinely 10–100x faster than the legacy Python tooling stack, replaces five to ten separate tools with one binary, costs nothing, has zero telemetry, and is already the default in essentially every major open-source Python project. If you are still running Flake8 + Black + isort + pyupgrade in CI, switching to Ruff will save you minutes per build, dozens of lines of configuration, and one or two CI containers — at the cost of a single afternoon's migration work. The 95/100 rating reflects exactly that: it is the rare tool that is both objectively the fastest option and the simplest one.

Frequently Asked Questions

Is Ruff free?

Yes. Ruff is completely free and open source under a dual MIT / Apache 2.0 license. There is no paid tier, no usage limit, and no telemetry.

What platforms does Ruff support?

Ruff ships pre-built binaries for macOS (Intel and Apple Silicon), Linux (x86_64 and aarch64), and Windows (x86_64), plus a PyPI wheel installable on any platform Python supports. It runs on Python 3.7 through 3.14.

How does Ruff compare to Flake8 and Black?

Ruff replaces both. It implements Flake8's rule set plus dozens of Flake8 plugins natively, includes a Black-compatible formatter, and runs roughly 41x faster than Flake8 and at comparable speed to (or faster than) Black on the same code. Most teams switch to Ruff and remove Flake8 + Black + isort from their dependencies entirely.

Is Ruff open source?

Yes — dual licensed under MIT and Apache 2.0. The source is on GitHub at astral-sh/ruff.

Does Ruff replace Pylint?

For most projects, yes. Ruff implements 800+ rules covering the vast majority of Pylint's checks. A small number of Pylint's deepest dataflow rules are not yet ported, so codebases that rely heavily on those specific checks may want to run both — but most teams find Ruff alone is enough.

What editors support Ruff?

VS Code, JetBrains IDEs (PyCharm, IntelliJ), Zed, Neovim, Helix, and Sublime Text all have official first-party Ruff extensions powered by the bundled ruff server LSP.