Why does Unity Input.GetKeyDown miss rapid presses?

GetKeyDown is sampled in Update; calling it from FixedUpdate misses presses entirely because FixedUpdate runs at fixed rate and may skip Update frames. Read input only in Update or use the new Input System with performed callbacks that queue events.

How do I queue input events for FixedUpdate to consume?

In Update, set a flag if GetKeyDown returned true. In FixedUpdate, read and clear the flag. Or use the new Input System whose actions queue events automatically and deliver them at every fixed step.

Should I use GetKey or GetKeyDown for held-button checks?

GetKey returns true every frame the key is held; correct for movement. GetKeyDown is true for one frame on press transition; for triggering actions like jump. Use the right one for the use case.

Fix: Unity Rapid Key Press Missed by Input.GetKeyDown

Quick answer: Read Input.GetKeyDown only in Update, never FixedUpdate. To act on input from FixedUpdate, set a flag in Update and clear it in FixedUpdate. The new Input System queues events and delivers them per fixed step.

Here is how to fix Unity rapid key presses that get dropped, especially when reading input from FixedUpdate. The legacy Input class samples keys per Update; FixedUpdate ticks at a different rate.

The Symptom

Rhythm games or twitch gameplay miss inputs when the player taps fast. Single press registers; double-tap may register only once.

What Causes This

Read in FixedUpdate. GetKeyDown returns true only the frame after the press; FixedUpdate may not run on that frame.

Variable framerate. Low FPS means longer Update intervals; presses that complete within one Update are seen as one event regardless of taps.

Legacy Input polling. The legacy Input class polls; new Input System events are more reliable for rapid input.

The Fix

Step 1: Read GetKeyDown only in Update.

private bool jumpPending;

void Update()
{
    if (Input.GetKeyDown(KeyCode.Space)) jumpPending = true;
}

void FixedUpdate()
{
    if (jumpPending)
    {
        rb.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
        jumpPending = false;
    }
}

Step 2: Use new Input System with performed callbacks.

using UnityEngine.InputSystem;

[SerializeField] private InputAction jumpAction;

void OnEnable()
{
    jumpAction.performed += OnJump;
    jumpAction.Enable();
}

void OnJump(InputAction.CallbackContext ctx)
{
    if (ctx.performed) jumpPending = true;
}

Performed callbacks fire on each event regardless of frame timing; rapid taps register reliably.

Step 3: Buffer inputs for forgiveness.

private float jumpBufferUntil;

void Update()
{
    if (Input.GetKeyDown(KeyCode.Space)) jumpBufferUntil = Time.time + 0.15f;
}

void FixedUpdate()
{
    if (Time.time < jumpBufferUntil && isGrounded)
    {
        Jump();
        jumpBufferUntil = 0;
    }
}

150 ms buffer covers physics-Update sync gaps and feels responsive.

Step 4: Test at low framerate. Set Application.targetFrameRate = 30 temporarily. If rapid taps still register, your input handling is robust.

Step 5: For rhythm games, prefer event-driven new Input System. Polling cannot guarantee sub-frame timing accuracy; events do.

“Read input in Update. Use new Input System for rapid taps. Buffer for forgiveness. No drops.”

Related Issues

For Touch input, see Touch Not Firing. For control scheme, see Control Scheme.

Update reads. Flags consumed in FixedUpdate. Or new InputSystem callbacks. Inputs land.