Free online scroll wheel test
Scroll test that catches the notch that jumps back
Rest the pointer on the pad and turn the wheel: steps upward and steps downward run on separate counters, and each one is listed with the number your browser sent and the unit it chose. The size of your own notch is measured first, and two things are then flagged that no hand could have asked for — a step that turns back within 50 ms, which is an encoder misreading its own direction, and a step twice the size of a notch arriving in the middle of a slow roll. A trackpad or a free-spinning wheel is recognized and left uncounted, because on those one event is not one detent.
- 100% free
- No signup
- Up and down apart
- Raw deltaY shown
- 50 ms reversal check
up 0
down 0
Rest the pointer in here and turn the wheel — slowly, one notch at a time, then a long roll each way. The page holds still while you do it, so nothing scrolls out from under the count.
no wheel event yet
What the wheel is doing
Roll a few more notches and the page will work out whether this wheel has detents in it.
- Sideways steps
- none — no tilt, no swipe, no Shift held
- Signed travel
- 0 px vertical, 0 px sideways
- Third axis
- deltaZ —
Fault checking waits for a notch size, because both faults are defined against one. It stays off on a trackpad by design.
The last 10 events, exactly as they arrived
Nothing yet. One row will appear per wheel event, with the number your browser sent before this page converted it.
Pixel figures are converted, not measured: a line is taken as 40 px and a page as 800 px so that the same detent reads alike whichever unit your browser chose. Counts and directions are the readings to trust; the distance is not comparable with someone else’s screenshot, because macOS scales the wheel by how fast you turn it before the event is ever built.
How to test a scroll wheel
Three passes: one to teach the page your wheel, one to hunt the fault, one to find what never arrived.
Turn it slowly first, one detent at a time
Give the page a dozen deliberate clicks of the wheel before you ask it anything, because the size of a step is not a constant it can look up — it depends on your browser, your operating system and whether your wheel reports in whole notches at all. Once three steps agree on a size, the panel names your detent in pixels, and everything after that is measured against a yardstick that came from your own hardware.
Now roll properly, fifty steps each way
An encoder that has started to fail does not fail on every detent; it does it once in a few dozen, which is exactly why the complaint sounds vague when you describe it to somebody. Scroll down at the speed you would read at, then back up, and keep going for a minute. Anything that turns back on itself lands in the fault list with the two step sizes and the gap between them, and the row stays there for as long as the run does.
Set a target and count the clicks out loud
No browser can see a detent that generated no event, so the only way to find a missing one is to know how many you turned. Pick 10, 20 or 50 from the target control, turn exactly that many downward clicks, and read what arrived. Fewer than you turned means the encoder is dropping steps; more means it is inventing them; the same number is the cleanest result this test can give you.
Technical specifications
| Event read | wheel, registered non-passive so the pad holds still instead of scrolling out from under the count |
|---|---|
| Units normalized | deltaMode 1 taken at 40 px per line and deltaMode 2 at 800 px per page, so Firefox's 3 and Chrome's 100 describe one detent |
| Notch size | Measured from your own run: the most common step above 30 px, once three of them agree and account for 60% of the large steps |
| Reversal rule | Opposite direction within 50 ms, and no bigger than the step it contradicts |
| Doubled-step rule | 1.8 notches or more inside one event, and only while consecutive events are over 120 ms apart |
| Sideways movement | deltaX tallied left and right on its own: a tilt wheel, a two-finger swipe, or Shift held while rolling |
| Events held | The last 4,000 in memory with the ten newest listed in full; Empty the table drops all of them |
| What no browser can see | A detent that produced no event at all — only the counted run finds those, by comparing what you turned against what arrived |
Frequently asked questions
Why does Firefox report 3 where Chrome reports 100 for the same notch?
Because they answer in different units, and the event says which one it used. Every wheel event carries a deltaMode field: 0 means the numbers are CSS pixels, 1 means lines of text, and 2 means whole pages. Chrome and Safari nearly always pick pixels; Firefox on Windows and Linux picks lines and reports three of them per notch, matching the Windows setting that decides how far one click of a wheel scrolls. The table on this page prints both — what your browser sent, and the same movement converted to pixels — so a reading from one browser can be compared with a reading from another.
My trackpad fills the table with fractions. Is something wrong with it?
No, that is exactly what a trackpad looks like from inside a browser. It has no detents and nothing to click against, so it reports a continuous stream of small pixel deltas — often fractional, often sixty or more a second — and then keeps sending them for a second or two after your fingers leave the glass while the momentum decays. The page detects that there is no repeating step size, says so, and switches its fault checks off rather than reporting hundreds of direction changes that are just you rubber-banding at the top of a list.
The page counted fewer steps than I turned. What does that mean?
It means the encoder produced nothing for one or more of the detents your fingers felt, which is the most common way a wheel dies. The wheel body still clicks — that is a sprung arm riding over a toothed ring, and it is purely mechanical — while the part that actually reports movement has stopped keeping up. Repeat the counted run three or four times before you conclude anything, because a single miscount is more likely to be your own counting, and check whether the losses cluster at one point in the wheel's rotation.
My wheel scrolls two lines for every click in every application.
That is a setting rather than a fault, and it lives outside the browser. Windows has a wheel-scroll figure that defaults to three lines and is adjustable up to a whole screen; macOS and most Linux desktops have their own equivalent. A setting applies uniformly to every notch you turn, so it shows up here as a perfectly consistent step size and no fault rows at all — whereas the doubled step this page flags appears in a run where every other step was half the size, which is the difference that matters.
Scrolling sometimes goes the wrong way. Is that the natural-scrolling setting?
Only if it goes the wrong way every single time. Direction inversion is a checkbox — natural or reverse scrolling — and a checkbox cannot be intermittent: with it on, up becomes down for every notch, on every application, permanently. What this page hunts is the opposite pattern, a single step that contradicts the fifty around it, which no setting can produce and which points straight at the encoder misreading one of its own transitions.
Why does the page stay still while I am rolling?
Because the pad cancels the scroll it would otherwise cause, and it has to be registered in a particular way to be allowed to. A listener declared as passive is not permitted to cancel anything, so the wheel handler here is registered non-passive on purpose — otherwise the count would slide up the screen as you built it and you would spend the test chasing the pad. The rest of the page scrolls normally; move the pointer off the pad and the wheel behaves as it always does.
Can a free-spinning wheel be tested here?
Partly, and the page will tell you which part. In free-spin mode the detent arm is lifted away, so there is nothing to count and the step sizes stop repeating; the same is true of the high-resolution mode that several mice now use even when notched, where one physical click is delivered as several small events instead of one. Direction, units, totals and the raw event stream all remain meaningful. Detent counting and the two fault checks do not, and are switched off rather than left to produce numbers nobody could act on.
About the encoder under the wheel
A mouse wheel is two mechanisms sharing an axle, and almost every complaint about scrolling comes from confusing them. The clicks you feel are a sprung arm riding over a toothed ring — usually 24 teeth, so one detent is 15 degrees of rotation — and that part is pure mechanics, which is why a dead wheel still feels perfectly normal in the hand. The part that reports anything is a quadrature encoder: two channels whose signals are a quarter-cycle out of phase, so the order in which they change tells the mouse which way the wheel turned. Wear shows up as a disagreement between those two mechanisms. The detent parks the encoder near one of its own switching points, and once the contacts are dirty or the optical gate is dim, a fingertip resting on the wheel is enough to make the channels change in the wrong order — one step reported forward, one step immediately reported back, from a wheel that never moved.
None of that reaches a page unaltered. Windows counts wheel movement in units of 120 per detent and converts them using the same lines-per-click figure a user can change in settings; high-resolution wheels send fractions of that 120 so a single click arrives as several small events; and macOS multiplies the whole thing by how fast you turned it, which is why a slow notch and a fast notch report different distances on the same hardware. That is the reason this page counts steps and directions instead of claiming a scroll distance, and the reason the notch size on screen is one it measured on your machine rather than a constant. If your suspicion is the wheel’s click rather than its rotation, that is a switch and it belongs to the mouse tester; if the same button is firing twice on a single press, the double click test times the pair and says whether a hand could have made it.
Most scroll testers online show a running total of deltaY and stop there, which looks informative and answers nothing: the total grows whichever way the wheel misbehaves, it is denominated in a unit that differs between browsers, and it cannot distinguish a detent you turned from one the encoder imagined. Directions counted separately, a learned notch size and a per-event list are what let you point at the moment things went wrong. If the fault list does fill up, the practical order is compressed air through the wheel slot, then a drop of contact cleaner on the encoder if the mouse opens without damage, then a replacement encoder — a standard 24-detent part that costs a couple of dollars and solders in with five pins. If instead the wheel is fine and the whole pointer is the thing that stutters, that is a different measurement and the cursor test draws it.
What the event table keeps
Every number on this page is worked out by JavaScript running in the tab you are reading it in. Nothing you type, paste or open is uploaded, logged or kept, which is also why the tools carry on working after you disconnect from the network.
A stored sample is four numbers and a unit name — how far, which way, when, and whether the browser counted in pixels or lines. Up to four thousand of them sit in the tab while you roll, they are never joined to anything that identifies the mouse or the machine, and Empty the table removes them at once.