Ruff is an open-source Python linter created by Astral Sh that stands out for its impressive speed, adaptability, and wide-ranging features.

This powerful tool has gained popularity among Python developers for its ability to streamline the code linting process.

By focusing on extensibility, fast performance, comprehensive linting rules, and easy configuration, Ruff aims to provide an efficient and user-friendly linting experience that can be tailored to various projects and coding styles.

Key Features

Ruff is extremely actively developed and used in major open-source projects due to its impressive features.

Here are some of the key features:

  • Extensible: Ruff is designed to be easily extended, so developers can add their own custom plugins, making it adaptable to various projects and coding styles.
  • Faster: Ruff is built to be much faster than other Python linters, using Rust's performance and Python's user-friendliness to ensure quick and efficient code analysis, especially for large codebases.
  • Comprehensive: Ruff supports many linting rules from popular tools like flake8, Pycodestyle, Pyflakes, and McCabe. It also offers auto-fixing for a wide range of issues, helping developers keep their code clean and consistent.
  • Easy Configuration: Ruff's configuration is simple and intuitive, allowing developers to customize its behavior to fit their preferences and project needs.


Ruff can be employed to replace Flake8 (along with numerous plugins). It does this while running much faster, sometimes even hundreds of times faster than any single tool.

Here are the key benefits:

  • Better Code Quality: Ruff assists developers in maintaining consistent coding styles and spotting potential problems early on, resulting in higher-quality code with fewer errors.
  • Greater Productivity: Ruff's fast performance and automatic issue-fixing features enable developers to concentrate on writing code, rather than wasting time manually fixing linting issues.
  • Easy Integration: Ruff can be effortlessly combined with popular development tools and continuous integration systems, making it hassle-free to include linting in existing workflows.

Excited to dive deeper into the world of Python programming? Look no further than my latest ebook, "Python Tricks - A Collection of Tips and Techniques".

Get the eBook

Inside, you'll discover a plethora of Python secrets that will guide you through a journey of learning how to write cleaner, faster, and more Pythonic code. Whether it's mastering data structures, understanding the nuances of object-oriented programming, or uncovering Python's hidden features, this ebook has something for everyone.

Getting Started with Ruff

To start using Ruff, first install it using pip:

pip install ruff

Next, run Ruff on your Python project:

ruff check .

Ruff will automatically analyze your code and report any linting issues it finds.

Here is an example of the output: F401 [*] `youtube_client.upload_video` imported but unused F841 Local variable `audio_folder` is assigned to but never used F841 Local variable `credentials` is assigned to but never used F401 [*] `os` imported but unused F401 [*] `textwrap.fill` imported but unused
Found 5 errors.
[*] 3 fixable with the `--fix` option (2 hidden fixes can be enabled with the `--unsafe-fixes` option).

Errors can automatically be fixed by running:

ruff check . --fix

Which produces this output: F841 Local variable `audio_folder` is assigned to but never used F841 Local variable `credentials` is assigned to but never used
Found 5 errors (3 fixed, 2 remaining).
No fixes available (2 hidden fixes can be enabled with the `--unsafe-fixes` option).

As you can see, the remaining errors can possibly be fixed with the unsafe-fixes option.

To configure Ruff, create a pyproject.toml file in your project's root directory and customize the settings according to your needs.

For example, to set the maximum line length to 100 characters and disable the undefined-name check, use the following configuration:

line-length = 100
ignore = ["F821"]


Ruff is an impressive and adaptable tool for checking Python code, offering quick performance, a wide range of linting rules, and straightforward configuration options.

By using Ruff in their development workflows, Python developers can experience better code quality through consistent coding styles, early issue detection, and reduced bugs.

They can also improve productivity by focusing on writing code instead of manually addressing linting issues, and benefit from seamless integration with popular development tools and continuous integration systems.

Thank you for reading and I will see you on the Internet.

This post is public so feel free to share it.

If you like my free articles and would want to support my work, consider buying me a coffee:

Are you working on a project that’s encountering obstacles, or are you envisioning the next groundbreaking web application?

If Python, Django, and AI are the tools you're exploring but you need more in-depth knowledge, you're in the right place!

Get in touch for a 1-hour consultation where I can address your specific challenges.

Developer Service Blog - 1 Hour Consulting - Nuno Bispo
Are you working on a project that’s hitting roadblocks or simply dreaming up the next big web application?

Tagged in: