What influences keyboard input speed

While everybody is focused on mouse lag, there’s little attention to keyboard lag. I’m going to explain to you why keyboard input latency matters, what influences it, and what you can do about it.

Why keyboard input latency matters

You know that argument that people used to have about 30 fps versus 60 fps? “The human eye can’t see the difference” and you don’t need more than 30 frames per second. By now you know better.

That’s because people can perceive latencies down to 2ms or less. Moreover, the increased latency can also influence your accuracy. If you then realize that modern keyboards can still have a delay up to 60ms, you might want to be a bit more careful with your next purchase.

CRT screen counterstrike

If you’re a competitive player then this is a no-brainer. You need to have the shortest input delay possible. You’ll see competitive CSGO players using expensive 120hz+ or old CRT screens, the most praised mouse (sensor) and complain about server tick rates or tweaking game settings for the least input latency. But they never stop to consider that keyboard lag is the biggest enemy of them all.

I’m not talking about any Windows software tweaks, or the perception that USB polling is a limiting factor that frequently appears in the CSGO community.

I’m talking about the actual keyboard hardware, because that’s where the real input lag starts.

Gaming keyboards

Don’t be fooled by any marketing you see out there. Gaming companies like to make wild claims that are either deceptive or blatantly wrong.  Just so that they can tell you exactly what you want to hear, not what you get.

If a product has “gaming” in its title these days, it’s for marketing, an excuse for its ridiculous design and RGB effects. It definitely doesn’t mean it’s optimized for (competitive) gaming.

Input latency versus input accuracy

There’s a difference between the input latency and accuracy of a press. If you only need the fastest reactions, you’re looking at getting the least input lag. If you only need consistency in repeated presses, you’re looking at getting the best accuracy.

In Rhythm games, like OSU, you want the fastest input speed, but also the highest accuracy. Each action in OSU has a 80ms time frame to react or less for a perfect 300 score. This needs to account for your reaction time, movement, and input lag.

Your reaction time will likely consume the most, and the best way to combat it is by tapping at a rhythm and knowing exactly what’s going to come next. That’s why practice makes perfect.

You can increase your accuracy not only with the shortest input delay but also by coupling the point of most impact with the point of activation.

I’m going to focus solely on input latency from here on out.

The parameters of input

Before we step into what exactly influences the input latency, I’m going to dissect the steps a keyboard takes for an input to PC. It’s an oversimplification that only takes the main and most easy digestible parts.

  1. Key input is the actual physical press of the key.
  2. Scan rate is the frequency at which the keyboard microcomputer chip (MCU) reads the keys.
  3. MCU processing is the time it takes for the microcontroller (MCU) to process the input.
  4. USB polling is the frequency at which the PC checks for input from the keyboard.
  5. PC software is the time your operating software (OS) and the particular program/game your using needs to process the input.

Input latency influence factors

Now that you understand the journey of input latency, it’s time to look at what can influence it at a digestible level.

Switch travel distance

Switch travel distance influences step 1, Key input. Travel distance can have a huge impact in reaction time. According to a project about keyboard latency by Dan Luu, travel time can account up to 10ms. This is not taking into account any adjusted behaviour to minimize travel. Such as pre-loading and not pressing till the end.

In short, you could say a combination of the shortest travel distance and highest actuation point will result in the fastest key input. Also when you repeat a key press, any travel after the actuation point is wasted time.

This means that a switch type like scissor-switch with a 1~2.5mm travel distance will often have the fastest physical key input.

To put it in a plain comparison:

Switch type Travel distance Typical actuation point
Scissor-switch 1~3mm At end
“Low-profile” mechanical switch ~3mm 1.2mm
Rubber dome 3.5~4mm At end
Memchanical 4mm At end
Mechanical switch ~4mm ~2mm

But be aware, when a keyboard has rubber-dome type of switches, and any laptop with scissor switches. These are often coupled with a membrane computer board, which you should avoid at any cost if you’re into the least latency with the most reliability.

