Variable jump height

Tap jump for a hop; hold it for a full jump. Super Mario Bros., Sonic the Hedgehog, and Celeste all do this, by three different mechanisms.

Mario falls under lighter gravity while the button is held¹. Releasing it caps Sonic’s upward speed². Celeste holds Madeline’s take-off speed on a timer, then halves gravity near the apex^3,4.

#How it works

All three games run one loop per update (one frame): gravity reduces the upward speed, and the speed moves the position. The button changes a different term in each.

	Super Mario Bros.	Sonic the Hedgehog	Celeste
Holding	lighter gravity, 0.117–0.156 px/frame² ($1E–$28)5	nothing; one gravity, 0.21875 px/frame² ($38)6	keeps the take-off speed for up to 0.2 s7; half gravity near the apex4
Releasing	heavier gravity, 0.375–0.5625 px/frame² ($60–$90)8, for the rest of the jump1	clamps upward speed to −4 px/frame (-$400)2	ends the hold; the current speed carries on3
Apex, held vs tapped	66–83 px held, 24–29 px tapped9	100 px held, 39 px tapped10	27 px held, 7 px tapped11

Heights are native pixels at the character’s feet, from flat ground, simulated frame by frame in each game’s own number format and update order. An independent re-implementation reproduces every figure (probes/jump-physics/jump-heights.mjs).

Interactive: jump-arc (needs JavaScript)

#Implementations

#Super Mario Bros. (1985)

A jump starts on the frame A goes down while Mario is on the ground¹². His horizontal speed picks a row of four small tables¹³. The rows give three distinct jumps, for standing, walking, and running¹⁴. Each sets a take-off speed of −4 px/frame (−5 running)^15,16, a held gravity, and a falling gravity.

on the frame A goes down while standing:             # CheckForJumping → InitJS
    row      = jump row for |x speed|
    speed    = TAKEOFF[row]                          # px/frame, fraction zero
    gravity  = HELD[row]
    fallGrav = FALL[row]

every frame in the air:                              # JumpSwimSub
    if speed >= 0:                                   # at or past the apex
        gravity = fallGrav
    else if not (A held now and A held last frame) and risen >= HALT:
        gravity = fallGrav                           # released; never switched back
    position += speed                                # ImposeGravity, 8.8 fixed point
    speed    += gravity
    if speed has reached MAX_FALL + 1/2: speed = MAX_FALL

The button never pushes Mario up; it picks only the gravity. Once JumpSwimSub swaps in the falling gravity, nothing swaps it back that jump¹. The swap waits until Mario has risen 1 px¹⁷, which the press frame already covers¹⁸.

Held gravity is 0.117–0.156 px/frame² ($1E–$28)⁵ across the rows; falling gravity is 0.375–0.5625 px/frame² ($60–$90)⁸. For a standing jump, they are 0.125 px/frame²¹⁹ and 0.4375 px/frame²²⁰.

Vertical speeds are 8.8 fixed point, with a third byte for the subpixel position²¹. Falling speed is capped at 4 px/frame²², but the clamp fires only once the speed’s fraction byte reaches $80, as at 4.5 px/frame²³.

Jdaster64’s chart of SMB’s physics engine agrees on the take-off speeds and gravities^15,5,8. It starts the fast jump at a higher horizontal speed than the code; the ledger follows the code¹³.

#Sonic the Hedgehog (1991)

Sonic jumps along the ground’s normal, so on flat ground all 6.5 px/frame ($680)²⁴ goes upward²⁵. The press frame doesn’t move him: Sonic_Jump drops its return address, skipping the rest of the grounded routine²⁶. Curling into a ball lowers his center 5 px²⁷, keeping his feet on the same row²⁷.

on the frame a jump button goes down on the ground:  # Sonic_Jump
    ySpeed -= JUMP                                   # along the ground normal
    curl into a ball                                 # height radius 19 → 14, y += 5
    skip the rest of this frame                      # no movement yet

every frame in the air:                              # Sonic_MdJump2
    if jumping and no jump button held and ySpeed < -CAP:
        ySpeed = -CAP                                # Sonic_JumpHeight
    y      += ySpeed                                 # ObjectFall: old speed first,
    ySpeed += GRAVITY                                # then gravity

One gravity, 0.21875 px/frame² ($38)⁶, applies held or not. The release check runs every airborne frame, before the move²⁸. With no jump button held, it clamps any faster rise to −4 px/frame (-$400)². Gravity brings the take-off speed under the cap in 12 updates²⁹, so later releases change nothing.

Speeds are 8.8 and positions 16.16 fixed point³⁰, and nothing limits the fall³¹. The Sonic Retro community’s Sonic Physics Guide matches the disassembly, down to the release check² and the motionless press frame²⁶.

#Celeste (2018)

Celeste works in pixels per second and multiplies by Engine.DeltaTime every update³². A jump sets the vertical speed to -105 px/s³³ and starts a 0.2 s⁷ timer³⁴.

every update:
    if varJumpTimer > 0: varJumpTimer -= dt          # Player.Update, before the state runs
    # NormalUpdate:
    if airborne:
        mult  = 1/2 if |speed| < HALF_GRAV and jump held else 1
        speed = approach(speed, MAX_FALL, GRAVITY * mult * dt)
    if varJumpTimer > 0:
        if jump held: speed = min(speed, varJumpSpeed)   # up is negative: keep take-off speed
        else:         varJumpTimer = 0                   # release ends the hold, cuts nothing
    if jump pressed and jumpGraceTimer > 0:              # Jump()
        speed = JUMP_SPEED; varJumpSpeed = speed; varJumpTimer = VAR_JUMP_TIME
    moveV(speed * dt)                                    # whole pixels, fraction kept

Holding jump while the timer runs cancels each update’s gravity, so Madeline rises at a constant -105 px/s^33,3. Gravity, 900 px/s²^35,36, applies once the hold ends. Unlike Sonic’s clamp, an early release cuts no speed³.

A separate rule halves gravity while jump is held and her vertical speed is under 40 px/s^37,4. The fall limit is 160 px/s³⁸. Positions are whole pixels, with the fraction kept in a remainder³⁹.

At 60 Hz⁴⁰, the hold nominally spans 12 updates⁷, but the timer is a float and its last update rests on rounding. A 0.0166667 s step gives 11 updates; an exact 1/60 s step gives 12⁴¹, and 2 px more height¹¹. The released code doesn’t set the step. The widget defaults to 0.0166667 s⁴², the likelier value (Coyote time explains why).

#Comparing the arcs

• Super Mario Bros. is lopsided: a long, gentle rise, then a fall under 3.5×⁴³ the gravity (standing). A release bends the rise into an early, steep descent¹. Held jumps peak at 66 px standing, 71 px walking, and 83 px running⁴⁴.
• Sonic the Hedgehog is a symmetric parabola under one gravity⁶. A release cuts the rise to −4 px/frame (-$400)² at once, starting a smaller parabola.
• Celeste rises in a straight ramp while the hold lasts³, then follows a parabola with a flattened top⁴.

#History

#Variants and combinations

Celeste also has coyote time, a grace window for late jumps⁴⁵. Super Mario Bros. and Sonic have none^46,47.