Litmus
The Professional Network Speed Test
A free, professional-grade network speed test and iperf alternative. Test LAN and WAN bandwidth between any two machines — measuring latency, jitter, packet loss, and data integrity with automatic quality grading and PDF reports. Available for Windows and Linux, no runtime required.
What Litmus Measures
Go beyond basic speed tests and iperf output. Every Litmus test produces a complete picture of network health with real-time metrics and professional-grade analysis.
Throughput
Average, minimum, and maximum bits per second across the test window.
Latency
Idle (pre-test baseline), loaded (during test), and post-test recovery measurements.
Jitter
RFC 3550 interarrival jitter calculation with per-sample timeline tracking.
Packet Loss
Per-packet sequence tracking with timestamped loss event detection.
Data Integrity
CRC32 verification — per-packet on UDP, stream-level on TCP.
Quality Score
Composite A through F letter grade derived from five weighted metrics.
Litmus vs iperf3 vs Online Speed Tests
See how Litmus compares to iperf3 and browser-based speed test tools like Speedtest.net and Fast.com.
| Feature | Litmus | iperf3 | Online Speed Tests |
|---|---|---|---|
| Throughput (bandwidth) testing | |||
| Latency measurement | Idle, loaded & recovery | Ping only | |
| Jitter (RFC 3550) | |||
| Packet loss tracking | Per-packet timestamped | Summary only | |
| Data integrity (CRC32) | |||
| Quality grading (A–F) | |||
| PDF reports | Automatic | ||
| GUI (desktop app) | Windows WPF | CLI only | Browser |
| CLI / headless mode | |||
| Real-time charts | 5 chart styles | Basic | |
| DSCP / QoS marking | |||
| Bandwidth shaping | Kbit–Tbit | ||
| Tests your actual network path | Tests to ISP only | ||
| No account or sign-up | Ads / tracking |
Test Any Configuration
Mix and match protocols, directions, and stream counts to test exactly the scenario you need.
Protocol
- TCP
- UDP
- Both (sequential)
Direction
- Upload
- Download
- Bidirectional
Streams
- 1–8 parallel connections
- Per-stream tracking
- Live aggregation
Certification Mode
One-click test suite that runs all six protocol/direction combinations in sequence, compiling results into a single certification PDF report with per-test grades and an overall pass/fail determination.
Network Quality Score
Every test receives a composite letter grade derived from five weighted metrics using a quadratic scoring curve.
Weighted Metrics
Threshold: min/max variance
Threshold: 100 ms
Threshold: 10 ms
Threshold: 0.05%
Threshold: 0 corrupt packets
Grade Scale
Scoring uses a quadratic curve — small deviations have minimal impact while values approaching the threshold drop the score sharply.
Professional Reports & Export
Automatic PDF report generation after every test, available in light and dark mode.
Standard Report
- Hero throughput banner
- Side-by-side config and quality summary
- Letter grade badge
- Throughput chart
- Full metric breakdown
Certification Report
- Multi-test summary with per-test grades
- Pass/fail shields
- Overview grid of all 6 tests
- Individual test detail pages
- Generated via --certify flag
Sample Reports
Standard Report
See what a single-test report looks like: TCP download at 4.96 Gbps with Grade A quality scoring, throughput charts, and full metric breakdown.
View Sample ReportCertification Report
Preview a full network certification: 6 tests across TCP & UDP (download, upload, bidirectional) on a 250 Mbps link, with per-test pass/fail results and charts.
View Certification ReportJSON Export
Structured output with config, per-interval samples, and full result summary
CSV Export
One row per sample: timestamp, bitrate, direction, latency, jitter, and more
Advanced Controls
More control than iperf3 or any speedtest app — fine-tune every aspect of your tests with professional-grade configuration options.
Bandwidth & Traffic
- Bandwidth shaping (Kbit–Tbit)
- DSCP/QoS marking (0–63)
- Socket buffer size override
- Warmup omit (0–60 seconds)
UDP Controls
- Packet size (68–65,535 bytes)
- Don't Fragment bit
- Ramp-up pacing (0–2,000 ms)
- Auto-detect ramp-up duration
Test Termination
- Duration-based (seconds)
- Byte count (K/M/G suffixes)
- Packet count (UDP)
- Interface binding
Data Patterns
- Random (cryptographic)
- Zeros / Ones / Alternating
- Incrementing sequence
- Microwave stress & custom byte
Charts & Visualization
- Area, Line, Bar, Step, Gauge styles
- 500 ms sample updates
- Up to 4 simultaneous test runs
- Auto-detect MTU (binary search)
Server & Network
- Active connection monitoring
- CPU usage with alert thresholds
- Peer discovery & chat (LAN)
- Server uptime & transfer statistics
Download Litmus
Download this free network speed test tool — self-contained executables, no runtime or dependencies required.
Windows
Windows 10/11 (64-bit)
Full-featured WPF desktop application with real-time charts, tabbed interface, and settings dialog.
v1.1.0
SHA-256: 6397b6a1dd6da21d8a72c0ed9b06c0b5b7e8543c6f19ebfbad8e3b7004e1bd1b
Linux
x86_64 binary
Terminal application with interactive TUI, headless mode, and JSON output for automation.
v1.1.0
SHA-256: ffe39a37462e51685b86c9c2c3e75a5274c40d1b86c5fd0d100705b6a1ae5150
System Requirements
Windows
- Windows 10 or 11 (64-bit)
- ~190 MB disk space
- No .NET runtime or installer required
Linux
- x86_64 (Intel/AMD 64-bit)
- ~100 MB disk space
- No dependencies — single static binary
Network
- Two machines — one server, one client
- Reachable over IP (LAN, WAN, or VPN)
- Default port 7201 (configurable)
Windows SmartScreen Notice
Because Litmus is a new product with a self-signed certificate, Microsoft SmartScreen may flag the download as “unknown” and show a warning when you first run it. This is normal for any newly published software and only happens once — after you allow it the first time, Windows will not prompt again.
To verify the file is authentic, right-click Litmus.exe, select Properties → Digital Signatures → Details → View Certificate, and confirm the certificate thumbprint matches:
40f00afbb53179e8f366132eb808954a8c9c4333Quick Start
# Download (Linux)
wget https://bobpopcorn.com/tools/litmus-x64 && chmod +x litmus-x64# Start a server
./litmus-x64 -s# 60-second TCP download test
./litmus-x64 -c 192.168.1.100 -t 60# 8 parallel UDP streams
./litmus-x64 -c 192.168.1.100 --udp -P 8 -l 1500# Bidirectional test with 1G target
./litmus-x64 -c 192.168.1.100 --bidir -b 1G# UDP with DSCP marking
./litmus-x64 -c 192.168.1.100 --udp -S 46 -l 1400# Transfer 500 MB then stop
./litmus-x64 -c 192.168.1.100 -n 500M# JSON output for scripting
./litmus-x64 -c 192.168.1.100 -t 30 -J# Full certification with PDF report
./litmus-x64 -c 192.168.1.100 --certifyRelease History
Current release — Windows 10/11 desktop app and Linux x86_64 CLI.
Initial public release — TCP/UDP throughput, latency, jitter, packet loss, CRC32 integrity, A–F grading, and PDF reports.
CLI Flag Reference
Mode
-s, --serverRun as server-c, --client <host>Run as client, connecting to host--chatRun as chat relay (multicast bridge)Protocol & Direction
--tcpTCP mode (default)--udpUDP mode--bothRun TCP then UDP sequentially--uploadClient sends, server receives-R, --downloadServer sends, client receives (default)--bidirSimultaneous upload and downloadTest Parameters
-t, --time <sec>Duration in seconds (default 30)-n, --bytes <n>Stop after n bytes (e.g. 100M, 1G)-k, --packets <n>Stop after n packets (UDP)-P, --parallel <n>Parallel streams, 1–8 (default 1)-b, --bandwidth <rate>Target bandwidth (e.g. 100M, 1G). 0 = unlimited-l, --length <bytes>UDP packet size in bytes (default 1400)-O, --omit <sec>Omit first N seconds as warmup (default 2)Network & QoS
-p, --port <port>Server port (default 7201)-B, --bind <iface>Bind to specific local interface-S, --dscp <n>Set DSCP/QoS value, 0–63-D, --dont-fragmentSet DF bit (UDP only)--buffer <KB>Socket buffer size in KB (0 = OS default)--ramp-up <ms>UDP ramp-up period in ms (default 150)--pattern <type>Data pattern: random, zeros, ones, alt55, altaa, incrementing, microwave, highbit, custom:0xNN--port-range <range>Data port range for server (e.g. 10000–10100)Reporting & Output
-J, --jsonOutput results as JSON--report [path]Generate PDF report--report-dir <dir>Auto-save PDF report to directory--certifyRun all 6 test combinations and generate PDF--no-reportDisable PDF report with --certify--log <path>Log file pathThresholds & Display
--latency-threshold <ms>Latency fail threshold (default 100 ms)--jitter-threshold <ms>Jitter fail threshold (default 10 ms)--loss-threshold <%>Packet loss fail threshold (default 0.05%)--plainDisable colours and Unicode art--no-tuiPlain-text server output (no TUI)--showShow effective settings and exitFrequently Asked Questions
Common questions about Litmus, network speed testing, and how it compares to iperf and online speed tests.
Run Litmus as a server on one computer and as a client on the other. Download the binary on both machines, start the server with "litmus-x64 -s", then run "litmus-x64 -c <server-IP>" from the client. Litmus measures throughput, latency, jitter, and packet loss across the actual path between the two machines — LAN or WAN.
Yes — Litmus measures the real network path between two endpoints, so you need a machine at each end of the link you want to test. That is what makes the results meaningful for LAN, WAN, and link certification work: you test your network, not the path to a third-party server.
Under 1 millisecond is typical for a healthy wired gigabit LAN; consistently higher than a few milliseconds usually points to congestion, duplex mismatches, or faulty hardware. Litmus measures idle, loaded, and recovery latency separately, and its default quality thresholds flag latency above 100 ms and jitter above 10 ms.
Yes. Litmus is completely free to download and use — no account, no licence key, and no usage limits. Both the Windows desktop app and the Linux CLI are self-contained executables with no runtime dependencies.
Litmus measures everything iperf3 does (throughput, jitter, packet loss) and adds latency measurement, data integrity verification (CRC32), automatic quality grading (A–F), real-time charting, and PDF report generation. Unlike iperf3, Litmus includes a full GUI on Windows and an interactive TUI on Linux.
Litmus is not a wrapper around iperf — it is an independent tool built from scratch. However, it fills the same role as iperf with a graphical interface on Windows (WPF desktop app with real-time charts, tabbed interface, and settings dialog) and an interactive terminal UI on Linux.
Online speed tests only measure the path between your device and the test provider's nearest server — they cannot test internal LAN or WAN links. Litmus tests the actual network path between any two machines you control, giving you accurate results for internal bandwidth testing, link certification, and troubleshooting.
Litmus measures five core metrics: throughput (average, min, and max bandwidth), latency (idle, loaded, and recovery), jitter (RFC 3550 interarrival calculation), packet loss (per-packet with timestamps), and data integrity (CRC32 verification). These are combined into a composite A–F quality score.
Yes. Use the --report flag on any test to generate a professional PDF report, or use --certify which includes a report automatically. Reports include all metrics, charts, quality grades, and test parameters — ready to attach to handover documents, SLA reviews, or change tickets.
Yes. The --certify flag runs a comprehensive test sequence covering both TCP and UDP with multiple packet sizes and directions. The resulting report serves as objective evidence of link performance for handovers, acceptance testing, and SLA validation.
Litmus is available as a desktop application for Windows 10/11 (64-bit) and as a terminal application for Linux x86_64. Both are single-file executables — no installation, no dependencies, no runtime required.
Yes. The Linux CLI supports headless mode and JSON output, making it straightforward to script automated tests, integrate with monitoring systems, or run scheduled bandwidth checks via cron.
Monitoring tools passively observe traffic flowing through your network. Litmus is an active test tool — it generates controlled traffic between two endpoints to measure the actual capacity and quality of a link. Use monitoring for ongoing visibility and Litmus for targeted testing, troubleshooting, and certification.