There are switches specifically made for faster key input, such as the Cherry MX speed switches. They actuate at 1.2mm and travel up to 3.4mm.

Then there are unique type of keyboards that allow you to adjust the actuation point. At time of writing, limited to the Wooting one using modified Flaretech Prism switches and Topre Realforce RGB using Topre switches.

The Topre keyboard has 3 different actuations at 1.5, 2.2 and 3mm and the Wooting keyboard can be adjusted anywhere between the 1.5-3.6mm.

It’s arguable that a higher actuation point might not be very practical at all times. You’ll accidentally press a key and experience a frustrating time typing. So it’s important to take this in consideration.

Keyboard Scan Matrix

Every key on the keyboard is connected to the MCU, the brains on the keyboard. But there’s a limit to how many connections you can make to a MCU, let alone that it’s very impractical to literally connect numerous keys. That’s why there’s a thing called a scan matrix.

A scan matrix are all the keyboard keys divided in a grid layout, so you will only need to connect the rows and columns instead of every key itself. It’s like a chess board that uses alphabetical columns and numbered rows to determine a chess piece location.

By making only 16 connections (8 rows, 8 columns), it’s able to read 64 keys. Just enough for a 60% keyboard.

In terms of input latency, a matrix layout is not ideal because it’s an extra layer of complexity. It’s vunerable to ghosting and terrible non-optimized engineering. The often misinterpreted ghosting and related key-rollover do not directly influence input latency. But It’s a tell-tale for the quality of engineering and where costs were saved. A topic for another time.

It’s near impossible to find a keyboard that doesn’t utilize a matrix layout. You rely on the manufacturer to make the most effective matrix layout that doesn’t compromise input latency for lower cost.

Wooting keyboard scanning

Scanning with a matrix layout is limited to a digital signal. It doesn’t actually read the key input itself, but by logic decides if it’s either ON or OFF.

The Wooting one needs to read every single key analog signal for analog input. Therefore it can’t rely on a matrix layout. But connecting every key to the MCU is extremely inefficient.

That’s why all the Wooting one keys are divided in 6 rows, each row connected to a multiplexer. The multiplexer is a nifty component that can connect multiple keys with a single connection to the MCU. It’s like a network switch that allows more devices to connect to your router.

You don’t often see it in a keyboard, because it’s a more expensive solution than a matrix layout.

A direct connection between a key and the MCU is optimal for the least input lag.

Keyboard scan rate

Ever wondered how a keyboard knows you pressed a key? You would expect that pressing a key would send a signal to the MCU that it’s pressed, similar to how a PS/2 connection works. But in fact, it’s more similar to USB polling.

The MCU will check all the keys every x amount of time for input. It’s literally asking every key, “hey have you been pressed yet?”. This is referred to as the keyboard scan rate.

Scanning frequency

The keyboard scan rate can happen at different frequencies, often referred to as an x amount of hertz (Hz), just like the USB polling rate. A scan rate of 1000hz is equal to 1ms. This means that the MCU will check every key, every 1ms for input.

In theory, if a key is pressed faster than the scanning rate, it won’t be detected. But in reality that’s near impossible to achieve unless you’re dealing with a real junk keyboard.

Instead, during the time that the key is in its “on” state the keyboard scan will cycle by and pick it up. The moment the keyboard scans will never be in sync with the exact moment you activate a key.

This means that once you activate a key, it needs to wait for the next scan cycle to pick it up. This adds a delay variable. The lower the frequency, the longer the cycles, the longer the input lag.

Common frequencies:
• 125hz / 8ms
• 250hz / 4ms
• 500hz / 2ms
• 1000hz / 1ms

A lot of keyboard manufacturers don’t bother to implement a scan rate of 1000hz. It takes a higher toll on the MCU and they will argue that there’s switch debounce time. But in fact, a faster cycle means that in all cases the key will be picked up faster in its next cycle.

Switch Debounce Time

Inside a mechanical switch when the two metal contacts touch each other, it has an unstable signal caused by the impact vibrations of the contacts. This is called bouncingDebouncing is any kind of hardware or software that ensures that the signal is stable enough to read.

