hyperfine

Visit Website

Introduction

hyperfine is a command-line benchmarking tool by David Peter (sharkdp). The repository is licensed Apache-2.0 (the project is dual-licensed with MIT according to its README) and has about 29,000 GitHub stars.

It benchmarks arbitrary shell commands: you give it one or more commands, it runs each many times, and it reports mean, standard deviation, range and relative speed. Warm-up runs and cache-clearing commands make results more trustworthy.

That makes it a simple, reliable way to check whether a build step, compiler flag, CLI release or script change made something faster or slower.

In the quality loop, hyperfine is the quick evidence tool. Before you merge a change that claims to speed up a build, a CLI command or a test suite, a hyperfine comparison gives reviewers numbers with a spread instead of a single stopwatch reading. Its JSON output also makes it easy to store results from scheduled runs and plot them over time.

Features

1. Statistical analysis: Multiple runs with mean, standard deviation, min and max.
2. Any shell command: Benchmark CLIs, scripts and build steps.
3. Warm-up runs: --warmup runs commands before measuring.
4. Prepare and cleanup: --prepare runs a command (for example clearing caches) before each timing run.
5. Parameter scans: Benchmark across a parameter range, such as thread counts.
6. Comparisons: Relative speed between commands in one summary.
7. Exports: CSV, JSON, Markdown and AsciiDoc exports for reports and CI.
8. Progress feedback: Live progress and estimates while benchmarks run.

Pros

1. Extremely simple: One command to compare alternatives.
2. Statistically sound: Repeated runs and outlier warnings.
3. CI friendly: JSON export makes trend tracking easy.
4. Cross-platform: Linux, macOS and Windows.
5. Popular and maintained: Commits in November 2026.

Cons

1. Process-level only: It measures whole command runs, not functions inside them.
2. Startup overhead: Very short commands are dominated by process start time.
3. Noisy environments: Background load affects results.
4. No load generation: Not for concurrent traffic or HTTP load.
5. Manual thresholds: Gating CI on results requires your own script.

Usage and Links (Example)

Compare two commands with warm-up:

hyperfine --warmup 3 'fd -e jpg' 'find . -iname "*.jpg"'

Export results for CI:

hyperfine --export-json bench.json 'make build'

More patterns from the README:

# Clear caches before every timing run
hyperfine --prepare 'sync; echo 3 | sudo tee /proc/sys/vm/drop_caches' 'grep -R TODO .'

# Scan a parameter
hyperfine --parameter-scan threads 1 8 'make -j {threads}'

# Markdown table for a pull request
hyperfine --export-markdown results.md 'old-tool input' 'new-tool input'

Tips: run on a quiet machine, use enough runs for stable statistics, and watch for hyperfine’s warnings about outliers or very short command times. For CI gates, parse the JSON export and compare the mean against a stored baseline with a tolerance.

Resources:

• GitHub repository

Pricing

hyperfine is free and open source.

Recommended for?

1. CLI and tooling authors comparing releases.
2. Build engineers measuring build and test step times.
3. Anyone needing quick, statistically sound timings of commands.
4. Not a fit for HTTP load or in-process micro-benchmarks.

Conclusion

hyperfine is the simplest trustworthy way to benchmark shell commands, with warm-up, statistics and exports.

Pair it with micro-benchmark harnesses for code-level work and load tools for services.