Home

Yet-Another-Bench-Script (YABS) Wiki

YABS is a single bash script that benchmarks a Linux server in one command. It measures three things that matter most when you rent a server — disk speed (with fio), network speed (with iperf3) and CPU performance (with Geekbench) — plus a summary of the hardware and network it found itself on. It needs nothing installed and no root privileges.

curl -sL yabs.sh | bash

Runs take 5–15 minutes and are run roughly 90,000 times a month. YABS has been developed in the open since October 2019 by Mason Rowe with the LowEndTalk, LowEndSpirit and HostBalls hosting communities.

This wiki explains what YABS does, why it does it that way, and how to make sense of the numbers it gives you. It is written for two readers at once: someone who just ran it on a new VPS and wants to know whether the result is good, and someone who wants to understand (or change) every line of the script. Most pages open with a short plain-English summary and then go deep.

Choose your path

If you...	Start here
Just want to run it and read the result	Getting Started → Understanding the Output → Interpreting Results
Got a number and want to know if it is good or bad	Interpreting Results, then Benchmarks Are Snapshots
Want to skip tests, save bandwidth, pick a Geekbench version, or get JSON	Command-Line Flags, JSON Output and Integrations
Hit an error or a confusing message	Troubleshooting and FAQ
Want to know exactly what each test runs	Tests: Disk (fio) · Tests: Network (iperf3) · Tests: CPU (Geekbench)
Are curious where the downloaded binaries come from and whether to trust them	Precompiled Binaries, GitHub Actions Automation
Want the back-story	History, Design Principles
Want to contribute	Contributing, Architecture and Script Flow

How a run fits together

flowchart LR
    A[curl -sL yabs.sh] --> B[Detect arch, tools,<br/>IPv4/IPv6]
    B --> C[Basic System<br/>Information]
    C --> D[Network Information<br/>ip-api]
    D --> E[Disk: fio<br/>4k 64k 512k 1m<br/>mixed 50/50]
    E --> F[Network: iperf3<br/>7 servers, 8 streams,<br/>send + recv, IPv4 + IPv6]
    F --> G[CPU: Geekbench<br/>single + multi core]
    G --> H[Clean up<br/>print runtime<br/>optional JSON]

Loading

Each stage can be skipped with a flag (-f disk, -i network, -g Geekbench, -n network info), and each degrades gracefully if something is unavailable.

Full index

Using YABS

• Getting Started — prerequisites, how to run, what happens during a run, bandwidth notice, Windows/WSL
• Command-Line Flags — every flag with examples, the -h dry run, custom iperf servers, Geekbench license file
• Understanding the Output — a complete report explained line by line
• Interpreting Results — what the numbers mean, expected ranges per storage/CPU/network class, cache and overload fingerprints, worked examples, checklist
• Benchmarks Are Snapshots — why one run proves little and how to benchmark properly
• JSON Output and Integrations — -j/-w/-s, the schema, unit caveats, result databases

The tests

• Tests: Disk (fio) — the exact fio commands and why each parameter was chosen; units; ZFS and free-space checks; dd fallback
• Tests: Network (iperf3) — server list and history, retry logic, send vs recv, busy, bandwidth usage, -r and -p
• Tests: CPU (Geekbench) — versions, baselines, architectures, uploads and claim URL, failure messages
• System Information — how every line of the header block is gathered, per architecture

Internals

• Architecture and Script Flow — flowchart of the script, functions, files, endpoints contacted, dependencies
• Precompiled Binaries — why static fio/iperf3 binaries, how they are built (musl, Holy Build Box), how to verify them
• GitHub Actions Automation — ShellCheck CI, daily upstream checks, build matrix, VirusTotal gate, releases
• Supported Platforms — architectures, distributions, containers, WSL, RISC-V, known limitations

Help and project

• Troubleshooting and FAQ — every message the script can print, what it means, what to do
• Contributing — testing checklist, conventions, what gets accepted
• Glossary — IOPS, block size, queue depth, direct I/O, steal time, KiB vs KB, and more

Background

• History — from a private iperf script in September 2019 to 2.7 million runs
• Design Principles — the opinions baked into the script
• Ecosystem and Community — forums, result databases, public iperf servers, stats.yabs.sh, the result assessment tool, articles
• Comparison with Other Bench Scripts — bench.sh, nench and friends

Three things to remember

1. YABS reports; it does not judge. It will never say "good" or "bad" — that is this wiki's job, and yours.
2. Every result is a snapshot of a shared machine at one moment. Re-run at another hour before drawing conclusions.
3. Compare like with like: same Geekbench version, same era of the script, similar time of day — and against what you were actually sold.

Links

• Repository: https://github.com/masonr/yet-another-bench-script
• Issues: https://github.com/masonr/yet-another-bench-script/issues
• Usage statistics: https://stats.yabs.sh/
• Result assessment tool: https://stats.yabs.sh/assess
• Binary releases: https://github.com/masonr/yet-another-bench-script/releases
• License: WTFPL