Jarl is a fast linter for R: it does static code analysis to search for programming errors, bugs, and suspicious patterns of code.

• Orders of magnitude faster than lintr and flir¹
• Automatic fixes when possible
• Support for 55+ rules (and growing)
• Integration in popular IDEs and editors (VS Code, Positron, Zed, ...)
• Command-line interface (CLI)
• Multiple output modes (concise, detailed, JSON format)
• CI workflow

Jarl is built on Air, a fast formatter for R written in Rust.

Quick start

See:

• "Getting started" for an intro to Jarl;
• "By Example" for short examples of what Jarl can do;
• "Editors", "Continuous integration", and "Pre-commit tools" to integrate Jarl into your development tools.

This shows what it looks like in the terminal:

test.R:

any(is.na(x))

if (all.equal(x, y)) {
  print("x and y are equal")
}

# In the terminal:
$ jarl check test.R
warning: any_is_na
 --> test.R:1:1
  |
1 | any(is.na(x))
  | ------------- `any(is.na(...))` is inefficient.
  |
  = help: Use `anyNA(...)` instead.

warning: all_equal
 --> test.R:3:5
  |
3 | if (all.equal(x, y)) {
  |     --------------- `all.equal()` can return a string instead of FALSE.
  |
  = help: Wrap `all.equal()` in `isTRUE()`, or replace it by `identical()` if
    no tolerance is required.

Found 2 errors.
1 fixable with the `--fix` option (1 hidden fix can be enabled with the
`--unsafe-fixes` option).

Use --fix to automatically fix rule violations when possible:

$ jarl check test.R --fix

test.R:

anyNA(x)

if (all.equal(x, y)) {
  print("x and y are equal")
}

Installation

This details how to install Jarl via the command line.

Note that the VS Code and Positron extensions contain a bundled version of Jarl, so you don't need to install it via the command line if you plan to use it via those extensions only. See the Editor support page for more information.

Released version

Either get binaries from the Releases page or install Jarl from the existing installer scripts below.

macOS and Linux

curl --proto '=https' --tlsv1.2 -LsSf \
  https://github.com/etiennebacher/jarl/releases/latest/download/jarl-installer.sh | sh

Windows

powershell Set-ExecutionPolicy Bypass -Scope Process -Force; `
   iwr https://github.com/etiennebacher/jarl/releases/latest/download/jarl-installer.ps1 | iex

Other

brew install jarl

scoop bucket add r-bucket https://github.com/cderv/r-bucket.git

# install
scoop install jarl

# update
scoop update jarl

# One-time run, not a global install:
uvx --from jarl-linter jarl check .

# Global install:
uv tool install jarl-linter
# or
pipx install jarl-linter

# Add to a project
pixi add jarl
pixi run jarl check .

# Install globally
pixi global install jarl

# Run one-off command
pixi exec jarl check .

# With yay
yay -S jarl-bin

# With paru
paru -S jarl-bin

# Add to a project
mise use conda:jarl
jarl check .

# Install globally
mise use --global conda:jarl

# Run one-off command
mise exec conda:jarl -- jarl check .

# Temporary shell
nix-shell -p jarl
jarl check .

# Run one-off command (with flakes enabled)
nix run nixpkgs#jarl -- check .

# One-off command with comma (https://github.com/nix-community/comma)
, jarl check .

# Add to NixOS configuration (permanent install)
environment.systemPackages = [
  pkgs.jarl
];

# Add to home-manager
home.packages = [
  pkgs.jarl
];

Development version

Some pre-releases may be available from the Releases page (the version usually contains alpha, see the installation instructions there).

Alternatively, if you have Rust installed, you should be able to get the development version with:

cargo install --git https://github.com/etiennebacher/jarl jarl --profile=release

Related work

lintr is the most famous R linter. It provides dozens of rules related to performance, readibility, formatting, and more. Jarl is heavily influenced by lintr since most rule definitions come from it. However, lintr doesn't provide automatic fixes for rule violations, which makes it harder to use. Its performance also noticeably degrades as the number of files and their length increase.

flir is a relatively novel package. It uses ast-grep in the background to search and replace code patterns. It is therefore quite flexible and easy to extend by users who may want more custom rules. While both Jarl and ast-grep use tree-sitter in the background to parse R files, their structure is completely different. Jarl is faster and also easier to link to the Language Server Protocol, which enables its use via VS Code or Positron extensions for instance.

Acknowledgements

• lintr authors and contributors: while the infrastructure is completely different, all the rule definitions and a large part of the tests are inspired or taken from lintr.
• Davis Vaughan and Lionel Henry, both for their work on Air and for their advices and answers to my questions during the development of Jarl.
• the design of Jarl is heavily inspired by Ruff and Cargo clippy.
• R Consortium for funding part of the development of Jarl.