Ruff vs Pylint: Which Python Linter Should You Use in 2026?

That does not make Pylint the universal winner. Ruff completed this small package roughly 48× faster, produced tighter output, and fixed safe violations. Pylint found more kinds of problems, but its default run also added convention and design messages that a team may not want. The choice is feedback speed and consolidation versus deeper analysis and extensibility.

The controlled package has eight Python files and 159 physical lines. Every intentional issue is tagged in the retained fixture. One clean module checks that the selected bug profiles do not invent a problem in valid narrowing code.

import json  # unused import

def undefined_name() -> object:
    return missing_value

def append_item(items: list[str] = []) -> list[str]:
    items.append("value")
    return items

def parse_number(value: str) -> int | None:
    try:
        return int(value)
    except Exception:
        return None

class Account:
    def __init__(self) -> None:
        self.balance = 10

owner = Account().owner  # semantic member error

We ran Ruff twice: its current defaults, then an explicit expanded profile (E,F,W,B,BLE,I,PL,RET,SIM,UP,S307). Pylint also ran twice: defaults, then only the 14 relevant symbols. These profiles make defaults and targeted coverage visible separately; they are not claimed to be perfectly matched rule sets.

ruff check --no-cache sample_project
ruff check --no-cache --select E,F,W,B,BLE,I,PL,RET,SIM,UP,S307 sample_project

pylint --persistent=no --jobs=1 --score=no sample_project
pylint --persistent=no --jobs=1 --score=no --disable=all --enable=<14 relevant symbols> sample_project

Ruff’s 8 default diagnostics represented 6 categories because three unused imports each produced F401. Its expanded run produced 12 diagnostics across 9 categories; the too-many-arguments case produced both PLR0913 and PLR0917. Pylint’s focused run produced 16 diagnostics across all 14 categories.

The official Ruff FAQ explains the boundary: Pylint performs more type inference, the tools have overlapping but different rules, and Ruff is not a pure Pylint replacement. Our missing-member and missing-argument results are concrete examples of that difference.

Pylint’s 23-message default output included six convention messages, three errors, five refactor messages, and nine warnings. Besides the target cases, it commented on trailing blank lines, a class with too few public methods, and both total and positional argument thresholds. That can be valuable—or noisy—depending on the team.

Ruff’s defaults were more practical than old descriptions of “only E and F rules” imply: Ruff 0.16.3 also caught the mutable default (B006), broad exception (BLE001), and unchecked subprocess call (PLW1510) without our expanded selector. Still, enabling a Ruff prefix such as PL does not recreate all Pylint analysis.

Each configuration started as a new process 11 times on Windows with an AMD Ryzen 5 3500. Caches were disabled, Pylint used one job, and output was discarded. The first timed process is separate; the repeated number is the median of the next ten.

The repeated default medians differ by about 48.3×; the expanded/focused medians differ by about 48.4×. That supports Ruff’s fast-feedback advantage on this machine, but not a universal ratio. This package is tiny, process startup dominates, and no editor daemon, cache, parallel Pylint run, or large repository was measured.

If you want to feel the feedback loop rather than read milliseconds, paste a mistake into the live Ruff Playground. Diagnostics update as you edit, and you can change the rule configuration without installing anything.

A separate fixture contained two unused imports. ruff check --fix reported 2 errors, 2 fixed, 0 remaining and removed both imports. Pylint 4.0.7 reported unused imports but exposed no general --fix command in its CLI help.

# before
import os
import sys

def greeting(name: str) -> str:
    return f"Hello {name}"

# after ruff check --fix
def greeting(name: str) -> str:
    return f"Hello {name}"

Lint fixes and formatting are separate. ruff check --fix repairs supported violations; ruff format rewrites layout. The Ruff Linter & Formatter Online exposes both jobs in a simpler one-click interface, while the Ruff Playground adds editable configuration, AST, tokens, and formatter IR.

Ruff documents fixes as safe or unsafe. The official linter guide recommends reviewing unsafe fixes because they can change runtime behavior or remove comments. Fast automation is useful precisely when the boundary stays visible.

• Missing member: Account().owner triggered Pylint E1101; neither Ruff profile reported it.
• Missing call argument: calling a two-parameter function with one argument triggered Pylint E1120; Ruff did not report it.
• Duplicate code: Pylint compared two files and flagged a 15-line repeated implementation with R0801.
• Import cycle: Pylint followed two package imports and reported R0401; Ruff did not.
• Missing encoding: Pylint flagged text open() without an explicit encoding; the tested Ruff profile did not.

These are exactly the cases a one-file syntax-oriented pass can miss. Pylint builds on astroid for inference and project analysis. It also supports third-party checkers, while Ruff currently implements rules natively and does not support third-party plugins, as documented in the official Ruff comparison.

Ruff can replace Pylint for some teams, but not by matching the package name alone. It works when the team mainly wants rapid linting, import cleanup, modernization rules, formatting, and a type checker already covers deeper call/type errors. It is not a complete replacement when the project depends on Pylint-only inference, cross-file checks, custom checkers, or framework plugins.

A safe migration is additive: run Ruff without removing Pylint, enable the Ruff groups you actually want, let Ruff fix safe issues, then list every remaining Pylint-only diagnostic. Keep Pylint for that list or replace each item deliberately. Do not delete the old gate because a generic benchmark was fast.

1. Ruff on every save and commit for quick linting, imports, modernization, and formatting.
2. mypy, Pyright, or ty in CI for annotation-based type errors Ruff is not designed to prove.
3. Pylint only where it adds value: semantic/cross-file checks, a required plugin, or project-specific policy.
4. Tests for runtime behavior no static tool can guarantee.

Try the same code in both site tools: use the Ruff Linter & Formatter when you want a fast lint-or-format result, and open the Ruff Playground when you want live diagnostics, raw settings, a shareable case, or parser views.

The retained evidence includes the keyword brief, all eight source files, the pre/post fix fixture, exact commands, diagnostic transcriptions, four sets of 11 timing samples, machine details, and limitations. The clean conclusion is narrower than “one tool wins”: Ruff optimized the feedback loop; Pylint inspected more relationships.

Repeat the comparison on your repository before changing CI. Include framework modules, generated code, plugins, type-heavy APIs, and the editor workflow developers actually use. Pylint’s running guide and Ruff’s configuration guide are the primary references for making the two runs reproducible.