Methodology

What the browser can measure

BenchRush measures the last part of a much larger hardware-to-browser pipeline. This page shows exactly where each number begins, where it ends and how to reproduce it.

Measurement boundary

The browser sees events, not your entire device.

A keyboard switch closes, firmware creates a report, the operating system processes it, the browser receives an event and JavaScript finally sees that event. BenchRush starts at that last browser-visible layer. That makes the tools useful for reproducing symptoms and personal baselines — but not equivalent to USB analyzers, oscilloscopes or manufacturer diagnostics.

Hardware→OS / driver→Browser→BenchRush
Signal pipeline

From action to result

01You act

Press a key, move a pointer, click a target or wait for a visual cue.

02The browser delivers

KeyboardEvent, PointerEvent, wheel or animation callbacks reach the page.

03BenchRush times/counts

JavaScript records distinct events, intervals, hits or misses with a defined test window.

04You interpret

The result is shown with its browser-level limitation and a related guide or test.

Measurement matrix

This is the shortest way to see what each tool means. “Not measured” is deliberate: a useful methodology says where the number stops.

ToolBrowser signalReported resultNot measured directly
Keyboard testkeydownDistinct received keys / quick-check completionSwitch contacts, scan matrix, cable electronics
Rolloversimultaneous keydown/keyupHeld keys + maximum simultaneous countEvery possible matrix combination or NKRO certification
Mouse testpointer/button/wheel eventsWhich core inputs reach the pageSensor quality, switch bounce electronics, raw USB packets
Double-click checkclick timingVery-rapid repeats under the test thresholdElectrical debounce waveform or switch condition
Polling estimatepointermove timestampsApprox. browser pointer-event HzConfigured raw USB polling rate
Scroll testwheel eventsevent rate + direction changesPhysical wheel rotation distance
Gamepad testGamepad API button/axis statebrowser-visible buttons, axes and connection stateraw HID/USB packets, firmware calibration or physical mechanism
Screen visual testmanual solid-color inspectionno automatic score; visual comparison onlyphysical pixel state from JavaScript
Refresh estimaterequestAnimationFramemedian frame cadence + timing spreadPanel electronics or guaranteed monitor mode
Reaction testperformance.now() around visual cue/click5-round average in msHuman reaction isolated from display/input latency
CPSclick eventsclicks ÷ 10 secondsSwitch actuation force or hardware debounce settings
Spacebar sprintnon-repeat keydowndistinct presses / 10 secondsPhysical travel or switch force
Mouse accuracytarget pointer events + timinghit accuracy + average acquisition timeSensor lab precision, human ability independent of setup

Timing rules that matter

performance.now()

Reaction and target-acquisition timing use the browser’s monotonic high-resolution clock rather than wall-clock time.

requestAnimationFrame()

The refresh test samples callbacks scheduled before repaints. Hidden/background tabs can be throttled, so the test asks you to keep the tab visible.

Pointer delivery

Pointer events can be coalesced or scheduled by the browser. That is why polling is labeled a browser event-rate estimate, not raw USB telemetry.

Repeated runs

Short browser measurements are noisy. Same-device, same-browser repeated runs are more useful than comparing isolated numbers across different setups.

How result labels work

A raw number is not very useful without context, so BenchRush adds a short interpretation directly to completed numeric tests. The label depends on the kind of measurement:

Reaction time

Uses a public browser-test reference. Human Benchmark currently reports a 273 ms median across more than 81 million recorded reaction clicks. BenchRush uses that as broad context, not as a medical norm or a guaranteed percentile.

CPS, Spacebar & Accuracy

Use broad BenchRush guide ranges designed to make repeated same-device runs easier to understand. They are explicitly not population percentiles.

Polling & Refresh

Use the nearest familiar Hz class to describe browser-visible cadence. “Near 1000 Hz” or “Near 144 Hz” is setup context, not certification of USB or panel hardware.

For any timing or speed result, your own repeated runs on the same device and browser are usually more meaningful than a cross-device comparison. Reaction reference checked 2026-10-05: Human Benchmark reaction-time statistics.

PlayerScore v1 — exact rules

PlayerScore is intentionally simple and transparent. It unlocks after at least three supported benchmark components exist. Each available component is normalized to 0–100, the available components are averaged, then the average is multiplied by 10 and rounded to produce a 0–1000 local score.

Reactionclamp((450 − ms) ÷ 3, 0, 100)
CPSclamp((CPS − 2) × 10, 0, 100)
Spacebarclamp((presses − 20) ÷ 0.9, 0, 100)
Keyboardquick-check completion %, capped at 100
Mouse100 after all 4 core inputs pass
Pollingclamp(browser Hz ÷ 10, 0, 100)
Accuracysuccessful target clicks ÷ all attempts × 100

Not included in PlayerScore: keyboard rollover and refresh-rate estimates. They provide setup context but do not raise or lower the score. Arcade scores also remain separate.

A repeatable test protocol

  1. Keep the tab visible and focused.Background throttling can affect animation and event timing.
  2. Use the same browser and device.Change one variable at a time when testing a setting or hardware change.
  3. Run more than once.Use a stable range or multi-round average instead of one lucky result.
  4. Separate symptoms from diagnosis.A missing browser event is evidence; it is not proof of which hardware layer failed.
  5. Escalate when the decision matters.Use manufacturer diagnostics or lower-level tools for hardware certification or warranty decisions.

Technical references

BenchRush’s browser-side measurement language follows standard Web APIs. These references explain the primitives the tests use; they are not endorsements of BenchRush.

Method changes are versioned in plain English

Current scoring model: PlayerScore v1. Methodology reviewed: 2026-10-05. If a formula changes, BenchRush will update this page rather than silently redefining what an old score meant.

Why BenchRush is built this way → · Read the interpretation guides →