Ruff

What is Ruff?

Ruff is a revolutionary Python linter and code formatter developed by Astral (the company behind uv) that has fundamentally changed the Python tooling landscape since its launch in August 2022. Written in Rust, Ruff delivers unprecedented performance improvements over traditional Python tools, often running 10-100 times faster than alternatives like Flake8, Black, and isort while maintaining drop-in compatibility.

The tool was created by Charlie Marsh and has quickly gained massive adoption in the Python community, with over 46,000 GitHub stars and usage in major projects including Apache Airflow, FastAPI, Pandas, and SciPy. Ruff's core philosophy is to consolidate multiple Python development tools into a single, blazingly fast interface that can handle linting, formatting, import sorting, and code modernization tasks.

Getting Started

Installing Ruff is straightforward and can be done through multiple package managers. The tool is distributed as a standalone binary, making it easy to integrate into any development workflow.

For Python projects, the most common installation method is via pip:

pip install ruff

For system-wide installation on macOS:

brew install ruff

For Rust developers:

cargo install ruff

Once installed, you can immediately start using Ruff on your Python codebase. The basic commands are intuitive and mirror familiar tools:

# Lint your code
ruff check .

# Format your code
ruff format .

# Lint and auto-fix issues
ruff check --fix .

Usage & Practical Examples

Ruff excels in various development scenarios, from individual projects to large enterprise codebases. Here are practical examples of how teams are using Ruff:

Basic Linting and Formatting

For a typical Python project, you can replace your entire linting and formatting pipeline:

# Traditional approach (slow)
flake8 src/
black src/
isort src/
pyupgrade --py38-plus src/**/*.py

# Ruff approach (fast)
ruff check --fix src/
ruff format src/

Configuration Example

Ruff's configuration through pyproject.toml is comprehensive and allows fine-tuning for specific project needs:

[tool.ruff]
# Enable specific rule sets
select = ["E", "F", "UP", "B", "SIM", "I"]
# Ignore specific rules
ignore = ["E501"]  # Line too long
# Set line length
line-length = 88
# Target Python version
target-version = "py38"

[tool.ruff.isort]
# Configure import sorting
known-first-party = ["myproject"]

[tool.ruff.format]
# Use single quotes
quote-style = "single"

CI/CD Integration

Ruff's speed makes it ideal for continuous integration pipelines:

# GitHub Actions example
- name: Run Ruff
  run: |
    pip install ruff
    ruff check --output-format=github .
    ruff format --check .

Performance & Benchmarks

Ruff's performance advantages are not just marketing claims—they're measurable and dramatic. According to the project's benchmarks and user testimonials:

• CPython Codebase: Linting the entire CPython codebase from scratch takes seconds with Ruff versus minutes with traditional tools.
• Large Projects: On a 250k line codebase, pylint takes 2.5 minutes while Ruff completes the same analysis in 0.4 seconds—a nearly 1000x improvement.
• Bokeh Project: Ruff is 150-200x faster than Flake8, reducing scan time from 20 seconds to 0.2 seconds.

This performance improvement isn't just about faster CI/CD pipelines—it fundamentally changes the developer experience. Developers report being able to run comprehensive linting as part of their commit hooks without noticeable delays, leading to better code quality and faster feedback loops.

Who Should Use Ruff?

Ruff is ideal for a wide range of Python developers and teams:

Individual Developers: Python developers who want fast feedback on code quality without the overhead of multiple tools. The speed improvement makes it practical to run comprehensive checks frequently during development.

Development Teams: Teams looking to standardize their Python tooling and reduce CI/CD pipeline times. The single-tool approach simplifies onboarding and reduces configuration complexity.

Large Organizations: Companies with extensive Python codebases where traditional linting tools create bottlenecks in development workflows. The performance improvements can significantly impact developer productivity.

Open Source Projects: Maintainers who want to enforce code quality standards without imposing long wait times on contributors. Many major Python projects have already adopted Ruff for this reason.

Ruff is particularly valuable for teams currently using multiple Python tools (Flake8 + Black + isort + others) who want to consolidate their toolchain while gaining substantial performance improvements.

Verdict

Ruff represents a significant leap forward in Python tooling, delivering on its promise of extreme performance while maintaining compatibility with existing workflows. The 10-100x speed improvements aren't just impressive numbers—they fundamentally change how developers interact with code quality tools, making comprehensive linting and formatting practical for real-time development feedback. While it's a relatively new tool, its rapid adoption by major Python projects and active development by Astral suggest it's well-positioned to become the standard Python linting and formatting solution. For most Python developers and teams, Ruff offers compelling advantages with minimal downsides, making it an easy recommendation for modernizing Python development workflows.

Python Package Manager

pip install ruff

macOS

brew install ruff

Rust

cargo install ruff

Docker

docker run --rm -v $(pwd):/app -w /app ghcr.io/astral-sh/ruff:latest check .

Basic Linting

# Lint current directory
ruff check .

# Lint with auto-fix
ruff check --fix .

# Lint specific files
ruff check src/ tests/

Code Formatting

# Format code
ruff format .

# Check formatting without changes
ruff format --check .

Configuration

# pyproject.toml
[tool.ruff]
select = ["E", "F", "UP", "B", "SIM", "I"]
ignore = ["E501"]
line-length = 88
target-version = "py38"

[tool.ruff.format]
quote-style = "single"

CI/CD Integration

# GitHub Actions
ruff check --output-format=github .
ruff format --check .