Ruff

Overview

Ruff is an open-source, high-performance Python linter and formatter written in Rust. Its primary objective is to offer a significantly faster alternative to existing Python code quality tools, consolidating the functionalities of multiple tools like Flake8, isort, and Black into a single application. Developed by Astral Software Inc. and released in 2022, Ruff has rapidly gained adoption within the Python community due to its speed and comprehensive feature set.

The tool is designed for developers and teams seeking to improve code consistency, identify potential bugs, and enforce coding standards efficiently. Ruff achieves its speed advantage by leveraging the performance characteristics of Rust, enabling it to process large Python codebases in milliseconds. This makes it particularly well-suited for integration into continuous integration/continuous deployment (CI/CD) pipelines, where rapid feedback on code quality is crucial. By replacing several distinct tools, Ruff can simplify project dependencies and reduce the overhead associated with managing multiple code quality configurations.

Ruff provides over 700 linting rules, many of which are reimplementations of popular checks found in Flake8 plugins, Pylint, and other linters. This extensive rule set allows for detailed analysis of Python code for stylistic issues, potential errors, and best practice violations. Beyond linting, Ruff also includes a powerful code formatter that aims for Black compatibility, ensuring consistent code style across a project. Users can configure Ruff through a pyproject.toml file, allowing for granular control over enabled rules, ignored files, and formatting preferences, making it highly adaptable to diverse project requirements and team conventions.

Ruff is particularly effective for large Python projects or monorepos where performance bottlenecks with traditional linters can be substantial. Its ability to perform both linting and formatting in a single pass minimizes execution time, contributing to faster development cycles and more responsive CI/CD feedback loops. The developer experience is enhanced by its straightforward configuration and command-line interface, which simplifies adoption for new and existing Python projects alike. Developers can benefit from Ruff's performance in local development environments, receiving instant feedback as they write code, which can prevent issues from propagating further into the development process.

Key features

• High-Performance Linting: Written in Rust, Ruff offers significantly faster linting speeds compared to Python-based alternatives, processing large codebases quickly. The official Ruff documentation provides more details on its performance characteristics and how it achieves this speed.
• Comprehensive Rule Set: Includes over 700 built-in linting rules, encompassing checks from Flake8, Pylint, isort, and other tools, providing extensive code analysis capabilities. The Ruff settings documentation lists all available rules and their configurations.
• Integrated Code Formatter: Features a built-in formatter that aims for compatibility with the Black code style, ensuring consistent code formatting across projects without needing a separate tool.
• Single Toolchain: Consolidates multiple code quality tools (linter, formatter, import sorter) into one, simplifying project dependencies and configuration management.
• pyproject.toml Configuration: Supports configuration via pyproject.toml, allowing for centralized and standardized settings across a project, including rule selection, exclusions, and target Python versions.
• Fix-on-Save Capabilities: Many linting errors and formatting issues can be automatically fixed by Ruff, enhancing developer productivity and reducing manual correction time.
• Editor Integrations: Offers integrations with popular code editors like VS Code and Vim, providing real-time feedback and automatic fixes directly within the development environment.
• Extensibility: While designed as a comprehensive solution, Ruff's architecture allows for future extensions and custom rule development, catering to specific project needs.

Pricing

Ruff itself is free and open-source for individual use, distributed under an MIT license. Astral Software Inc., the company behind Ruff, offers paid plans for their broader platform, which includes Ruff along with other tools and services. These paid plans are geared towards teams and organizations requiring additional features, support, and integrations beyond the core open-source Ruff tool.

For detailed and up-to-date pricing information regarding Astral's platform plans that include Ruff, please refer to the official Astral pricing page.

Common integrations

• VS Code: The official Ruff extension for VS Code provides real-time linting, formatting, and quick fixes directly within the editor.
• Pre-commit Hooks: Ruff can be easily integrated into Git pre-commit hooks to automatically lint and format code before commits, ensuring code quality standards are met. Refer to the Ruff pre-commit integration guide for setup instructions.
• GitHub Actions: Integrate Ruff into GitHub Actions workflows to automate code quality checks and formatting during CI/CD processes. The Ruff GitHub Actions documentation provides example configurations.
• Other CI/CD Systems: Ruff's command-line interface allows for straightforward integration into various CI/CD platforms, including GitLab CI, CircleCI, and Jenkins, by executing Ruff commands as part of the build or test stages.
• Editor Integrations (e.g., Vim, Sublime Text): Ruff can be integrated with other text editors through their respective plugin ecosystems, often leveraging language server protocol (LSP) support or direct command execution.

Alternatives

• Black: An uncompromising Python code formatter known for its deterministic output and opinionated style.
• Flake8: A popular Python linter that combines PyFlakes, pycodestyle, and McCabe complexity checking into a single tool.
• Pylint: A highly configurable and comprehensive static code analysis tool for Python, capable of detecting a wide range of errors and style issues.
• Mypy: A static type checker for Python that helps catch type errors before runtime, complementing linters by focusing on type correctness.
• Prettier: While not Python-specific, Prettier is a widely adopted opinionated code formatter for many languages, offering a similar purpose in JavaScript and web development ecosystems.

Getting started

To begin using Ruff, you can install it via pip. After installation, you can run Ruff on your Python files to lint and format them. The following example demonstrates a basic setup and usage:

# Install Ruff
pip install ruff

# Create a sample Python file (example.py)
cat << EOF > example.py
import os, sys

def my_function ( arg1, arg2 ):
    result = arg1 + arg2
    if result > 10:
        print( "Result is large" )
    return result

my_function( 5, 7 )
EOF

# Lint the file to see potential issues
ruff check example.py

# Output will highlight issues like unused imports (F401), missing whitespace (E203), etc.

# Automatically fix issues found by the linter and format the code
ruff check --fix example.py
ruff format example.py

# View the corrected file
cat example.py
# Expected output after fix and format:
# import os
# import sys


# def my_function(arg1, arg2):
#     result = arg1 + arg2
#     if result > 10:
#         print("Result is large")
#     return result


# my_function(5, 7)


# For configuration, create a pyproject.toml file in your project root
cat << EOF > pyproject.toml
[tool.ruff]
target-version = "py310"
line-length = 88
select = ["E", "F", "W", "I"]
ignore = ["E501"]

[tool.ruff.format]
quote-style = "double"
indent-style = "space"
EOF

# Now, run Ruff again with the new configuration
ruff check example.py
ruff format example.py

# Ruff will apply the rules defined in pyproject.toml.

This example demonstrates how to install Ruff, run it for linting and automatic fixes, and apply formatting. It also shows how to configure Ruff using a pyproject.toml file to specify Python version targets, line length, selected rules, and formatting preferences. For more advanced configurations and integrations, consult the official Ruff documentation.