Ruff

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:
``bash
# Fix issues automatically
ruff check --fix .

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

Built-in Formatter:
`bash
# Format code (Black-compatible)
ruff format .
`

Quick Start

`bash
# 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

`toml
# 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:
`json
{
"ruff.enable": true,
"ruff.organizeImports": true,
"editor.formatOnSave": true,
"[python]": {
"editor.defaultFormatter": "charliermarsh.ruff"
}
}
`

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

GitHub Actions:
`yaml
- name: Lint with Ruff
run: |
pip install ruff
ruff check .
ruff format --check .
`

Migration

From Flake8 + isort + Black:
`bash
# 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.