Ruff vs Flake8 and Black: I Replaced Both and Benchmarked It

Ruff isn't just "a faster Flake8." It re-implements the checks of an entire toolchain in one place, so a single ruff check (and ruff format) covers what used to need four separate tools:

That consolidation is the real story. One tool, one config block in pyproject.toml, one thing to install. And because it's Rust, it's fast enough to run on every keystroke in your editor and on every file in CI without anyone noticing the wait.

I pointed both linters at the same real codebase — 1,677 Python files from a populated virtualenv (FastAPI, huggingface-hub, numpy and their dependencies) — restricted both to the same F rule set for a fair fight, and disabled Ruff's cache so it did the full work every run:

=== ruff check, 1677 files (best of 3, no cache) ===
0.44s
0.28s
0.28s
=== flake8, same files, same rules ===
14.72s

Fifty-three times faster is not a rounding error — it's the difference between a linter you run constantly and one you avoid. Flake8 is a Python program that imports pycodestyle and pyflakes and walks each file in Python; Ruff parses and checks in parallel across cores in native code. On a big repo that's the gap between a sub-second pre-commit hook and a coffee break.

Speed is nice, but coverage matters more. I ran both on a small, deliberately messy file. Flake8 reported the unused imports and whitespace issues — but Ruff *also* flagged that the import block was unsorted (I001, isort's job) and offered to fix it, which Flake8 simply can't do on its own:

I001 [*] Import block is un-sorted or un-formatted
 --> messy.py:1:1
help: Organize imports

F401 [*] `os` imported but unused
 --> messy.py:1:8
help: Remove unused import: `os`

F841 [*] Local variable `unused_var` is assigned to but never used

The [*] marker means Ruff can fix it automatically. Run ruff check --fix and it applies them — in my test it fixed 3 of 4 findings (the unused imports and the import sort) in one pass, leaving only the ones that need human judgement:

$ ruff check --fix --select F,I messy.py
Found 4 errors (3 fixed, 1 remaining).
No fixes available (1 hidden fix can be enabled with `--unsafe-fixes`).

This is the "Ruff formatter" half people search for. ruff format is a near-drop-in replacement for Black — same opinionated style, same 88-column default, but far faster and built into the same tool. On my messy file it normalized quotes, fixed the mangled spacing, and added the missing whitespace around operators, exactly as Black would:

-        result[x['id']] = x
+        result[x["id"]] = x

-    def process( self ,data ):
-        return [d for d in data if d!=None]
+    def process(self, data):
+        return [d for d in data if d != None]

Single quotes became double quotes, process( self ,data ) became process(self, data), and d!=None became d != None — Black-compatible output from the same binary that does the linting. If you're already on Black, ruff format produces essentially identical results; if you're starting fresh, you get formatting and linting from one tool with one config.

Here's the nuance most "Ruff is better" posts skip. On my messy file, Flake8 reported 10 issues while Ruff's defaults reported 5 — which looks like Ruff missing things. It isn't a bug; it's a philosophy difference:

• Flake8 enables the full pycodestyle style checker by default, so it flags every E2xx whitespace nit out of the box.
• Ruff ships a smaller, curated default set (mostly F pyflakes rules and a few essentials) on the theory that you should *opt into* stylistic strictness rather than fight it.
• The fix is one line. Add a select in pyproject.toml — e.g. [tool.ruff.lint] select = ["E", "F", "I", "UP", "B"] — and Ruff checks as much as Flake8 plus its plugins, and then some (it implements 900+ rules).

For almost every project, yes. You collapse four tools into one, get a 30–50× speedup, and keep Black-compatible formatting. Migration is low-risk: Ruff reads a pyproject.toml config, understands most Flake8 rule codes, and ruff format matches Black closely enough that the reformat diff on an existing Black codebase is usually tiny. The realistic path is: add Ruff, set your select, run ruff format once, and delete Flake8, isort, pyupgrade and Black from your dev dependencies.

The only reasons to wait: a heavy investment in a niche Flake8 plugin Ruff hasn't reimplemented yet (rare now — it covers the popular ones), or a formatting style that deliberately diverges from Black. Otherwise, Ruff is the 2026 default. Try it on your own code first in the Ruff linter online — no install, runs in the browser — and if you like what you see, pip install ruff (or uv add ruff) and wire it into your editor and CI.