Ruff: Python linter and code formatter written in Rust

Original Article ↗ Hacker News Discussion ↗

Ruff, a Python linter and formatter written in Rust, is drawing praise for its speed, unified tooling, and ability to simplify what many see as a fragmented and cumbersome Python ecosystem. Supporters highlight that it can replace multiple tools (like Black, isort, and flake8) with a single fast binary and appreciate that it decouples dev tooling from Python runtimes, while critics question the need for Rust-based rewrites, worry about VC backing, and argue that performance gains are overhyped for smaller codebases. The conversation also branches into related tooling such as uv, type checkers like Pyright and MyPy, and broader tensions between traditional Python workflows and newer, more opinionated toolchains.

Astral toolchain & scope

  • Ruff is part of a broader Astral toolchain (ruff, uv, upcoming type checker “Red Knot”).
  • Some users say Astral tools are now everywhere; others note many active Python/Rust users hadn’t heard of the org itself.
  • Astral is VC-funded; business model is unclear in the thread.

Performance and Rust implementation

  • Many report huge speed gains vs pylint/flake8/black combos: minutes down to under a second, even on modest (~20k LOC) codebases.
  • Others argue previous Python linters are already “instant” on their codebases and that the speed hype is overstated.
  • Rust binary is praised for:
    • Not depending on the project’s Python environment.
    • Avoiding multi-Python/version headaches when tooling has different version constraints than the project.
    • Easier rollout to non-expert colleagues (“download binary and run it”).
  • Counterargument: Python-native tools can already be isolated via separate environments; “decoupling” is more about setup preferences than inherent coupling.

Formatting and style debates

  • Ruff’s formatter is largely Black-compatible; some appreciate that it ends style arguments and gives team-wide consistency.
  • Others dislike Black-style choices (e.g., collapsing multi-line argument lists; no spaces around = in keyword args).
  • Accessibility concerns are raised around indentation; Black is criticized as inflexible, while Ruff is praised for configurability.

Tooling integration and rewrites

  • Many like Ruff because it unifies linting and formatting with one tool and one config instead of several (black, isort, flake8, pylint, etc.).
  • Some are uneasy that Ruff reimplements decades of Python tooling instead of improving flake8/pylint, losing plugin ecosystems and extensibility.
  • Others argue rewrites were necessary: legacy tools were architecturally limited, Python packaging/tooling had deep inertia, and Rust/Go-style single binaries are a qualitative improvement.

Type checking and complementary tools

  • Pyright (and community fork basedpyright) are frequently recommended; some teams have dropped pylint and rely on Pyright for many lint-like checks.
  • Mypy is still used but is viewed as missing some bugs that Pyright catches.
  • Astral is confirmed to be working on a type checker; users expect Ruff + Rust-based type checker + uv to form a cohesive stack.

Workflow, CI, and DX

  • Debate over running linters in CI vs pre-commit:
    • CI favored for large monorepos and enforcement (harder to bypass).
    • Hooks favored where speed and instant feedback matter.
  • Newer Python users describe the Astral stack as a welcome, opinionated “one way to do it,” contrasting with the fragmented traditional ecosystem.

Django and multi-language formatting

  • Ruff only covers Python; for Django templates and mixed HTML/CSS/JS, people mention Prettier and DjLint, but performance and template-mixing remain pain points.