✅ Updated Nov 2026
Affiliate Disclosure: As an Amazon Associate, we earn from qualifying purchases. Links marked "Check on Amazon" are affiliate links — learn more.
⭐ Key Takeaways
Quick answer: Our top pick is Samsung 990 PRO 2TB NVMe SSD, with WD Black SN850X 2TB NVMe SSD with Heatsink as a strong alternative.

Two people can benchmark the same game on the same graphics card under Linux and publish numbers that flatly contradict each other, with neither of them lying. One ran a cold shader cache on a freshly installed system; the other ran a warmed cache on a machine that had been gaming for an hour. One changed Proton versions between runs without noticing; the other compared two kernels while a background update was quietly eating CPU time. On Linux the variables multiply — translation layers, shader compilation, driver branches, compositor behaviour — so a benchmark result is only ever as good as the method behind it. A number published without its method is not data. It is decoration.

This guide is that method: how to design a repeatable run, read frame times instead of headline averages, control the hidden variables that make Linux results drift, and log runs so a claimed improvement is a real one. It is not a catalogue of benchmarking tools — the site already compares those — nor a MangoHud installation walkthrough, which the setup guide covers. This is the discipline between the tool and the conclusion.

As an Amazon Associate, we earn from qualifying purchases.

Quick answer

Benchmark games on Linux by fixing everything except the one thing under test: same save, same scene, same settings, a warm shader cache, and a machine at a known thermal state. Log frame times with MangoHud rather than watching a live counter, repeat each run at least three times, and compare averages alongside the slowest frames instead of averages alone.

Why the average frame rate is the weakest number

An average compresses an entire run into one figure, and compression destroys exactly the information a player feels. A run can hold a high average while still hitching every time a new area streams in, because a handful of very slow frames barely dent the mean across thousands of fast ones. The experience of a game lives in the distribution of frame times — how long each individual frame took to render — not in the summary statistic.

That is why serious benchmarking works in frame time, measured in milliseconds per frame, and reads the tail of the distribution: the slowest slice of frames, often reported as percentile lows. Sort every frame in the run by duration, look at where the slowest portion sits, and ask how bad the bad moments are. Two configurations with near-identical averages can have very different tails, and the calmer tail feels smoother even when the headline numbers tie.

One honesty rule matters here: percentile figures are not defined identically by every tool. Tools slice and name the tail differently, so a percentile low from one program is not automatically comparable with the same label from another. Compare like with like — same tool, same version, same calculation — or the comparison is theatre.

Design the run before you run it

Repeatability starts with the scene. Use the same save file, the same starting point and the same route through the game world for every run, because a different camera path is a different workload. Where a game ships a built-in benchmark, prefer it for hardware and driver comparisons: it removes player input from the equation entirely. Where it does not, a scripted, practised route through a demanding area is the next best thing, and the route should be written down.

Lock everything the test is not about. Resolution, graphics preset, upscaling mode and quality, frame-rate caps, and display configuration stay fixed across every run in a comparison. Decide the variable under test — a Proton version, a kernel, a driver branch, a settings change — and let that be the only thing that moves. Disable variable refresh for controlled runs or fix the refresh behaviour, since a display syncing dynamically adds its own variance to frame pacing. Close background load: launchers updating other games, browsers, indexing services and scheduled updates all belong outside the test window.

Record the environment with the results: distribution and kernel version, Mesa or proprietary driver version, Proton or GE-Proton build, compositor and session type, power profile, and the game’s own build number. A result that cannot be tied to an exact software stack cannot be reproduced, and an irreproducible result is an anecdote.

Control the hidden variables

The largest Linux-specific trap is shader compilation. The first run through a scene compiles shaders and pipelines, and those compilation stalls land in the frame-time log as spikes that have nothing to do with steady-state performance. The standard defence is procedural: run the route once as a warm-up and discard it, let Steam’s shader pre-caching finish before testing where it applies, and only then start recording. Comparing a cold first run of one configuration against a warm run of another is the single most common way Linux benchmarks mislead.

Thermal state is the second trap. A graphics card at the start of a session boosts differently from the same card forty minutes into a heat-soaked case, and a laptop drifts further than a desktop. Standardise the starting condition — begin every run from a similar idle temperature, or test only in the warmed state — and keep fan and power profiles identical across runs. The CPU governor deserves the same treatment: a performance-oriented governor such as the one GameMode applies removes a class of frequency-scaling variance, but only if it is active for every run being compared.

Finally, respect run-to-run variance. No two runs are identical, so a single run proves little. Record at least three runs per configuration, compare the spread as well as the centre, and treat a difference smaller than the spread as no difference at all. If the runs disagree wildly, the method has a leak — find it before publishing anything.

Log it, then compare it

Watching a live overlay while playing is monitoring, not benchmarking. For a result, log: MangoHud can write frame times and sensor data to a file across a run, and those logs can be plotted afterward in frame-time viewers, where the shape of a run — spikes, streaming hitches, shader stalls — is visible in a way a single average never shows. Plot the frame-time graph for every important comparison; the graph is where a stutter hunt is won.

Comparisons then become mechanical. To judge a new Proton release, run the fixed route under the old build and the new build, back to back, changing nothing else, and compare averages and tails across the repeated runs. To judge a kernel or driver, do the same. Keep the logs and let the archive accumulate: a folder of dated logs with environment notes turns future questions into lookups instead of fresh experiments.

