Button Rollover Test

You are sprinting, you are aiming, you are holding a direction, and you press jump. Four inputs, one moment, and one of them quietly does not arrive. Most people blame themselves for that. Sometimes it really is the hardware, because not every controller can carry every combination of buttons at the same time, and the ones that cannot will never tell you which combination they struggle with. This page finds out. It counts how many buttons your pad can hold at once, checks the combinations games actually use, watches for inputs appearing that you never pressed, and measures how far apart two buttons really land when you swear you pressed them together.

Test Your Controller

Results

Button scorecard

Combination results

Report

How To Run It Properly

1. Use a cable if you have one. A wireless pad that drops a packet at the wrong instant produces exactly the same reading as a pad that genuinely cannot hold the combination, and you want to rule that out first.
2. Press any button on the controller so the browser starts reporting it. Nothing appears in the grid until you do, and that is the browser being careful rather than anything being broken.
3. Start in free press mode and press a few buttons individually. You are confirming the grid matches your pad and that the indices line up before you test anything harder.
4. Switch to add one more. Hold one button, then add a second without letting go, then a third, and keep going as far as your fingers reach. Watch the held now number climb. If it stops climbing while you are still adding fingers, you have found something.
5. Run the combination check next. The tool names a combination, you hold it, and it confirms every button arrived without anything extra. This is the mode that catches faults specific to certain groupings rather than to a count.
6. Finish with together timing. Pick two buttons, press them as simultaneously as you can, and repeat it fifteen or twenty times. The number that comes out is how far apart they really land.
7. Repeat anything that failed. One failure is a data point and three failures in the same place is a fault, and the difference matters enormously when you are deciding whether to open a controller.

If a single button never registers at all rather than failing only in combination, that is a different problem and the button test is the faster page for it, since it checks each input on its own without the load of a combination on top.

What Each Mode Is Actually Looking For

Free press

No prompts, no scoring, everything logged. Press whatever you like and watch the grid, the counter and the timeline. This is the mode for confirming your suspicion in ten seconds, and it is the one to use when you want to show somebody else what your controller is doing rather than describe it.

Add one more

The rollover ladder. You hold one button, then keep it held and add another, and another, building the stack as far as your hands allow. The tool records the highest number that were genuinely reported together. On a healthy modern controller you will run out of fingers long before the pad runs out of capacity, and that is exactly the result you want.

Combination check

Counting is not the whole story. Some faults are not about how many buttons you hold but about which ones, because certain pairs share wiring or sit on the same section of a scanning matrix. This mode names a combination, waits for you to hold it cleanly, then confirms every button in it arrived and nothing else came along. Choose custom in the setup panel and you can build your own by clicking the grid, which is what you want if a specific move in a specific game keeps failing.

Together timing

A different question entirely. Not whether two buttons can be held together, but how far apart they land when you try to press them at the same instant. This is the mode fighting game players care about, and the section further down explains why the answer is more useful than it first looks.

What Rollover Means On A Controller

The word comes from keyboards, where it is a genuinely serious problem and where phrases like six key rollover and n key rollover appear on every product page. It is worth understanding the keyboard version first, because the controller version is a much smaller problem for a specific and interesting reason.

A cheap keyboard wires its keys into a grid to save on components. Instead of a wire per key, rows and columns cross, and each key sits at an intersection. The controller scans the grid rapidly and works out which intersections are closed. That works beautifully until you hold three keys that form three corners of a rectangle, at which point the fourth corner also reads as closed, because current has found a path around. The keyboard reports a key you never touched. That is ghosting, and the usual fix is for the firmware to refuse to report anything at all when it detects the pattern, which is blocking. Either way an input you wanted has gone missing. If you want to see this happen on your own keyboard rather than take my word for it, the keyboard test will show you the moment it does.

Controllers mostly sidestep the whole problem. There are far fewer inputs, usually seventeen or so rather than a hundred and four, and there is plenty of room on the microcontroller to give each one its own pin. No shared grid means no rectangles and no phantom corners. The standard browser gamepad interface reinforces this, because it hands over the state of every button on every poll as a simple list, with no concept of a limit on how many can be true at once.

So on a first party controller plugged in with a cable, the honest expectation is that this test passes completely and you learn nothing except that your pad is fine. That is a real result and it is worth having in writing. The interesting cases are the ones underneath.

Where Rollover Problems Genuinely Turn Up

Five situations account for almost every real failure, and none of them involve a normal controller connected normally.

Adapters and converters

