# How input latency is measured: cameras, photodiodes and button taps

> Input lag is timed from a press to its result. What high-speed cameras, screen photodiodes, solenoids and electrical button taps each include and can resolve.

- Canonical: https://cronuszenlab.com/reference/how-input-latency-is-measured
- Site: Zen Lab (https://cronuszenlab.com/)
- Author: Dana Rehn (https://cronuszenlab.com/authors/editorial)
- Section: Method
- Published: 2026-10-10 · Updated: 2026-11-14
- Tags: input lag, latency, measurement, photodiode, high-speed camera

---

Input latency is measured by timestamping a press and the response it causes, and each published method puts those two timestamps at a different point in the chain. A camera starts the clock on the visible press and stops on the first changed frame, while an electrical tap closes the button contact itself and stops when the input event reaches a computer. Figures taken with different methods cover different stretches of the chain and cannot be compared directly.

NVIDIA's [Reflex article of 1 September 2020](https://www.nvidia.com/en-gb/geforce/news/reflex-low-latency-platform/), by Seth Schneider, names the stretches. Peripheral latency is the input device processing the press and sending it to the PC. PC latency is a frame's trip through the PC, game and render together. Display latency runs from the finished frame to the new image on the panel, and system latency is the whole span. With a console in the chain, the console fills the PC's segment.

## Which segment does each method cover?

| Method | Clock starts | Clock stops | Segments covered | Stated resolution or accuracy |
| --- | --- | --- | --- | --- |
| High-speed camera | Press, seen on video | First changed frame on screen | Peripheral, PC or console, display, plus finger travel | One frame: about 4.17 ms at 240 fps, 1 ms at 1000 fps |
| LagBox (Bockes, Wimmer and Schmid, CHI EA 2018) | Opto-coupler closes the button contact | Input event arrives at a Raspberry Pi 2 | Peripheral, from the contact onward | Sub-millisecond, per the authors |
| Schmid and Wimmer device (EHPHCI 2021) | Opto-coupler closes a mouse button contact | Photoresistor sees the screen region turn white | Peripheral from the contact onward, PC, display | Device's own delay averaged 116.5 µs over 200 readings |
| Optical mouse on the screen (Casiez et al., UIST 2015) | Displayed texture moves under the mouse | Mouse reports the motion | Display output and mouse input as one loop | Up to 5 readings per second |
| Blur Busters Arduino tester (2012) | Software flashes squares on screen | Photodiode sees the change | Display, against a reference | ±0.1 ms claimed after zero calibration |
| NVIDIA LDAT | Mouse click | Luminance change on the panel | Peripheral, PC, display | No figure on NVIDIA's page |
| NVIDIA Reflex Latency Analyzer | Click arriving at the monitor's USB port | Resulting pixel change | PC and display; peripheral too with a compatible mouse | None stated |
| Gamepadla Prometheus 82 | Solenoid makes contact with the control | PC registers the input | Peripheral, including actuation | ±1 ms stated in the Prometheus 82 README |
| RTINGS TV input lag test | Tool flashes a white square | Pixels at screen center start to change | Display only, pixel response excluded | Floor of 4.17 ms at 120 Hz, 8.33 ms at 60 Hz |

## Cameras count in frames

A high-speed camera films the controller and the screen in one shot, and the frames between the press and the first change on screen are counted. Every reading is rounded to a whole frame. At 240 fps a frame lasts 1/240 s, about 4.17 ms; at 1000 fps it lasts 1 ms. NVIDIA's article gives that 1 ms floor for a 1000 FPS camera, puts the bare-minimum equipment at about $7,000 and says each measurement takes roughly 3 minutes.

Andreas Schmid and Raphael Wimmer of the University of Regensburg give the same limits in [Yet Another Latency Measuring Device](https://epub.uni-regensburg.de/45570/1/yet-another-latency-measuring-device.pdf) (EHPHCI 2021): 1 ms at 1000 fps and 4 ms at 240 fps. They call the manual analysis of video cumbersome, which is why electrical methods were built. At 240 fps a 1 ms change is about a quarter of one frame, too small to appear in a single reading.

## Photodiodes and other screen sensors

RTINGS describes its TV method on its [input lag test page](https://www.rtings.com/tv/tests/inputs/input-lag) (Adam Babcock, updated 3 October 2025). A photodiode tool sits at the center of the screen, and a test PC is connected to both the tool and the TV. The tool flashes a white square and stops timing the moment the pixels start to change, so the panel's response time is left out. The software averages several readings and ignores outliers. A TV draws each image from the top down, so a sensor at the center catches the change halfway through a refresh. On a 120 Hz TV each image takes 8.33 ms to draw, which makes 4.17 ms the lowest figure the test can record; on a 60 Hz TV the floor is 8.33 ms.

Blur Busters published an early do-it-yourself version on [18 October 2012](https://www.blurbusters.com/sneak-preview-of-arduino-input-lag-meter/). Mark Rejhon's Arduino tester used a photodiode pressed against the screen and claimed input lag accuracy of ±0.1 ms once zero-calibrated against a CRT on the same system. A later edit to the post says the CRT calibration was no longer needed.

NVIDIA's [LDAT](https://developer.nvidia.com/nvidia-latency-display-analysis-tool) is a discrete hardware analyzer built around a luminance sensor. NVIDIA says it measures motion-to-photon latency, click to muzzle flash, and works with GPUs from all vendors, and it publishes no accuracy figure. Schmid and Wimmer note that LDAT senses mouse button presses electrically, that it went only to a selection of hardware reviewers, and that its internals have not been published, so outside researchers cannot validate it.

The Reflex Latency Analyzer, built into 360 Hz G-SYNC displays, takes another route. The mouse plugs into a designated USB port on the monitor, which watches for clicks and times until the resulting pixel change. NVIDIA says a compatible mouse adds peripheral latency to the reading, and any other mouse except a Bluetooth one gives PC plus display latency. Schmid and Wimmer point out that this clock starts when the click reaches the system, so the device's own internal latency stays outside it.

Géry Casiez and colleagues ([UIST 2015](https://hal.science/hal-01226729)) turned the screen into the input. As Schmid and Wimmer summarize the method, the mouse sensor sits on the display, the display moves a texture under it, and the time until the input event arrives is the reading. The abstract gives up to five readings a second and allows software probes, such as mouse event listeners, to locate where the time goes. Their results show latency affected by the operating system and system load.

## Taps and solenoids on the button

[LagBox](https://hci.uni-regensburg.de/publications/bockes_2018_lagbox) (Florian Bockes, Raphael Wimmer and Andreas Schmid, CHI EA 2018) runs on a Raspberry Pi 2. An opto-coupler soldered to a controller, mouse or keyboard button is switched from the Pi's GPIO pins, and the tool times each toggle until the input event arrives. The authors claim sub-millisecond accuracy. The group's [project page](https://hci.uni-regensburg.de/projects/input-device-latency) says a test repeats 1,000 times, with a random wait of 0.1 to 10 ms so the circuit can discharge. The same page models a device's latency as four parts: the button's mechanical delay, the device's microcontroller, the USB polling interval and the kernel's process-switching interval. Closing the contact electrically skips the first of those, so a LagBox figure starts at the contact.

Schmid and Wimmer's 2021 device joins an electrical tap to a screen sensor. An Arduino Micro closes a modified mouse button through an LTV-817 opto-coupler, the test application turns a black region white, and a photoresistor taped to the monitor stops the timer. Between presses it waits a random 100 to 1,000 ms so it does not fall into step with the system under test. Its own delay averaged 116.5 µs over 200 readings, with a minimum of 112 µs and a maximum of 124 µs. Filmed for 99 readings with a Google Pixel 3a at 240 fps, its results differed from the frame counts by 2.64 ms on average, less than one frame of that video. The paper also shows how much sensor position matters: on a 60 Hz monitor the top and bottom of the screen differ by 16.67 ms.

Gamepadla's [Prometheus 82](https://github.com/cakama3a/Prometheus82) keeps the mechanical stage in. Arduino hardware fires a solenoid at a button or stick, a sensor at the solenoid's tip marks the moment of contact, and Python software times until the PC registers the input. The project's README says a test repeats 500 times and gives a permissible error of ±1 ms for buttons and sticks. The test script as published sets 400 iterations with a 40 ms solenoid pulse and keeps readings between the 2% and 98% quantiles. Gamepadla's device pages measure polling rate separately with a software tool and list the Windows build behind each row.

## Why does a single reading say so little?

Latency moves from one press to the next. Raphael Wimmer, Andreas Schmid and Florian Bockes measured 36 USB keyboards, mice and gamepads for [On the Latency of USB-Connected Input Devices](https://hci.uni-regensburg.de/publications/on_the_latency_of_usb-connected_input_devices_2019) (CHI 2019). The devices differed in the distribution of their latencies as well as in the average, and the authors write that reporting only means and standard deviations hides those distributions. Their project page proposes swarmplots, which draw every reading as its own point. Part of the spread comes from polling, since a press can land anywhere in the host's polling cycle. [The polling note](/reference/controller-polling-rate-explained) works through that arithmetic, and [the stage-by-stage latency budget](/reference/what-adds-controller-input-latency) lists the other stages that vary.

Labs also summarize in different ways. RTINGS averages its readings and leaves out outliers. Gamepadla's script trims its readings to the 2% to 98% quantile range before averaging, while the Regensburg group plots every point.

## FAQ

**How is controller input lag measured?**

By timestamping a press and the response it causes. Labs close the button contact electrically or strike it with a solenoid and time the input's arrival at a computer, film the pad and screen with a high-speed camera, or put a light sensor on the screen.

**Can a 240 fps phone measure 1 ms differences?**

No. One frame at 240 fps lasts about 4.17 ms, so each reading is rounded to whole frames and a 1 ms difference is about a quarter of the smallest step the camera records.

**What does a photodiode input lag test measure?**

On RTINGS's TV test, the time from a white square being flashed until the pixels at the center of the screen start to change. The figure describes the display alone and leaves out pixel response time.

**Why do latency tests repeat a press hundreds of times?**

Latency varies from one press to the next. Wimmer, Schmid and Bockes found that USB input devices differ in the shape of their latency distributions, which a single reading or a mean alone cannot show.

