Coyote Time, Jump Buffering and the Invisible Systems That Make Platformers Feel Fair

Play a well-made platformer and a badly-made one back to back, and the difference is obvious long before you could explain it. One feels responsive. The other feels like it is arguing with you.

Usually the difference is not the controls, the animation or the physics. It is a set of small deceptions running underneath, each one designed to make the game agree with what you believed you did rather than with what the simulation strictly recorded.

They have names, and they are worth knowing, because once you can see them you notice their absence everywhere.

Coyote Time

You run off the edge of a platform, press jump a fraction late, and jump anyway.

Strictly, you should not be able to. Your feet left the ground before the input arrived. Coyote time is a short grace window after leaving a ledge during which the game still treats you as grounded — named, inevitably, for the cartoon convention of hanging in the air until you notice the ground has gone.

The reason it exists is that human timing is not frame-accurate and human perception of “the edge” is not pixel-accurate. Without the grace window, a player who felt they jumped in time is told they did not, repeatedly, with no visible explanation. That reads as the game being unfair rather than as their own timing being imprecise — because from the inside, intention and execution feel like the same thing.

Jump Buffering

The mirror image. You press jump slightly before landing, and the game performs the jump the moment you touch down.

Without buffering, that input is discarded — you were airborne, jump is not available, nothing happens. The player, who pressed the button and saw no response, concludes the game dropped their input. Which, technically, it did.

Buffering matters most exactly where the game is hardest, because that is where players press early. Under pressure, anticipation runs ahead of the action. A game without buffering gets progressively less responsive precisely as it demands more precision, which is the worst possible time for it.

Corner Correction

You jump up beside a ledge, clip the corner with the top of your head, and stop dead.

Corner correction detects that near-miss and nudges the character sideways so the jump completes. The player, who was aiming at the gap and believed they had it, gets the outcome they intended.

This one is less discussed than the other two and arguably does more work, because a head-bonk does not just fail — it converts upward momentum into a fall, which usually means dying. The gap between “made it” and “died” can be a couple of pixels of overlap the player could not have seen.

Hitbox Leniency

The shape the game uses for collision is frequently not the shape you can see.

A character’s hurtbox — the region where damage lands — is often smaller than the sprite. A projectile’s hitbox may be smaller than its visual effect. The effect is that near-misses read as misses, which is what the player expected anyway, since they were watching a character and not a rectangle.

The bullet-hell genre takes this furthest, frequently reducing the player to a single tiny point drawn explicitly so you can see it. That is the same idea made honest: the game tells you the real hitbox rather than hiding the leniency.

Why the Numbers Are Not Published

It would be useful to give a table of exact windows per game. Nobody can, honestly, and it is worth saying why.

Studios overwhelmingly do not publish these values. They are tuned by feel over months, they interact with animation and physics in ways that make a single number meaningless out of context, and there is little commercial reason to disclose them.

The notable exception is Celeste, whose developer publicly documented its forgiveness systems — including a jump grace period and pixel-level corner correction — as part of a broader openness about the game’s design. It is cited constantly in discussions of this topic for exactly one reason: it is nearly the only well-known case where the values came from the developer rather than from someone with a frame counter.

Figures circulating for other games are almost always community measurements. Some are careful. They are still inference from the outside, and should be read that way.

Why Invisibility Is the Point

Here is what makes these systems unusual as design: they only work while the player does not know they are there.

A player who has just cleared a jump with coyote time experiences skill. If a message appeared saying grace window applied, the same event would become charity, and the satisfaction would evaporate. The mechanism has to succeed silently or it fails at the thing it exists to do.

That is a genuinely strange property. Most good design announces itself eventually — you notice a clever system and appreciate it. This category is the opposite: its quality is measured by how completely it escapes attention.

The General Principle

Underneath all of it sits one idea that reaches well past platformers: the gap between what a person did and what they meant to do is the designer’s problem, not the user’s.

A player who misses a jump by three frames did not decide to miss it. They intended to jump; their hands were imprecise, as hands are. A system that punishes that is technically correct and practically hostile.

The same reasoning turns up everywhere people interact with software — the undo that catches a mis-click, the search that tolerates a typo, the form that accepts a phone number in whatever format you typed it. All of them are the same manoeuvre: work out what the person meant, and quietly agree with that instead.

Platformers just have the advantage that you can feel it happening in about four seconds.