By far the most common cause. A box that lets a PlayStation pad talk to a Switch, or an old controller talk to a modern PC, has to translate one protocol into another in real time. Cheap ones cut corners, and one of the corners they cut is how many simultaneous inputs they carry through. Four buttons work, six work, and the seventh is silently discarded. If you use an adapter, test with it and then test without it, because that comparison alone usually settles the question.

Very cheap third party pads

The ones sold as a two pack for the price of a coffee do sometimes use matrix wiring, exactly like a budget keyboard, because it genuinely saves a little money. When they do, they ghost and block in the same way and the pattern is just as reproducible. The combination check is the mode that finds this, because matrix faults are about specific groupings rather than about a count.

Wireless under load

Not a rollover fault at all, but it looks identical from where you are sitting. A dropped packet at the moment you add the sixth button means the sixth button never arrives. The distinguishing feature is that it will not reproduce. A genuine rollover limit fails the same way every single time, while a radio problem fails once, then works, then fails somewhere else. If your failures move around, the connection stability test is a much better use of your next five minutes than this page.

Software sitting in the middle

Steam Input, DS4Windows, reWASD and vendor apps all intercept your controller and re-present it. Any one of them can be holding a remap, a macro, or a chord that consumes a combination before it reaches anything else. If a combination fails here but works elsewhere, close everything in between and test again. Watching the raw indices arrive in the controller mapping tool is the quickest way to confirm what your pad is really sending underneath all that.

Worn contacts under mechanical load

The least obvious one, and the only one where the controller itself is genuinely at fault. Pressing several buttons at once flexes the board and the rubber membrane slightly differently from pressing one. A contact that is already marginal can lose connection under that flex and recover the moment you let go. It presents as a button that works perfectly alone and drops out in company, which is why the dropout counter on this page exists.

The Three Ways It Fails

They get bundled under one word and they mean different things, so it is worth being able to name what you are looking at.

Blocking is an input that never arrives. You hold five buttons and the tool shows four, and the missing one stays missing for as long as the other four are down. This is the firmware refusing to report something it cannot resolve, or the hardware genuinely being unable to see it. Blocking is consistent and reproducible, which is the good news, because it means you can characterise it exactly.

Ghosting is an input that arrives without you. A button lights up on the grid that your hands are nowhere near. This is the rarest of the three on a controller and the most diagnostic when it happens, because it points squarely at matrix wiring. The combination check counts these as phantom inputs, since that mode is the only one where the tool knows which buttons you were asked to hold.

Dropping is an input that arrives, leaves, and comes back while you are still holding it. Your finger never moved. This is the mechanical one, and it is the one that ruins you in games without ever looking like a hardware fault, because everything works when you check it afterwards. The tool catches it by watching for a button that switches off and back on faster than a human release and re-press could manage, which is what the dropout window setting controls.

The practical difference is what you do next. Blocking and ghosting point at the wiring, the adapter or the firmware, which means the fix is usually a different cable, a different adapter or a different controller. Dropping points at a contact, which means cleaning is worth trying and often works.

Reading Your Numbers

Most held at once

The highest number of buttons the pad reported together at any point. On a healthy controller this number is limited by your hands rather than your hardware, and most people top out somewhere between six and ten depending on how they hold the pad. What matters is not the number itself but whether it stopped climbing while you were still adding fingers. Eight is a great result if eight is all you tried, and a bad one if you had ten down.

Dropouts

Buttons that switched off and straight back on while you were holding them. Zero is what you want and zero is normal. Even one is worth a second run, because a single dropout can be a genuine slip of the thumb and a repeated one on the same button is a marginal contact. This number is the one to watch on an older controller, because it is where age shows up before anything actually dies.

Phantom inputs

Buttons that registered during the combination check without being part of the combination. Anything above zero here is unusual on a controller and worth taking seriously, because it means an input is being generated rather than merely lost. Check that your hands really were clear of the grid first, since a resting thumb on a bumper accounts for more phantom readings than faulty wiring ever will.

Combinations passed

How many of the checked combinations registered completely and cleanly. A failure here with a healthy count from the ladder mode is the signature of a matrix problem, because it means the pad can carry the load in general but not this particular grouping.

Typical press gap

The middle value from your together timing runs, in milliseconds. This is partly your hands and partly your hardware, and the next section explains how to tell which is which.

The Together Timing Number, And Why It Is Not Just About You

Ask somebody to press two buttons at the same time and they will get within about ten to thirty milliseconds of themselves. That is a human number, not a controller number, and most of what this mode measures is you. Which raises a fair question about why it is here at all.

It is here because of the shape of the results rather than the average. Press two buttons together twenty times and plot the gaps, and a healthy setup gives you a spread centred near zero, with roughly as many runs where the left button landed first as where the right one did. Your hands are imprecise in both directions equally.