Often a software solution is used. The keyboard firmware will delay reading the key until the signal is stable enough. If the implemented delay is not long enough, you will get multiple inputs from a single key press, also known as key chatter.

Depending on the quality of the switch, the bouncing time will vary. The most popular Cherry MX switches have a bouncing time of up to 5ms. This means the software delay should at least be 5ms or higher.

In reality however, the manufacturer will often add a longer software delay because the switches will corrode over time and require a longer debounce time. A longer debounce time also helps them reduce the amount of defects.

Afterall, 100+ switches are installed on every single keyboard, if even one of those switches has chatter, the entire keyboard has to be returned. That’s a costly expense.

To put things into perspective.

If you buy an extremely cheap mechanical keyboard from Amazon, you can expect the following:

  1. The switches are from an unknown manufacturer with unknown quality.
  2. The switches were not sorted and tested for key chatter.
  3. The keyboard firmware has a very high debounce time to compensate for above.

It’s also no wonder that there isn’t a single keyboard manufacturer that will openly talk about it.

The Wooting one uses Flaretech optical switches, these have a bouncing time of 0.03ms. The Wooting one scan rate is 1000hz (1ms) and, therefore, isn’t limited to the switch bouncing time.

It’s very common for manufacturers to tout 0.2ms input latency, while in reality this only accounts the switch bouncing rate and says nothing about the actual input latency.

There are also other switch technologies with low bouncing times, but you better stay clear with anything that has a membrane computer board, like rubber dome keyboards. If you value input latency, stay clear of this. Just no.

MCU Processing Time

Your keyboard has a little chip inside called a microcomputer chip (MCU). It’s just like your computer central processing unit (CPU). It has the task to process every input into a keyboard firmware defined output.

A faster MCU can handle more processes at the same time and make calculations faster. But it’s also heavily dependent on how efficient the firmware code is written. It’s similar to how you can have the exact same gaming gear (the MCU) as a professional gamer (the firmware code), but perform nowhere as good because you’re not as efficient and effective as the pro.

Then you also have to consider that if the MCU is loaded with a lot of processes at the same time, it will slow down every other process including input latency.

Running a RGB effect/animation can take a great toll on the MCU. It requires a lot of processing power and will delay other processes. Just like when you play a game with extreme graphics while live-streaming, your CPU will get overloaded and significantly decrease your frames per second.

Better turn off those RGB effects.

USB polling versus PS/2 interruption

The connection to the PC is another point of input lag. These days all keyboards use a USB connection, previous generations used PS/2. These two connections inherently work different.

PS/2 is an interrupt type of connection. The keyboard will send a direct signal to the computer CPU interrupting any action it’s performing and tells it to execute the key input.

USB is a polling type of connection. The CPU will check every x amount of ms for input, just like the keyboard scan rate.

The theory is that PS/2 interruption is a faster input connection than USB polling. But in practice this doesn’t have to be true anymore. It’s very hard to find any PS/2 compatible keyboards and computers these days. Even if you make use of a keyboard that has it, it doesn’t guarantee it’s faster than USB polling. Modern motherboard designs and CPU’s aren’t optimized for legacy connections, such as PS/2.

You can reread the keyboard scan rate section to further understand how USB polling works. It also applies to the connection to the PC.

In short:

  1. 125hz (8ms) /250hz (4ms) /500hz (2ms) /1000hz (1ms) are the most common frequencies that USB will scan.
  2. Always aim for 1000hz (1ms) polling
  3. Input lag occurs when a sent signal is not in sync with the scan. It will have to wait for the next scan cycle before it’s sent.

Computer OS and Application software

Welcome to the biggest variable ever. If you read the MCU processing time section, then this same theory applies to your computer operating system (OS). When it receives the input it needs to process it to an output. Afterward, the application you’re using will process it to an output.

This part entirely depends on the efficiency of the software code and how it handles input. In general, the less your CPU is burdened, the faster the input can be processed.

