ESLint Rule Benchmark

ESLint Rule Benchmark times individual ESLint rules, capturing ops/sec, mean and median runtimes and rich latency percentiles to surface performance hotspots.

It helps you catch regressions and quantify optimization gains.

Key Features

• Prevent performance regressions – catch slow rules before they reach production
• Compare implementations – find the fastest approach with side-by-side benchmarks
• Expose detailed metrics – ops/sec, mean, median, percentiles and more
• Track performance trends – export JSON results for historical analysis
• Benchmark real code – measure against actual projects, not synthetic snippets
• Use TypeScript natively – run .ts rules out of the box
• Automate CI/CD checks – post performance impact straight to pull requests
• Generate multiple report formats – output to console, JSON or Markdown

Used by

• eslint-plugin-perfectionist
• eslint-plugin-de-morgan

Quick Start

1. Install package:

1npm install --save-dev eslint-rule-benchmark

2. Create a simple benchmark config benchmark/config.js or benchmark/config.ts:

1import { defineConfig } from 'eslint-rule-benchmark'
2
3export default defineConfig({
4  tests: [
5    {
6      name: 'My Rule Performance',
7      ruleId: 'my-plugin/my-rule',
8      rulePath: '../rules/my-rule.js',
9      cases: [
10        {
11          testPath: './my-rule/base-case.js',
12        },
13      ],
14    },
15  ],
16})

3. Run benchmarks:

1npx eslint-rule-benchmark run

Configuration File

By default, eslint-rule-benchmark run will look for the config.{js,cjs,mts,ts,cts,mts} configuration file in the ./benchmark/ directory.

The configuration file should export a configuration object, preferably using the defineConfig helper for type safety and autocompletion.

1import { defineConfig } from 'eslint-rule-benchmark'
2
3export default defineConfig({
4  /* Number of measurement iterations. Default: 1000. */
5  iterations: 1000,
6
7  /* Warmup configuration. */
8  warmup: {
9    /* Number of warmup iterations. Default: 100. */
10    iterations: 100,
11
12    /* Whether to enable warmup. Default: true. */
13    enabled: true,
14  },
15  /* Max time per benchmark. Default: 5000. */
16  timeout: 5000,
17
18  /* Array of benchmark test specifications. */
19  tests: [
20    {
21      /* Descriptive name for this test group/specification. */
22      name: 'Rule: sort-imports',
23
24      /* ESLint rule identifier. */
25      ruleId: 'sort-imports',
26
27      /* Path to the rule's implementation. */
28      rulePath: '../lib/rules/sort-imports.ts',
29
30      /* Override global benchmark settings for this specific test group. */
31      iterations: 50,
32      timeout: 300,
33      warmup: {
34        iterations: 10,
35      },
36
37      /* Array of test cases for this rule. */
38      cases: [
39        {
40          testPath: './sort-imports/base-case.ts',
41
42          /* ESLint rule options specific to this case. */
43          options: [{ order: 'asc', ignoreCase: true }],
44
45          /* ESLint rule severity for this case (0, 1, 2). Default: 2. */
46          severity: 2,
47        },
48        {
49          testPath: './sort-imports/complex-case.ts',
50        },
51      ],
52    },
53    {
54      name: 'Rule: sort-vars',
55      ruleId: 'sort-vars',
56      rulePath: '../lib/rules/sort-vars.ts',
57      cases: [
58        {
59          testPath: './sort-vars/base-case.ts',
60        },
61      ],
62    },
63    /* ... more test specifications */
64  ],
65})

Metrics and Output

ESLint Rule Benchmark provides the following performance metrics:

Metric	Description
Operations per second	Number of operations per second
Average time	Average execution time of the rule (e.g., in ms)
Median time (P50)	Median execution time (50th percentile)
Minimum time	Minimum execution time
Maximum time	Maximum execution time
Standard deviation	Standard deviation (measure of time variability)

Metrics are available in Console, JSON, and Markdown formats, allowing integration with various systems and workflows.

Example Output

------------------------------------------------------------------------------------------------------
                                          Rule: sort-imports
------------------------------------------------------------------------------------------------------
Sample               | Ops/sec       | Avg Time | Median   | Min      | Max      | StdDev    | Samples
base-alphabetical.ts | 7,569 ops/sec | 0.132 ms | 0.131 ms | 0.125 ms | 0.148 ms | ±0.004 ms | 7,421
base-natural.ts      | 7,485 ops/sec | 0.134 ms | 0.132 ms | 0.126 ms | 0.151 ms | ±0.005 ms | 7,010
base-line-length.ts  | 7,508 ops/sec | 0.133 ms | 0.131 ms | 0.125 ms | 0.150 ms | ±0.005 ms | 7,828
------------------------------------------------------------------------------------------------------

System Information:

Runtime: Node.js v22.15.1, V8 12.4.254.21-node.24, ESLint 9.25.1
Platform: darwin arm64 (24.5.0)
Hardware: Apple M1 Pro (10 cores, 2400 MHz), 32 GB RAM

GitHub Actions Integration

ESLint Rule Benchmark automatically publishes benchmark results as comments to GitHub Pull Requests when running in GitHub Actions environment.

Setup

ESLint Rule Benchmark automatically posts benchmark results as comments on pull requests.

Example Workflow

Create .github/workflows/benchmark.yml:

1name: ESLint Rule Benchmark
2
3on:
4  pull_request:
5    types: [opened, synchronize]
6
7jobs:
8  benchmark:
9    runs-on: ubuntu-latest
10    permissions:
11      pull-requests: write
12    steps:
13      - uses: actions/checkout@v4
14      - uses: actions/setup-node@v4
15        with:
16          node-version: '20'
17      - run: npm ci
18      - name: Run benchmark
19        env:
20          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
21        run: npx eslint-rule-benchmark run

FAQ

How accurate are the measurements?

The tool uses Tinybench with warmup phases and outlier filtering for high accuracy.

How it works?

The tool uses Tinybench for accurate and reliable benchmarking:

• Warmup phase to minimize JIT compilation impact
• Multiple iterations for statistical significance
• Isolation of the tested rule from other rules
• Outlier filtering (Tukey's fences method) for more stable and representative results, especially for maximum execution times.

Can I benchmark TypeScript rules?

Yes! Native TypeScript support is included.

Versioning Policy

This plugin is following Semantic Versioning.

Contributing

See Contributing Guide.

License

MIT © Azat S.