HTTP load generator, ApacheBench (ab) replacement
20.2k
Stars
1.3k
Forks
187
Open issues
30
Contributors
AI Analysis
hey is a lightweight HTTP load generator written in Go, designed as a modern replacement for Apache Bench (ab). It enables developers and performance engineers to stress-test web applications with configurable concurrency, request rates, and duration, supporting both HTTP/1.1 and HTTP/2 protocols. Best suited for developers, DevOps engineers, and QA teams who need quick, simple load testing without heavyweight tools.
Inferred from signals mentioned in the README (tests, CI, type safety) — not a review of the actual code.
AI's overall editorial judgment — not an average of the bars above, can weigh other factors too.
hey: a minimal HTTP load tester that remains a go-to quick-test tool a decade after launch
hey is a single-binary HTTP load generator designed as a practical replacement for ApacheBench (ab). It sends configurable volumes of concurrent requests to any HTTP/HTTPS endpoint and prints latency distributions, status code breakdowns, and throughput summaries. Built for developers and ops engineers who need fast, zero-configuration load tests from the command line, it supports HTTP/2, rate limiting, custom headers, and CSV output. Its appeal is simplicity: one binary, one URL argument, immediately useful results. Adoption appears broad among developers doing quick sanity checks and CI-level performance gates, though it is not designed for scripted multi-step scenarios.
Created in 2016 by Jaana Dogan (rakyll) at Google, originally named 'boom'. Renamed to 'hey' to avoid binary name conflicts with the original boom project. Has remained largely feature-stable since ~2019 as a deliberately minimal tool.
Early growth was driven by the reputation of its author (a prominent Go contributor) and the genuine gap between ab's age/limitations and the needs of modern HTTP APIs. Stars accumulated steadily through tutorials, blog posts, and word-of-mouth in DevOps and Go communities. Growth is now slow but consistent (~12 stars/week), reflecting a mature tool with stable demand rather than active expansion.
Widely referenced in developer tutorials, benchmarking blog posts, and cloud provider documentation (e.g., Google Cloud, AWS examples). Available via Homebrew and pre-built binaries hosted on Google Cloud Storage, indicating institutional backing. The 20k+ stars and 1,294 forks across nearly 10 years provide reasonable indirect evidence of broad usage, though no formal case studies or production deployment data are publicly documented.
Likely a straightforward Go CLI application: a worker pool dispatches HTTP requests concurrently, collects per-request timing data, then aggregates and prints summary statistics. Appears to use Go's standard net/http package with optional HTTP/2 support. Single binary with no external runtime dependencies, which is consistent with its sub-100KB footprint implied by the README.
not documented in README
Last push was January 10, 2026 — roughly 6 months before the evaluation date. For a mature, deliberately minimal tool with limited scope, this cadence is consistent with active maintenance rather than abandonment. The project is not feature-creeping; updates are likely bug fixes and dependency bumps. 1,294 forks suggest ongoing community engagement.
ADOPT IF: you need a fast, zero-configuration HTTP load test from a single binary and your scenario is a single endpoint with fixed parameters — especially for development-time smoke tests or CI performance gates. AVOID IF: your testing requires scripted multi-step user flows, dynamic data, authentication token refresh, or integration with observability platforms — use k6 or Locust instead. MONITOR IF: you rely on it for high-concurrency ceiling tests (>10k RPS), as newer tools like oha or bombardier may produce more accurate results at extreme load levels.
Independent dimensions
Mainstream potential
4/10
Technical importance
6/10
Adoption evidence
6/10
- Feature scope is intentionally frozen; users needing anything beyond single-endpoint load (sessions, dynamic payloads, chained requests) will outgrow it immediately.
- oha is gaining momentum as a direct replacement with a better UX, which may gradually erode hey's mindshare among new users discovering the space.
- No documented test suite in the README; regressions in edge cases (e.g., HTTP/2 behavior, redirect handling) may go undetected between infrequent releases.
- Pre-built binaries hosted on Google Cloud Storage create an implicit dependency on continued Google infrastructure goodwill, though the Apache-2.0 license allows self-building.
- Rate limiting is per-worker rather than global, which can lead to higher-than-intended aggregate QPS in multi-worker configurations — a subtle correctness issue for precise rate-controlled tests.
hey will remain a stable, widely-recommended quick-start tool for HTTP load testing for at least several more years, but is unlikely to gain significant new features or close the gap with scripting-capable tools. It occupies a permanent useful niche.
Newsletter
Get analyses like this every Monday
Free weekly digest of the most interesting open-source discoveries.
Languages
Information
- Language
- Go
- License
- Apache-2.0
- Last updated
- 6mo ago
- Created
- 120mo ago
- Analyzed with
- anthropic/claude-haiku-4-5
Stars over time
Contributors over time
Top 100 contributors only — repos with more will plateau at 100.
Open issues
Top contributors
Recent releases
Similar repos
codesenberg/bombardier
bombardier is a fast HTTP(S) benchmarking tool written in Go that uses fasthttp...
mcollina/autocannon
autocannon is a fast HTTP/1.1 benchmarking tool written in Node.js, inspired by...
| Repository | Stars | Week Δ | Language | Score | Updated |
|---|---|---|---|---|---|
|
rakyll/hey
this
|
20.2k | +21 | Go | 7/10 | 6mo ago |
 hatoo/oha
|
10.4k | — | Rust | 8/10 | 2d ago |
|
codesenberg/bombardier
|
6.8k | — | Go | 7/10 | 3mo ago |
 grafana/k6
|
31k | — | Go | 8/10 | 21h ago |
|
mcollina/autocannon
|
8.5k | — | JavaScript | 8/10 | 2mo ago |
 roadrunner-server/roadrunner
|
8.5k | — | Go | 8/10 | 1w ago |
k6 is a full scripting-based load testing platform with JavaScript test definitions, metrics integrations, and cloud execution. hey is strictly a one-shot CLI tool. hey wins on zero-friction simplicity; k6 wins on any scenario requiring multi-step flows, thresholds, or team-level reporting.
oha is the most direct modern alternative: also a single Go/Rust binary for quick HTTP load tests, but adds a live TUI dashboard. oha is actively competing for the same use case with a more modern UX. hey has the advantage of maturity, wider tutorial coverage, and Homebrew availability.
bombardier targets higher raw throughput using fasthttp and offers real-time stats. For raw performance benchmarking hey may undercount at extreme concurrency levels; bombardier is better suited for ceiling-finding. hey is simpler for everyday use.
autocannon is the Node.js ecosystem equivalent — familiar to JS developers and pipeable into Node toolchains. hey requires no runtime and is preferred outside JS ecosystems.
hey was explicitly built to replace ab. It adds HTTP/2 support, better latency histograms, JSON/CSV output, and a cleaner CLI. For any new usage, hey is a strict improvement over ab in usability.