What you are looking for is a bias. If one specific button lands second almost every single time, that is not your hand, because your hand does not have an opinion about which finger is slower in a way that survives twenty attempts. A consistent one sided gap means one of those buttons is genuinely slower to register, which usually means a contact that needs more travel before it closes, or a trigger being read through an analog threshold rather than as a simple switch.

The second thing to look for is a small number of enormous outliers. Nineteen presses land within thirty milliseconds and one lands at two hundred. That is not a slow contact, that is an input that went missing and then turned up, and on a wireless pad it is almost always the link. The gap histogram makes both patterns obvious at a glance, which is the entire reason for drawing it rather than reporting an average.

Worth knowing that the tool cannot see anything faster than one display frame, which on a 60Hz screen is about sixteen milliseconds. Two buttons that genuinely arrive four milliseconds apart will be reported as landing together. That is a real limit and it means this mode is good at spotting a consistent bias and useless for measuring true simultaneity. If the total delay between your thumb and the screen is what you actually care about, the latency test measures that directly instead.

What Counts As Normal

Two pieces of context that stop people worrying unnecessarily. First, the number of buttons you can hold is genuinely limited by hand shape, and reaching only seven does not mean your pad stops at seven. Enlist a second pair of hands if you want to push the ladder properly. Second, on a controller with analog triggers, those triggers have to cross a threshold before they count as pressed, so they will almost always look slightly slower in the together timing test than a face button does. That is the mechanism working as designed rather than a fault, and the trigger pressure test shows you where your own threshold actually sits.

Where This Actually Costs You Something

A rollover limit is invisible in a lot of games, because a lot of games never ask for more than three inputs at once. It becomes expensive in a handful of specific places.

Shooters with a full loadout. Aim, sprint, crouch, direction, and then fire or jump on top. That is five or six inputs live at the same moment, and it is the most common real world load anybody puts on a controller. If something is going to drop, this is where you will feel it, and you will feel it as an occasional jump that did not happen rather than as a hardware fault.

Fighting games. Multi button inputs are not optional here. Grabs, three button macros, dashes and defensive options are all built on two or more buttons landing in the same frame, and a pad that splits them across two frames turns a grab into a single attack. This is the genre where the together timing mode earns its place, and it is worth running before you conclude that your execution is the problem.

Flight and driving games with modifiers. Holding a shoulder button to shift a whole set of controls onto other buttons means the modifier and the target are always down together, plus whatever else you were already holding. Long modifier chains stack quickly.

Anything with a radial menu. Emote wheels, quick chat and weapon wheels are almost always a held button plus a direction plus a confirm. Three inputs is not demanding, but the combination is fixed, so if that specific grouping is one your pad struggles with, it will fail every time and feel like the game rather than the controller.

Accessibility setups and macros. Any remap that puts several actions on one physical press is generating a combination that never existed as far as the pad is concerned. Worth testing deliberately if you rely on one.

What To Do About It

Start with the things that cost nothing

• Remove the adapter and test the pad directly. If the limit disappears, you have your answer and no amount of work on the controller will help.
• Switch from wireless to a cable and repeat the failing combination five times. Consistent failure is hardware, intermittent failure is the link.
• Move to a rear motherboard port, off any hub. Underpowered ports cause stranger symptoms than people expect, and a hub sharing bandwidth with a webcam is a real source of dropped input.
• Close Steam Input, DS4Windows, reWASD and any vendor software, then test again. A macro or a chord you set up months ago can eat a combination without ever announcing itself.
• Charge the pad fully. A controller running low reports less reliably, and the battery health test is a quick way to rule the pack out rather than guess at it.

If it is dropouts

Dropouts under load are the one failure here that responds to cleaning, because the cause is a contact that is marginal rather than dead. Opening the controller, wiping the board contacts and the conductive pads on the rubber membrane with isopropyl alcohol, and letting everything dry fully resolves a good share of them. The teardown steps and the safety notes in the controller repair guide apply directly, since getting to the button contacts is the same disassembly. If cleaning helps for a week and the fault returns, the membrane has worn and replacing it is cheap and needs no soldering.

If it is blocking or ghosting

There is no repair for matrix wiring, because the limitation is designed in rather than worn out. Your options are remapping around the combination that fails, or replacing the controller. Remapping is a real option and worth trying first if only one grouping is affected, since moving a single action to a different button costs nothing and takes a minute.

If nothing reproduces

A failure you cannot reproduce is usually not a rollover problem. Look at the connection, look at the port, and look at whether the pad reports consistently in the first place. The polling rate test tells you how often your controller actually reports, and a pad reporting erratically will fail this page in ways that have nothing to do with how many buttons it can carry.