The difference in input will widely differ depending on the application you’re using. That’s why it’s not only the task of your input device to be fast, but also the developer. A developer can make a huge difference in input speed by writing optimized code and increase the input cycle.

Monitor refresh rate

Update 2019-10: We’ve been informed that the monitor refresh rate is not the full picture. On modern monitors the display needs to process the frames sent from the computer, which is a big factor in the total input lag. Since this article is focussed on the keyboard part we will refer to this excellent website for the full picture on monitor input lag: https://displaylag.com/display-database/. Credits to Tyler for pointing this out.

Your monitor refresh rate doesn’t directly influence your input latency, but it does influence the moment you will visually see the input. This indirectly adds to the latency and will influence your response.

You can find (gaming) monitors ranging from 60hz up to 240hz refresh rate. This means that the monitor is capable of refreshing the graphics from 60 up to 240 frames per second (fps). Though, your computer might not be able to reach 240 fps in the majority of games.

The most common monitors have 60hz refresh rate. That’s 60 frames per second, 1 frames every 17ms. If your moment of input comes in at the start of the refresh cycle, it will need to wait 17ms before you’ll see it. In average, the input lag caused by a 60hz monitor will be 8.5ms.

On a 240hz monitor, with the ability to run a game at 240 frames per second, the input lag will average 2ms.

You can also calculate how much input lag your monitor causes.

1 / Game FPS * 1000 = maximum delay in milliseconds. If you divide it by 2, you’ll have the average.

How Wooting measures input latency

At Wooting we take input speed optimization very serious and are continuously pushing the limits but there are some limitations to what we can measure ourselves. We’re focused on what happens on the keyboard.

We use an oscilloscope to measure the frequency of the keyboard scan rate. This device can measure electric signals that vary over time. This is also how we can measure the latency with high accuracy. We have a bit more modern oscilloscope you can connect to your PC.

The oscilloscope is connected to 1 of the 6 rows in the Wooting keyboard, when a scan happens it will trigger the electric signal. After the first row, it will scan through the 5 other rows and start back at 1 again. So to measure the scan rate, which is how fast the entire keyboard is scanned for input, we calculate the time in between two triggers on the oscilloscope.

As you can see from the test results above, there’s a stable and frequent electric trigger happening every 0.96 milliseconds (ms). It’s expressed in 960 microseconds on the test result.

This means that the keyboard scan rate is just under the 1ms (0.98ms) or at a 1000hz polling rate.

This however only takes the scan rate into account and not any of other mentioned influence factors.

We are working together with several parties to get accurate and more in-depth input latency results.

For instance, there’s a researcher, Sunjun Kim, that had tested the Wooting one from keyboard input signal to the PC receiving it within 4.2ms. He was also able to deduct the keyboard scanning + MCU calculation time to 2.5ms.

Testing tools on the PC are not reliable

As a final note to input latency and their influence factors. You can’t rely on software tools from the internet or PC to accurately measure input latency. These tools will only be able to measure the latency on the PC itself and are not capable of testing input lag on your device.

For the most accurate measurements, you’ll need to rely on external devices that monitor events coming from the device.


You’re welcome to leave feedback or contribute to this post. If you have more information, references or want to challenge some of the ideas mentioned, leave a comment behind or reach out to social@wooting.nl

I also have to mention that this post didn’t go into extreme depth, to keep it light and easier to understand.

Calder Limmen Written by:

Co-founder & CEO at Wooting.


  1. June 14, 2018

    Thank you for the excellent post

  2. July 22, 2018

    You guys got Sunjun Kim’s result wrong. The twitter post you linked says his measurements were 4.2ms of full-chain latency, and about 2.5ms of MCU latency.

    • S34MH1
      May 12, 2022

      2.5ms?Only 400Hz?

  3. This is very helpful as knowing this will help in gaining knowledge about this important thing. As the keyboard is one of the most important components of the computer this tips will be useful while using it and boost up its speed.

  4. Ben
    December 6, 2018

    Is there a way you can send me the specs comparison of the wooting keyboard to a k55 rgb keyboard from corsair. I was wondering if i should invest in this keyboard or not.

    • December 10, 2018

      What type of comparison are you looking for. If it’s an input speed comparison, then I don’t have those type of results. This is focused on the influence factors, so it’s easier to look through the marketing.

  5. Vic
    December 9, 2018

    Good to know I bought the right keyboard!
    I have to use a usb 3 dock to connect my monitors and eveything so I guess this probably slows down my scan/send rate anyway. Am I correct?

    • December 10, 2018

      I can’t tell with 100% certainty without testing it. But in theory, you created a bottleneck by adding another layer of USB polling. The followup question would be, how much data it can process simultaneously and if it throttles data for the next polling cycle, which depends on the quality of the dock device.

      You’ll always be sure that you’re working at optimal speed when connecting the device directly in your motherboards USB ports (usually on the back of the pc).

  6. January 17, 2019

    You could possibly make use of the other two options – live chat and e mail – for
    unpublished places.

  7. Jay Lee
    April 24, 2019

    Thanks for the explanation! Glad to see you guys are continuously innovating & improving your products and software. The addition of features such as Tachyon mode is a cool concept and I cant wait to see what you do next.

  8. ahmed
    June 13, 2019

    what is the actuation point for the Tachyon mode is it in the bottom or top of the travel its not clear

  9. Ash
    October 18, 2019

    Awesome! Bookmarking this post. Could you update the post or make a new one regarding Wooting Two’s specs? Thank you

    • October 21, 2019

      Wooting two spec it’s the same. We apply the same to all our keyboards.

  10. Viric
    February 8, 2020

    Thank you for the article. I miss there a comment about a disgrace related to slow sampling frequency: pressing two letter keys close enough in time makes the keyboard not know what key was pressed first.
    If you type fast it is really annoying.

    I’d say that many cheap keyboards will fail at fast typers.

    One test you can do is to drop two fingers over two keys almost at once, knowing which you press first, repeatedly. Then do the same changing which you pressed first. And you will find that the keyboard takes a decision of order not based on arrival time, when close enough.

  11. Viric
    February 8, 2020

    And I’d like to mention another disgrace of cheap USB keyboards: they may claim 2KRO. It’s known that 2KRO is a must for a fast typer – two keys or even three at once can come easily and the keyboard should be able to keep up with them.
    In theory, 2KRO means “you can press any two keys at once and they will be recognized without jam, modifiers apart”. But most keyboards (like Logitech K120 or Cherry Stream 3.0 or many others) do not considers modifiers apart. Therefore, for many letters, keeping shift pressed makes the letter part of the keyboard 1KRO – and that’s pretty bad for a fast typer. Keystrokes will be forgotten by the matrix jam and even sometimes a poor antighosting firmware will produce the scancodes in wrong order.

    I wish keyboard manufacturers would tell their scanrate and provide 2KRO free of modifiers, and travel distances, actuation points, etc. But often the technical specs of a keyboard will not say a word about that.

    I personally have no interest about gaming but I find every keyboard I try poor about fast typing.

  12. gyrados
    December 22, 2020

    >PS/2 is an interrupt type of connection. The keyboard will send a direct signal to the computer CPU interrupting any action it’s performing and tells it to execute the key input.
    Meaningless. The OS can decide to handle it whenever it wants. I plugged a PS/2 keyboard recently into a Windows 7 box and the polling rate was around 80Hz, even worse than the default of USB keyboards (125Hz?).

  13. gyrados
    December 22, 2020

    Wait, I remember, it was a PS/2 mouse. And the cursor moving around was noticeably choppy than a typical default mouse (at ~125Hz).

  14. StrictNon-Comformist
    January 25, 2021


    You are correct: the data/state may very well end up getting stored in main memory from I/O as the bare minimum latency, executed in an Interrupt Service Routine to prevent data from being lost. Inside the interrupt the guidance is always to do as little as required with interrupts disabled, such that you can then have any higher-level processing take place at a lower priority. I believe this is something all major desktop/server OSes have in common, where as little as possible is done with interrupts turned off, leaving a note for lower-priority handling systems to handle higher-level (getting data to a particular process, or all other stuff). In Windows this is what’s known as a Deferred Procedure Call.

    How long between the ISR queueing the bare minimum amount and this DPC is completed? That”s determined by all threading priorities of the OS and what has higher priorities. It is incredibly variable. That’s just at the kernel level itself. In Windows, once the data from an I/O device is processed by the kernel, then it needs to alert the necessary user space processes waiting on that data. Yup, still more unpredictable latencies. If the process scheduled to receive it isn’t currently paused with a thread only pending on that input, but it is instead doing other processing, it doesn’t matter how fast your machine is or how many cores it has or total CPU usage on the cores: you’re still waiting for the interaction of the system scheduler and your application, which may (depending on how the data goes through from the kernel to user space applications) have filtering steps applied: Windows message hooks are one example of that, installed in user space, but you can also have device drivers added in the full multilayer device driver stack involved. The driver stack in Windows (and other OSes these days) aren’t limited to running in kernel space for certain things, and in fact, device driver writers are very strongly encouraged to do as little processing in kernel space as feasible, and do the rest in user space, for system stability.

    The practical translation of all that’s involved is the OS has almost no practical chance of losing data from a keyboard and all the other hardware devices, but depending on processing priorities and system load, the latency between input from a keyboard (of any technology) to when the end user application gets it for processing is indefinite: it can be effectively infinite in latency, and that’d still be technically-correct system operation. This can be demonstrated readily by setting enough processes to the highest real-time priority with them not giving up the processor for waiting on things, and try to do something with the system: you get one painfully sluggish system, and it doesn’t matter how many fast CPU cores you have (this can actually work against you) as it’ll still be effectively worthless.

    So, all the Wooting keyboard models can ever hope to accomplish is to be the most predictable and bounded latency link in the chain between the user’s input and it being used in the system, without generating junk keypresses, While I’m not the fastest typist (measured informally at 90 wpm once in IRC on a MacBook Pro butterfly keyboard as my last measurement), and it may very well be I’m limited by the membrane debounce times combined with the tactile issues, I don’t know how much the keyboard affects the latency by itself for slowing my processing down. No desktop gaming OS is real-time by any stretch of the imagination, they’re all full of non-determinism out the wazoo. An old PC running MS-DOS was far more bounded and predictable: this is why Microsoft needed to work hard to create DirectX and related APIs, that got applications closer to the bare metal.

    I regret that for RSI issues I’m not going to be getting a Wooting keyboard because none are ergonomic. I was looking at the upcoming boards with Lekker switches to create a keyboard mouse using the analog keys to remove all reasons to use a separate mouse that requires moving hands off the keyboard to remove a major cause of problems. I write software and advise developers for a living, so precise diagonal mouse control is a rare requirement in my work.

  15. April 25, 2021

    125 hz for a keyboard is enough including competitive gaming. I use 1000hz on mouse and have 144hz monitor.

  16. April 25, 2021

    Instead of worrying abt the useless poll rate of a keyboard many sure your switches are at least Red. That’s way more important. Just having brown over red will slow you down ages because of the tactile bump. And I’m not even gonna mention the blues.

    The refresh rate on a monitor is a different thing where even 200-240hz over 144hz makes difference.

  17. Lester C.
    May 22, 2021

    An issue I see with my PC is that the keyboard will go dead for up to 15 seconds. During that time, some of the keystrokes are lost; and a few of the most recent keystrokes are buffered. Mouse works fine. Happens with any keyboard. Its not malware or the like either. I even did a complete rebuild. I suspect its one of my standard apps that somehow stops USB polling for a moment, Nothing evident in task manager.
    My question is: What is the best way to really troubleshoot this? Any good monitoring tools?

  18. November 11, 2021

    Hello. remarkable job. I did not expect this. This is a splendid story. Thanks!

Leave a Reply

Your email address will not be published. Required fields are marked *