How to choose what to measure

Match the measurement to the question. For a driver, kernel or Proton comparison, the built-in benchmark or fixed route with full logging is the right instrument, judged on averages and percentile tails together. For a stutter investigation, the average is nearly useless — go straight to the frame-time graph and look for spikes and their locations in the route. For a settings decision, benchmark the specific scene that struggles rather than the game’s easiest area, and judge by the tail, since settings changes usually buy smoothness before they buy averages. For a whole-system question, such as whether a distribution change helped, run the full suite of test games rather than crowning a winner from one title.

The hardware behind repeatable runs

Method matters more than gear, but a little hardware removes whole categories of noise — a fast, consistent system drive, a second drive for side-by-side installs, portable media that carries a frozen test setup between machines, and a way to watch power draw during a run.

Samsung 990 PRO 2TB NVMe SSD

Samsung 990 PRO 2TB NVMe SSD

Samsung 990 PRO 2TB NVMe SSD

Check price on Amazon

The primary test drive: fast, consistent storage keeps loading and streaming behaviour stable across runs, so storage variance stays out of the frame-time log.

Specs:
– Interface: PCIe Gen4 x4 NVMe, M.2 2280
– Model: MZ-V9P2T0B/AM
– Maker-rated sequential read: up to 7,450 MB/s
– Heatsink: none on this model

WD Black SN850X 2TB NVMe SSD with Heatsink

WD Black SN850X 2TB NVMe SSD with Heatsink

WD Black SN850X 2TB NVMe SSD with Heatsink

Check price on Amazon

A second internal drive for side-by-side installs — one distribution or driver stack per drive — so A/B comparisons never share a system partition.

Specs:
– Interface: PCIe Gen4 x4 NVMe, M.2 2280
– Model: WDS200T2XHE
– Maker-rated sequential read: up to 7,300 MB/s
– Heatsink: integrated

Samsung T9 Portable SSD 2TB

Samsung T9 Portable SSD 2TB

Samsung T9 Portable SSD 2TB

Check price on Amazon

Carries a frozen benchmark library and saved test routes between machines, so the same games, saves and settings travel with the tester.

Specs:
– Interface: USB 3.2 Gen 2×2
– Model: MU-PG2T0B/AM
– Maker-rated sequential read: up to 2,000 MB/s
– Enclosure: ruggedised portable shell

SanDisk Extreme PRO USB 3.2 Flash Drive 128GB

SanDisk Extreme PRO USB 3.2 Flash Drive 128GB

SanDisk Extreme PRO USB 3.2 Flash Drive 128GB

Check price on Amazon

Bootable installer media for clean test installs, kept separate from everyday drives so a test system can be rebuilt identically at any time.

Specs:
– Interface: USB 3.2
– Model: SDCZ880-128G-GAM46
– Maker-rated read speed: up to 420 MB/s
– Capacity: 128GB

P3 Kill A Watt P4400 Electricity Usage Monitor

P3 Kill A Watt P4400 Electricity Usage Monitor

P3 Kill A Watt P4400 Electricity Usage Monitor

Check price on Amazon

A wall meter that logs power draw during a run, adding an efficiency dimension to comparisons and catching configurations that buy frames with disproportionate wattage.

Specs:
– Model: P4400
– Operating voltage: 115 VAC, maximum 125 VAC
– Maximum current: 15 A
– Displays: volts, amps, watts, power factor and cumulative kilowatt-hours

Who should skip this

Skip this method if the goal is a quick sanity check that a game launches and plays — an overlay glance is enough for that. Skip it if the library is mostly older or lightweight titles where every configuration is comfortably fast; there is nothing to measure. And skip the full discipline for one-off personal decisions where the honest answer is simply whether the game feels fine on the machine in front of you. Benchmarking rigour earns its keep when a claim will be published, a purchase decided, or a regression hunted.

FAQ

How many runs are enough for a trustworthy comparison?

Three recorded runs per configuration is a workable minimum, after a discarded warm-up run. Compare the spread between runs as well as the averages: if the runs disagree with each other more than the two configurations differ, the honest conclusion is that no difference was measured.

Why does the first run of a game always look worst on Linux?

Shader and pipeline compilation. The first pass through a scene builds the shaders it needs, and those builds stall frames. Steam’s shader pre-caching and a discarded warm-up run move that cost outside the recorded runs, which is why cold and warm results should never be compared directly.

Are percentile lows from different tools comparable?

Not automatically. Tools define and calculate percentile figures differently, and the same label can hide different maths. Compare results produced by the same tool and version, or convert both back to the raw frame-time logs and analyse those with one method.

Does the built-in benchmark in a game reflect real gameplay?

It reflects a fixed, repeatable workload, which is exactly what comparisons need — but it may stress the system differently from open gameplay, especially for CPU load and streaming. Use built-in benchmarks for A/B comparisons, and a fixed manual route when the question is about real-world smoothness.

Final verdict

Benchmarking games on Linux is a method problem before it is a tools problem. Fix the scene, warm the caches, hold the thermals and software stack constant, log frame times instead of admiring averages, repeat the runs, and change one variable at a time. Do that, and Linux results become reproducible enough to argue with. The hardware above only removes excuses; the discipline is the benchmark.

Explore Our Guides & Free Tools