CLI tool
six-ddc/plow avatar
six-ddc/plow

plow: the benchmarking tool that serves its own charts while the load runs

A high-performance HTTP benchmarking tool that includes a real-time web UI and terminal display

4,517 stars153 forksGoApache-2.0

At a glance

What is it?
plow is a Go HTTP benchmarking tool built on fasthttp that keeps a summary, a latency histogram and a percentile table updating while connections are still open, and serves the same view as a web UI on port 18888. The trade-offs are a scratch based container image and a flag list the README cuts off mid-line.
Who is it for?
plow suits a team that wants to watch latency percentiles move while a load test runs, and that is willing to drive a single Go binary with three flags. It does not suit anyone who needs HTTPS from the container image without supplying a trust store, or who wants a documented option reference, because the flag list stops mid-line.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 8 days ago.
What is it written in?
Mainly Go, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • six-ddc/plow4,517 ★ · +3
Star history
Repository2026-09-232026-11-15
six-ddc/plow4.5k4.5k

3 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The same binary serves the charts on port 18888

There is no separate dashboard process to start. The sample run in the README prints the charts address on the line right under the benchmark banner, then keeps printing summaries to the terminal while the load continues.

text
Benchmarking http://127.0.0.1:8080/hello using 20 connection(s).
@ Real-time charts is listening on http://[::]:18888

Summary:
  Elapsed        8.6s
  Count        969657
    2xx        776392
    4xx        193265
  RPS      112741.713
  Reads    10.192MB/s
  Writes    6.774MB/s

Statistics    Min       Mean     StdDev      Max
  Latency     32µs      176µs     37µs     1.839ms
  RPS       108558.4  112818.12  2456.63  115949.98

Latency Percentile:
  P50     P75    P90    P95    P99   P99.9  P99.99
  173µs  198µs  222µs  238µs  274µs  352µs

The two front-end assets sit at the repository root as `echarts.min.js` and `jquery.min.js`, next to `charts.go`, and go.mod pins `github.com/go-echarts/go-echarts/v2 v2.4.5`, so the page comes from the same binary rather than a separate service. Read the address carefully: `[::]` is every interface on the host, not loopback, and the option list stops before any flag that would narrow it.

Three flags decide how a run ends: -c, -d and -n

The usage line is `plow [<flags>] <url>`, and the defaults are conservative: one connection and, effectively, no request rate limit.

bash
usage: plow [<flags>] <url>

A high-performance HTTP benchmarking tool with real-time web UI and terminal displaying

Examples:

  plow http://127.0.0.1:8080/ -c 20 -n 100000
  plow https://httpbin.org/post -c 20 -d 5m --body @file.json -T 'application/json' -m POST

Flags:
      --help                     Show context-sensitive help.
  -c, --concurrency=1            Number of connections to run concurrently
      --rate=infinity            Number of requests per time unit, examples: --rate 50 --rate 10/ms
      --ramp-up=-1               Concurrently will increase pre seconds

A run goes on for a duration with `-d`, for a fixed number of requests with `-n`, or until you interrupt it with Ctrl-C. `--rate` takes a plain count or a rate with a unit, and `--ramp-up` is described as concurrency increasing over the first seconds. What this list cannot tell you is where the rest of the flags are: it is cut off at the `-n, --` line, so options such as `-m`, `-T` and `--body` are visible only through the examples.

bash
plow http://127.0.0.1:8080/ -c 20 -n 10000 -d 10s

Shell completion is generated by the binary itself, one flag per shell.

bash
eval "$(plow --completion-script-bash)"

fasthttp underneath, and a CLI parser pinned to an unstable module

The choice of HTTP stack is the whole point of the dependency list. `github.com/valyala/fasthttp v1.70.0` replaces Go's default `net/http`, and the README says the reason is performance. Around it sit small, purposeful modules: `go-isatty` and `go-runewidth` for the terminal tables, `go-echarts` for the page, `automaxprocs` so a container respects its CPU quota, `golang.org/x/time` for the rate limiter, and `fasthttpcors` for cross-origin requests.

code
module github.com/six-ddc/plow

go 1.24.0

toolchain go1.24.4

require (
	github.com/AdhityaRamadhanus/fasthttpcors v0.0.0-20170121111917-d4c07198763a
	github.com/beorn7/perks v1.0.1
	github.com/go-echarts/go-echarts/v2 v2.4.5
	github.com/mattn/go-isatty v0.0.20
	github.com/mattn/go-runewidth v0.0.16
	github.com/valyala/fasthttp v1.70.0
	go.uber.org/automaxprocs v1.6.0
	golang.org/x/time v0.8.0
	gopkg.in/alecthomas/kingpin.v3-unstable v3.0.0-20191105091915-95d230a53780
)

The one to look at twice is `kingpin.v3-unstable`, pinned to a 2019 revision. That module is where the help format and the two `--completion-script-` flags come from, so the CLI surface of the tool depends on an unstable package that has not moved in seven years.

Percentiles are produced from a stream, not from a stored sample set