Method And Honest Limits

What the browser can see

This page reads the list of button states your browser exposes and counts how many are true at the same instant. There is no limit built into that interface, so anything this test finds is a limit in your controller, your adapter, your driver or the software in between. That is a genuinely useful property, because it means a failure here is real rather than an artefact of the page.

Sampling

Readings arrive in step with your display refresh, so a 60Hz screen gives about sixty a second and roughly sixteen milliseconds between looks. Everything timed on this page inherits that resolution. It is plenty for counting simultaneous holds and spotting dropouts, since those last far longer than one frame. It is not enough to measure true simultaneity, and the together timing numbers should be read as frames rather than as precise milliseconds.

The tool cannot read your intentions

In add one more mode, the page has no way of knowing whether a button disappeared because you released it or because the controller dropped it. That is why the dropout detector looks for the specific pattern of a button vanishing and returning too quickly for a human to have done it deliberately, rather than flagging every release. In combination mode the tool does know what you were asked to hold, which is why phantom inputs are only counted there.

Analog triggers behave differently

On most controllers the triggers are analog and count as pressed once they cross a threshold. That makes them slightly slower to register than a digital button and it means a very light pull may not count at all. Pull them properly for this test. If a trigger behaves oddly in combination but fine on its own, the adaptive trigger test is worth a look on pads that have variable resistance, since a trigger fighting back changes how hard you actually press.

Run each mode more than once

A single failure proves very little. The whole value of this page is in whether a failure reproduces, because a reproducible fault can be characterised and fixed while an intermittent one is usually something else entirely wearing a disguise.

Browser And Platform Notes

• Chrome and Edge map controllers most predictably. Firefox works but sometimes places buttons on different indices for the same pad, so check the grid matches your controller before drawing conclusions. Safari is the least consistent of the three.
• Keep this tab focused. Background tabs get throttled and inputs stop being sampled, which will cost you a peak.
• If the grid stays empty, the browser may not see the device at all rather than the pad being faulty, and the controller checker confirms that in a couple of seconds.
• Third party pads with an XInput and DirectInput toggle, usually reached with a button combination involving Home, often expose completely different button indices in each mode. Test in the mode you actually play in.
• Watching the values live while you flip a setting is easier in the gamepad viewer, which is useful when you are trying to work out whether software in the middle is changing what arrives.
• Everything runs locally in the page. Nothing about your controller or your results leaves your device.

Questions People Actually Ask

How many buttons should a controller handle at once?

All of them. A normal controller gives every button its own connection rather than sharing a grid, so there is no designed limit and you will run out of fingers first. If you find a hard ceiling below six, something between your hand and the browser is imposing it.

My count stopped at seven. Is that a fault?

Almost certainly not, it is your hands. Seven is about where most people run out of reachable buttons while holding a pad normally. Get somebody to press a few more with you before you conclude anything, or use the combination check instead, since it tests specific groupings rather than raw count.

Is this the same thing as keyboard rollover?

Same idea, very different odds. Keyboards genuinely suffer from it because a hundred plus keys get wired into a grid to save cost. Controllers have around seventeen inputs and plenty of pins, so the grid is usually unnecessary. Cheap pads and cheap adapters are the exceptions, and they fail in exactly the way a budget keyboard does.

A button drops out only when I hold three others. What is that?

Usually a marginal contact rather than a wiring limit. Holding several buttons flexes the board and the membrane slightly, and a contact that is already borderline loses connection under that flex. Cleaning is worth trying because this specific fault responds to it.

Why does my trigger always look slower than my face button?

Because it is analog. It has to travel far enough to cross a threshold before it counts as pressed, while a face button closes a switch almost immediately. A consistent lag of a frame or two on a trigger is the mechanism rather than a fault.

Everything passes here but I still lose inputs in game.

Then the controller is probably not the problem. Look at what sits between it and the game, meaning remapping software, an overlay, or the game engine dropping inputs on a frame hitch. A pad that passes this page is reporting everything correctly to the browser, and the browser is not doing anything special to receive it.

Does an adapter really cause this?

It is the single most common cause of a genuine rollover limit. Test the same controller with and without the adapter and compare the two reports. If the limit only exists with the adapter in the chain, no work on the controller will fix it.

Does the tool work on a phone or tablet?

Yes, with a controller connected over Bluetooth or through an adapter. The grid, the timeline and the histogram all scale down. Bear in mind that testing over Bluetooth makes it harder to separate a dropped packet from a genuine limit, so treat a failure as a prompt to retest wired rather than as a conclusion.