Ruff is an extremely fast Python linter and formatter written in Rust — running 10-100× faster than existing tools while supporting 700+ lint rules from Flake8, pylint, isort, and more, making it the modern all-in-one solution for Python code quality.

What Is Ruff?

• Definition: Blazingly fast Python linter and code formatter.
• Speed: 10-100× faster than Flake8, pylint, isort combined.
• Language: Written in Rust for maximum performance.
• Rules: 700+ rules from popular linters in one tool.

Why Ruff Matters

• Speed: Lint 100K lines in 0.1 seconds vs 10+ seconds with traditional tools.
• All-in-One: Replaces Flake8, isort, pylint, pyupgrade, and more.
• Auto-fixing: Automatically fix hundreds of issue types.
• Drop-in Replacement: Compatible with existing configurations.
• Active Development: Rapidly improving with frequent releases.

Performance

Speed Comparison:

• Flake8: ~10 seconds for medium projects
• pylint: ~60 seconds for medium projects
• Ruff: ~0.1 seconds (100× faster!)

Real-World Benchmarks:

• Django (300K lines): 12s → 0.15s (80× faster)
• FastAPI (50K lines): 2s → 0.03s (67× faster)
• Pandas (500K lines): 20s → 0.25s (80× faster)

Key Features

Comprehensive Rules:

• E/W: pycodestyle errors and warnings
• F: Pyflakes (undefined names, unused imports)
• I: isort (import sorting)
• N: pep8-naming (naming conventions)
• UP: pyupgrade (modern Python syntax)
• B: flake8-bugbear (common bugs)
• C4: flake8-comprehensions (better comprehensions)
• SIM: flake8-simplify (simplification suggestions)

Auto-fixing:

# Fix issues automatically
ruff check --fix .

# Show what would be fixed
ruff check --fix --diff .

Built-in Formatter:

# Format code (Black-compatible)
ruff format .

Quick Start

# Install
pip install ruff

# Lint current directory
ruff check .

# Auto-fix issues
ruff check --fix .

# Format code
ruff format .

# Watch mode
ruff check --watch .

Configuration

# pyproject.toml
[tool.ruff]
line-length = 88
target-version = "py310"

# Enable rules
select = [
    "E",   # pycodestyle errors
    "W",   # pycodestyle warnings
    "F",   # Pyflakes
    "I",   # isort
    "N",   # pep8-naming
    "UP",  # pyupgrade
    "B",   # flake8-bugbear
]

# Ignore specific rules
ignore = ["E501"]  # Line too long

# Exclude directories
exclude = [".git", "__pycache__", "venv", "migrations"]

[tool.ruff.per-file-ignores]
"__init__.py" = ["F401"]  # Ignore unused imports

Integration

VS Code:

{
    "ruff.enable": true,
    "ruff.organizeImports": true,
    "editor.formatOnSave": true,
    "[python]": {
        "editor.defaultFormatter": "charliermarsh.ruff"
    }
}

Pre-commit:

repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.1.9
    hooks:
      - id: ruff
        args: [--fix]
      - id: ruff-format

GitHub Actions:

- name: Lint with Ruff
  run: |
    pip install ruff
    ruff check .
    ruff format --check .

Migration

From Flake8 + isort + Black:

# Old workflow (slow)
isort . && black . && flake8 .

# New workflow (fast)
ruff check --fix . && ruff format .

Comparison

vs Flake8: 100× faster, more rules, built-in auto-fix. vs pylint: 10-100× faster, simpler config, fewer false positives. vs Black: Ruff format is Black-compatible, comparable speed. vs isort: Built-in import sorting, much faster.

Best Practices

• Start Conservative: Enable core rules first (E, F), gradually add more.
• Use Auto-fix: ruff check --fix . fixes most issues automatically.
• Integrate Early: Add to pre-commit hooks and CI/CD from day one.
• Combine with Type Checker: ruff check . && mypy .
• Format Then Lint: ruff format . && ruff check --fix .

Adoption Strategy

Week 1: Install, run ruff check ., configure basic rules. Week 2: Run ruff check --fix ., review changes, add to pre-commit. Week 3: Add to CI/CD, enforce in pull requests. Week 4: Enable more rule categories, document in CONTRIBUTING.md.

Why So Fast?

• Rust: Compiled language vs interpreted Python.
• Parallel Processing: Multi-threaded execution.
• Efficient Caching: Smart cache invalidation.
• Optimized Algorithms: Fast AST parsing.

Ruff is revolutionizing Python linting — replacing multiple slow tools with one blazingly fast solution that saves time in development and CI/CD, making code quality checks instant rather than a bottleneck.