The README is explicit about how the numbers appear while a run is in progress: real-time histograms and quantiles are computed with stream-based algorithms inspired by the Prometheus client library, with low memory and CPU bounds, which it presents as almost no additional benchmarking overhead. That design choice is why the percentile table is complete before the run ends.

The consequence is that the values are produced without keeping every observation, so a P99.9 column from a short run rests on far fewer samples than the same column from a long one. Comparing two runs of different lengths compares two estimators over different sample counts, and the reported `Min`, `Mean`, `StdDev` and `Max` come out of the same pass.

The summary block also splits the response classes: the sample run shows a total count with `2xx` and `4xx` broken out, plus read and write throughput per second next to RPS. A run that returns mostly `4xx` is still counted as throughput, so the status breakdown is the first thing to read before believing an RPS number.

FROM scratch leaves the image without a shell and without trust anchors

The container image is three lines long.

dockerfile
FROM scratch
COPY plow /usr/bin/plow
ENTRYPOINT ["/usr/bin/plow"]

There is no shell, no package manager and no certificate bundle copied in, which keeps the image to the binary and nothing else. Two practical effects follow. A run against an HTTPS target, such as the httpbin.org endpoint used in the README's own POST example, depends on the binary finding a trust store inside that empty filesystem, and nothing here supplies one. And when a run misbehaves there is nothing to exec into.

bash
docker run --rm --net=host ghcr.io/six-ddc/plow
# docker run --rm -p 18888:18888 ghcr.io/six-ddc/plow

Those two lines also decide who can see the charts. Host networking puts the chart page on the host's own interfaces as soon as the binary starts, while the commented alternative publishes exactly one port and leaves the rest of the network to the bridge. Pick the second form when the machine is shared.

Four install channels, none of them pinned to the same moment

Binary and image distributions are published on the releases assets page, and the README adds three package-manager routes.

bash
go install github.com/six-ddc/plow@latest
sh
# brew update
brew install plow
bash
docker run --rm --net=host ghcr.io/six-ddc/plow

Each costs something different. `go install ...@latest` needs a Go toolchain on the machine and resolves to the newest module version, so it moves as soon as a tag lands. The Homebrew formula moves when the formula is updated, and the README says nothing about how that happens. A `.goreleaser.yaml` sits at the repository root next to the scratch Dockerfile. Nothing states which channel is freshest, so two engineers benchmarking the same service can be two versions apart, and the only reliable check is the build you actually have on your PATH.

Tags two years apart, and a licence link pointing at another branch

The release list is short and uneven: v1.3.1 on 2022-07-28, v1.3.2 on 2024-12-24, then v1.4.0 on 2026-04-28, with the last push to the default branch on 2026-10-17. So the project moves in occasional bursts, with about two and a half years between the first two of those tags, and there is no release cadence to plan against.

Two smaller signals point the same way. The README's licence link points at `blob/master/LICENSE` while the default branch is `main`, so the link does not match the current branch layout, and the Apache-2.0 file itself is at the root. And the repository has no changelog: the top level holds `main.go`, `print.go`, `report.go`, `requester.go` with their test files, `charts.go`, the two vendored browser assets, `bench_server/` and a `demo.gif`, which is the shape of a small tool with tests rather than a project with release notes. For a benchmarking tool the missing piece is the one you would look for first, a record of what changed between v1.3.2 and v1.4.0.

Editorial conclusion

plow suits a team that wants to watch latency percentiles move while a load test runs, and that is willing to drive a single Go binary with three flags. It does not suit anyone who needs HTTPS from the container image without supplying a trust store, or who wants a documented option reference, because the flag list stops mid-line. Before the first run, check which build your channel gave you, confirm that port 18888 is not already serving on that host, and decide whether host networking is acceptable for the machine you run it on.

Frequently asked questions

How do I install plow?

Three routes are given: `go install github.com/six-ddc/plow@latest`, `brew install plow`, and `docker run --rm --net=host ghcr.io/six-ddc/plow`. Binary and image distributions are also published on the releases assets page.

Which port does the plow web UI use and how do I reach it?

A run prints `@ Real-time charts is listening on http://[::]:18888`, which is every interface on the host rather than loopback. With `docker run --rm --net=host ghcr.io/six-ddc/plow` the page is already reachable on the host, and the commented alternative publishes the single port with `-p 18888:18888`.

How do I stop a plow benchmark after a fixed time or request count?

Use `-d` for a set duration, `-n` for a fixed number of requests, or interrupt with Ctrl-C. Concurrency comes from `-c, --concurrency`, which defaults to 1, and `--rate=infinity` is the default rate limit, with `--rate 50` and `--rate 10/ms` given as examples.

Does plow provide shell completion?

Yes, the binary emits it. Run `eval "$(plow --completion-script-bash)"` for bash, or `eval "$(plow --completion-script-zsh)"` for ZSH, adding the statement to your shell profile.

Official sources

  1. License: Apache-2.0
  2. Project website
  3. README
  4. Releases
  5. six-ddc/plow on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/six-ddc-plow.svg)](https://hysenlabs.com/projects/six-ddc-plow)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/six-ddc-plow.svg)](https://hysenlabs.com/projects/six-ddc-plow)

Was this useful?