Super Mario World

On this page

Jumping
Running and the jump
Compared with Super Mario Bros.
Moving in the air
Related
Mechanics
References
Sources

The atlas reads Super Mario World through SMWDisX, IsoFrieze’s disassembly built on mikeyk’s, with most comments by kaizoman666. It assembles all five releases, and the claims cite the code the USA one runs. Every number here was also measured in that ROM, running in Mesen from a new game, on the flat start of Yoshi’s Island 1.

#Jumping

On the ground, a fresh press of B starts a jump and A a spin jump¹. Mario’s horizontal speed picks the take-off speed from a table, −5 to −6.06 px/frame (spin −4.63 to −5.63)². A spin jump takes off slower and climbs 54.8 px held, 28.5 px tapped³.

Variable jump height comes from two gravities, as in Super Mario Bros., but with no switch. Gravity is 0.1875 px/frame² held, 0.375 released⁴, depending only on whether A or B is down that frame, rising or falling. Letting go and pressing again brings the lighter gravity back. Mario falls no faster than 4.375 px/frame (4.1875 holding the button)⁵.

every frame:                                        # player routine, CODE_00CD24
    y += speed                                      # CODE_00DC2D, sixteenths of a pixel
    if on the ground and B or A goes down:          # CODE_00D5F2
        speed = TAKEOFF[|x speed| / 8]              # the spin column for A
    if speed > 0: speed = min(speed, FALL_CLAMP)    # CODE_00D928
    speed += A or B held ? GRAVITY_HELD : GRAVITY   #   negative speed is up

The move comes first, so the press frame doesn’t lift him, and his first step up is the take-off speed plus a frame of held gravity⁶. Measured from a standstill, Mario climbs 64.2 px held, 33.3 px tapped⁷.

Positions are sixteenths of a pixel⁸. Landing doesn’t clear the fraction, so the same jump can draw a pixel higher or lower from one take-off to the next⁸. The heights here are exact sixteenths, given in pixels to one decimal.

#Running and the jump

A faster run picks a faster take-off, and so a higher jump. Held, the jump climbs 64.2 px standing, 72.6 px walking, 81.6 px running, and 85.3 or 91.1 px sprinting⁹. Mario’s top speeds are 1.25 px/frame walking, 2.25 running, and 2.94–3.06 sprinting¹⁰. At a full P-meter his speed wobbles across a step of the table, so a sprinting jump takes off at one of two speeds depending on the frame¹⁰.

#Compared with Super Mario Bros.

	Super Mario Bros.	Super Mario World
Take-off speed	−4 px/frame (−5 running)¹¹	−5 to −6.06 px/frame (spin −4.63 to −5.63)²
Gravity with the button held	0.117–0.156 px/frame² (`$1E`–`$28`)¹², while rising, until the first release¹³	0.1875 px/frame² held, 0.375 released⁴, rising or falling
Gravity without it	0.375–0.5625 px/frame² (`$60`–`$90`)¹⁴, for the rest of the jump¹³	the heavier value, until the button goes down again⁴
Fastest fall	4 px/frame¹⁵	4.375 px/frame (4.1875 holding the button)⁵
Held jump	66 px standing, 71 px walking, and 83 px running¹⁶	64.2 px standing, 72.6 px walking, 81.6 px running, and 85.3 or 91.1 px sprinting⁹
Units	8.8 fixed point¹⁷	sixteenths of a pixel⁸

The two jumps reach much the same heights^16,9. They differ in control: SMB1 swaps in the heavier gravity once, for good¹³, and Super Mario World picks a gravity every frame⁴.

#Moving in the air

Mario steers with momentum. With neither Left nor Right held, he keeps his speed, since the air skips friction¹⁸. Holding a direction accelerates him at 0.09375 px/frame² (0.3125 turning)¹⁹, faster while he still moves the other way. Measured on a running jump: momentum kept; moving the other way 8 frames after the turn, at full speed after 29²⁰. See air control.

Mechanics

Mechanic	Kind	How
Variable jump height	Held gravity	a lighter gravity on any frame the button is held
Jump	Speed from the run	one of eight take-off speeds, by horizontal speed
Gravity	Lighter while held	a lighter gravity on any frame the button is held
Air control	Momentum	the d-pad pushes against the speed Mario carries, and with it released he keeps that speed
Running	P-meter	a full P-meter raises the top speed from 2.25 to 3 px/frame
Hitbox	Points and a box	six points against blocks, and a box against sprites
Invincibility frames	Frame timer	after the power-down animation, 127 frames counted every frame
Mode 7	Rotate and scale	an angle and two scales turned into the matrix with a sine table; Reznor's wheel turns once in 512 frames
Status bar split	Scanline IRQ	in the Mode 7 boss rooms but Bowser's an interrupt at line 36 switches from Mode 1 to Mode 7 below the bar
Sampled sound	Sampled instruments	each instrument is a 5-byte entry naming a sample, its envelope, and a pitch multiplier
Music driver	Fractional tempo	a 2 ms timer tick adds the tempo to an 8-bit accumulator, and each carry calls the sound engine's step
Coyote time	None	a jump starts only while Mario isn't in the air, and walking off a ledge puts him there before the jump code runs

Every claim about this game, by concept (47)

general	Right after block collision, `CODE_00F595` starts Mario's death once his y measured from the top of the screen reaches 256 px, 32 px below the bottom of the 224-line picture, unless `YoshiHeavenFlag` is set, when it jumps to `CODE_00C95B` instead.	Code
Air control	In the air with neither Left nor Right held, Mario's horizontal routine returns before friction, so he keeps his speed.	Code
	Holding a direction in the air accelerates Mario by `MarioAccel_`'s 1.5/16 px/frame each frame up to his top speed, or by 5/16 (2.5/16 without Y) while he still moves the other way.	Code
	Measured in the game, a running jump keeps 36/16 px/frame when Right is let go, and turning Left in the air reverses it within 8 frames and reaches 36/16 the other way 29 frames after the turn.	Verified
	In the air Mario's horizontal speed follows the ground's code except that a released d-pad keeps the speed and the cap index never reaches 2 unless he left at full P-meter; a frame-by-frame model of these rules reproduces every probed frame.	Verified
	Measured frame by frame, a running jump turned with Left and Y held drops from 35/16 px/frame to exactly 0 in 7 frames of −5/16, then gains −1.5/16 a frame and reads −36/16 on the 31st frame of the turn.	Verified
Coyote time	When neither foot point finds a block and Mario isn't in the air, collision sets `PlayerInAir` to `$24` (falling). Collision follows the move, so he counts as airborne on the frame whose move carries his trailing foot past the edge, already moved by the ground's vertical speed, 6/16 px/frame (3/16 with B held); gravity then adds 6/16 a frame (3/16 held) up to 70/16.	Verified
Coyote time	Mario gets no grace window after walking off a ledge; `CODE_00D5F2` starts a jump only while `PlayerInAir` is 0, and block collision, earlier in the same frame, has already set it to `$24`.	Verified
Destructible terrain	A turn block (`$11E`) under the head point is hit from below like any functional block: it becomes bounce sprite 7, the turning turn block. That path doesn't read `Powerup`, and it breaks a block only when the block's `IntBlk_BounceSprite` entry is 7; the turn block's entry is 6 (its sprite number is 7), so a plain head hit never breaks a turn block, big or small. On the hit frame collision skips the head's downward move and only zeroes a rising speed.	Verified
	A block hit from below becomes a bounce sprite with an 8-frame timer and a vertical speed of `$C0` (−4 px/frame), and on its first frame, the hit frame, the block's cell becomes an invisible solid tile (`$152`) under it. Each frame the sprite moves by its speed's high nybble plus the carry of its low nybble into a fraction byte, then adds `$10` to the speed (a ? block) or `$13` (a turn block). Nothing clears that fraction, so a slot's leftover from its last bounce carries into the next.	Verified
	After a head hit, a turn block bounces through the hit frame and the five after it; on the sixth it snaps back to its cell as the always-turning tile (`$048`), which nothing collides with, so Mario passes through it. Its spin timer, `$FF` at the hit, runs down by one a frame, and 255 frames after the hit frame the cell becomes a turn block again.	Verified
Gravity	Each frame `CODE_00D928` adds 3/16 px/frame to Mario's vertical speed while A or B is held and 6/16 otherwise, rising or falling.	Code
	Gravity's routine cuts a downward speed above `$40` (4 px/frame) back to `$40` before adding gravity, so Mario falls at most 70/16 px/frame, or 67/16 holding the button.	Verified
	Each frame the player routine moves Mario by his current speed (`CODE_00DC2D`), then handles a jump press (`CODE_00D5F2`), then adds gravity (`CODE_00D7E4`), so the press frame doesn't lift him and his first step up is the take-off speed plus held gravity.	Code
	`CODE_00DC4F` adds a speed's low nybble to a subpixel byte and its high nybble, sign-extended, plus the carry to the 16-bit position, so Mario moves in sixteenths of a pixel.	Code
Hitbox	`GetMarioClipping` gives Mario a box for touching sprites 12 px wide from x+2, 26 px tall from y+6 when big, and 12 px tall from y+20 when small or ducking.	Code
	Against blocks Mario tests six points, a center, two side points, a head, and two feet at x+5 and x+11, y+32; big Mario's head point is at y+8 and small Mario's at y+16.	Code
	`GetBlockAtPlayer` adds a point's offsets to Mario's position and reads the block holding that pixel, x ÷ 16 for the column and y with its low 4 bits cleared for the row; in a horizontal level's layer 1, every point below y `$1B0` (432 px) reads as air. Side points stop at blocks `$111`–`$16D`, and a falling foot lands on `$100`–`$16D`.	Code
	With Mario's x in the left half of a block column (`PlayerBlockXSide` 0), collision tests his side points at x+14, and unless he's flush at x mod 16 = 2 marks him blocked on the right; in the right half (1), it tests those at x+2, flush at 13, blocked on the left. After all six points, it moves him 1 px back out of the wall and, if his speed points into the wall, zeroes its high byte but not its low byte.	Verified
	Mario's head point (x+8, and y+8 big or y+16 small; block-points) is the fourth of collision's six points, after the center and side points and before the feet. In the air, when it is in a solid block, collision moves him down by 15 minus the point's row in the block, keeping the subpixel, so the point ends on the block's bottom row, and zeroes his vertical speed if he was rising. Gravity then acts on that frame as usual. A turn block hit this way skips the move on that frame (turn-block-hit).	Verified
	On the ground, a head point in a solid block's upper 9 rows (0–8) ejects Mario left: collision marks him blocked on the right and zeroes his horizontal speed's high byte, and the wall push then moves him 1 px left a frame (side-push). In rows 9–15 he isn't moved. Either way it sets the top-blocked bit, and while that bit is set a jump press on the ground doesn't jump.	Verified
	A ? block under the head point (tile `$124`, a coin, in the probe) is hit from below: it gives its contents and bounces (block-bounce), and collision then treats it as solid, moving Mario down onto its bottom row and stopping his rise on the same frame (head-hit). When the bounce timer runs out, 7 frames after the hit frame, the cell becomes a used block (`$132`), which is solid and is never hit again.	Verified
Invincibility frames	`HurtMario` returns at once while `IFrameTimer` is nonzero. After the power-down animation Super Mario World sets it to `$7F`, and the timer loop counts it down on every frame the sprites aren't locked.	Code
Jump	On the ground, a fresh press of B (or X) starts Mario's jump and a fresh press of A a spin jump; `CODE_00D5F2` takes the take-off speed from `DATA_00D2BD` at an index set by his horizontal speed.	Code
	`DATA_00D2BD` gives a normal jump −80/16 to −97/16 px/frame (`$B0`–`$9F`) and a spin jump −74/16 to −90/16 (`$B6`–`$A6`), faster for every 0.5 px/frame of horizontal speed.	Code
	Measured in the game, a standing spin jump climbs 54.8 px with A held and 28.5 px tapped, against 64.2 and 33.3 for a normal jump.	Verified
	The jump press sets only Mario's vertical speed and air state, then falls into the horizontal code, so the press frame already uses the air rules and his speed carries over unchanged.	Verified
	Landing clears `PlayerInAir` during block collision, before the frame's speed update, so the landing frame already brakes or accelerates by the ground rules; the jump itself leaves the horizontal speed alone.	Verified
	A foot point in a block's top half lands Mario unless he is moving up; `CODE_00EE11` takes the point's row within the block, and below 8 the landing subtracts it from his y, keeping the subpixel, which stands him on the block's top. In the lower half the point doesn't land him.	Verified
Mode 7	The game keeps a Mode 7 angle, 0 to `$1FF` for a full turn, and an X and a Y scale, `$20` for 1.0, and turns them into the matrix with a quarter-wave sine table of 129 entries; D copies A and C is −B, a rotation scaled per axis.	Code
Mode 7	In the Reznor fight the Reznor in sprite slot 7 sets the Mode 7 center to `$80` and adds 1 to the angle each frame, wrapping at `$1FF`, so the Mode 7 wheel the four Reznors ride (the "Reznor sign" in the comments) turns once every 512 frames.	Code
Music driver	The engine's main loop waits on timer 0, set to tick every 2 ms; for each tick it adds the song's tempo byte to an 8-bit accumulator, and on a carry out it calls the routine APU_0BC0, unless a flag at audio RAM `$0388` is set. That routine wasn't read; the structure suggests it is one step of the music, which would make the tempo set the step rate. The tempo starts at `$36`, which gives 500 × 54 / 256, about 105 carries a second.	Code
Running	Measured on flat ground, Mario's top speed is 20/16 px/frame walking, 36/16 holding Y, and 47/16 to 49/16 once the P-meter is full, near `DATA_00D535`'s `$14`, `$24`, and `$30`.	Verified
	Each frame the player routine moves Mario by last frame's speed, runs block collision (which lands him), then `CODE_00D5F2` updates his horizontal speed, so a speed change first moves him on the next frame and a landing frame already uses the ground rules.	Verified
	`PlayerXSpeed` is 16 bits, a high byte in 1/16 px/frame and a low byte below it, so acceleration works in 1/4096 px/frame; position moves by the high byte alone.	Code
	On flat ground `MarioAccel_` speeds Mario toward a held direction by `$0180` (1.5/16 px/frame) a frame, with or without Y; holding against his motion uses its turning row, `$0280` (2.5/16) walking and `$0500` (5/16) with Y.	Code
	`DATA_00D535` caps Mario's ground speed at `$14` walking and `$24` holding Y, and at `$30` while the P-meter is full and charging.	Code
	`CODE_00D742` compares only the speed's high byte with the cap; below it the frame adds the full acceleration, unclamped, and at or past it the frame applies friction instead, so Mario's top speed cycles around the cap.	Code
	With no direction held on the ground, `CODE_00D76B` moves Mario's speed 1/16 px/frame a frame toward the slope's target speed, 0 on flat ground, and stops exactly on it.	Code
	Mario turns at the turning row's rate while his speed's high byte is nonzero and points against the held direction; the step is not clamped at zero, so the last one overshoots into the new direction.	Code
	A held Left or Right turns Mario to face it on the same frame, on the ground and in the air, unless he carries an item.	Code
	On flat ground, Down makes Mario duck, and a ducking Mario ignores Left and Right, so friction alone slows him; the duck flag is set only on the ground, so a duck jump stays ducked and steers.	Code
	Measured from a standstill on Yoshi's Island 1, Mario first passes `$14` on frame 14 walking and reaches `$24` on frame 24 holding Y; with Y held his P-meter fills 56 frames later.	Verified
Sampled sound	The sound engine runs on the SPC700. Its set-instrument command (`$DA`) reads a 5-byte entry from a table in audio RAM at `$5F46` and writes the first four bytes to the voice's DSP registers, the sample number (SRCN), ADSR1, ADSR2, and GAIN, and keeps the fifth as a pitch multiplier, so every instrument is a recorded sample with an envelope.	Code
Status bar split	In the Mode 7 boss rooms other than Bowser's, the NMI sets Mode 1 for the status bar at the top of the frame, and an interrupt at the line where the bar ends switches to Mode 7 and writes the Mode 7 layer's scroll; the bar ends at line 36, or 45 in Morton's and Roy's rooms. Bowser's room skips the status bar interrupt and goes straight to Mode 7.	Code
Variable jump height	Measured in the game, Mario climbs 64.2 px held and 33.3 px tapped from a standstill, 72.6 px held at walking speed, 81.6 px held running, and 85.3 or 91.1 px held sprinting.	Verified
Variable jump height	Measured in the game from a standstill, Mario's climb grows with each frame B is held, from 33.3 px tapped to 64.2 px at 28 frames or more.	Verified

References

^On the ground, a fresh press of B (or X) starts Mario's jump and a fresh press of A a spin jump; CODE_00D5F2 takes the take-off speed from DATA_00D2BD at an index set by his horizontal speed.CodeSMWDisX
How we know
```
9921CODE_00D5F2:
9922    LDA.B PlayerInAir
9923    BEQ +
9924    JMP CODE_00D682
```
bank_00.asm lines 9921–9924 at 30643c7 · upstream ↗
```
9940    LDA.B byetudlrFrame
9941    ORA.B axlr0000Frame
9942    BMI CODE_00D630
```
bank_00.asm lines 9940–9942 at 30643c7 · upstream ↗
```
9953CODE_00D630:
9954    LDA.B PlayerXSpeed+1
⋮
9958  + LSR A
9959    LSR A
9960    AND.B #$FE
9961    TAX
9962    LDA.B axlr0000Frame
9963    BPL CODE_00D65E
⋮
9975    INX
⋮
9981  + LDA.W DATA_00D2BD,X
9982    STA.B PlayerYSpeed+1
```
bank_00.asm lines 9953–9982 at 30643c7 · upstream ↗
Checked against the evidence by its author, an AI model, 2026-10-20.
Checked by a second AI model, 2026-10-21.
In the claim ledger
^ a bDATA_00D2BD gives a normal jump −80/16 to −97/16 px/frame ($B0–$9F) and a spin jump −74/16 to −90/16 ($B6–$A6), faster for every 0.5 px/frame of horizontal speed.CodeSMWDisX
How we know
```
9673DATA_00D2BD:
9674    db $B0,$B6,$AE,$B4,$AB,$B2,$A9,$B0
9675    db $A6,$AE,$A4,$AB,$A1,$A9,$9F,$A6
```
bank_00.asm lines 9673–9675 at 30643c7 · upstream ↗
Checked against the evidence by its author, an AI model, 2026-10-20.
Checked by a second AI model, 2026-10-21.
In the claim ledger
^Measured in the game, a standing spin jump climbs 54.8 px with A held and 28.5 px tapped, against 64.2 and 33.3 for a normal jump.VerifiedSMWDisX
How we know
```
9673DATA_00D2BD:
9674    db $B0,$B6,$AE,$B4,$AB,$B2,$A9,$B0
```
bank_00.asm lines 9673–9675 at 30643c7 · upstream ↗
Measured by a script in MesenCE 2.2.1 (build 4b8a196), on . It fails if the result disagrees with the claim.
The numbers come from the run; its author, an AI model, checked the script measures what the claim says, 2026-10-25.
Checked by a second AI model, 2026-10-21.
Checked by a second AI model, 2026-10-25.
In the claim ledger

^ a b c dEach frame CODE_00D928 adds 3/16 px/frame to Mario's vertical speed while A or B is held and 6/16 otherwise, rising or falling.CodeSMWDisX

How we know

10167DATA_00D7A5:                                  ;!
10168    db $06,$03,$04,$10,$F4,$01,$03,$04        ;!

bank_00.asm lines 10167–10169 at 30643c7 · upstream ↗

10439CODE_00D928:
10440    LDY.B #$01
10441    LDA.B byetudlrHold
10442    BMI +
10443CODE_00D92E:
10444    LDY.B #$00

bank_00.asm lines 10439–10444 at 30643c7 · upstream ↗

10457CODE_00D948:                                  ;!
10458    CLC                                       ;!
10459    ADC.W DATA_00D7A5,Y                       ;!

bank_00.asm lines 10457–10459 at 30643c7 · upstream ↗

821  + LDA.W axlr0000P1Hold,X                    ;\ 
822    AND.B #!ButA|!ButX                        ;| Set up $15, sharing the top two bits of controller data 2 (for A/X).
823    ORA.W byetudlrP1Hold,X                    ;|
824    STA.B byetudlrHold                        ;/

bank_00.asm lines 821–824 at 30643c7 · upstream ↗

Checked against the evidence by its author, an AI model, 2026-10-20.

Checked by a second AI model, 2026-10-21.

In the claim ledger

^ a bGravity's routine cuts a downward speed above $40 (4 px/frame) back to $40 before adding gravity, so Mario falls at most 70/16 px/frame, or 67/16 holding the button.VerifiedSMWDisX
How we know
```
10171DATA_00D7AF:                                  ;!
10172    db $40,$40,$20,$40,$40,$40,$40,$40        ;!
```
bank_00.asm lines 10171–10173 at 30643c7 · upstream ↗
```
10446  + LDA.B PlayerYSpeed+1                      ;! \ If Mario's Y speed is negative (up),
10447    BMI CODE_00D948                           ;! / branch to $D948
10448    CMP.W DATA_00D7AF,Y                       ;!
10449    BCC +                                     ;!
10450    LDA.W DATA_00D7AF,Y                       ;!
```
bank_00.asm lines 10446–10450 at 30643c7 · upstream ↗
Measured by a script in MesenCE 2.2.1 (build 4b8a196), on . It fails if the result disagrees with the claim.
The numbers come from the run; its author, an AI model, checked the script measures what the claim says, 2026-10-20.
Checked by a second AI model, 2026-10-21.
In the claim ledger
^Each frame the player routine moves Mario by his current speed (CODE_00DC2D), then handles a jump press (CODE_00D5F2), then adds gravity (CODE_00D7E4), so the press frame doesn't lift him and his first step up is the take-off speed plus held gravity.CodeSMWDisX
How we know
```
8897CODE_00CD24:
⋮
8904  + JSR CODE_00DC2D
8905    JSR CODE_00E92B
```
bank_00.asm lines 8897–8905 at 30643c7 · upstream ↗
```
8946CODE_00CD82:
8947    JSR CODE_00D5F2
8948    JSR CODE_00D062
8949    JSR CODE_00D7E4
```
bank_00.asm lines 8946–8949 at 30643c7 · upstream ↗
Checked against the evidence by its author, an AI model, 2026-10-20.
Checked by a second AI model, 2026-10-21.
In the claim ledger
^Measured in the game from a standstill, Mario's climb grows with each frame B is held, from 33.3 px tapped to 64.2 px at 28 frames or more.VerifiedSMWDisX
How we know
```
10440    LDY.B #$01
10441    LDA.B byetudlrHold
10442    BMI +
⋮
10444    LDY.B #$00
```
bank_00.asm lines 10439–10459 at 30643c7 · upstream ↗
Measured by a script in MesenCE 2.2.1 (build 4b8a196), on . It fails if the result disagrees with the claim.
The numbers come from the run; its author, an AI model, checked the script measures what the claim says, 2026-10-25.
Checked by a second AI model, 2026-10-21.
Checked by a second AI model, 2026-10-25.
In the claim ledger

^ a b cCODE_00DC4F adds a speed's low nybble to a subpixel byte and its high nybble, sign-extended, plus the carry to the 16-bit position, so Mario moves in sixteenths of a pixel.CodeSMWDisX

How we know

10909CODE_00DC4F:                                  ;!
10910    LDA.B PlayerXSpeed+1,X                    ;!
10911    ASL A                                     ;!
10912    ASL A                                     ;!
10913    ASL A                                     ;!
10914    ASL A                                     ;!
10915    CLC                                       ;!
10916    ADC.W PlayerXPosSpx,X                     ;!
⋮
10920    LDA.B PlayerXSpeed+1,X                    ;!
⋮
10930    ADC.B PlayerXPosNext,X                    ;!

bank_00.asm lines 10909–10933 at 30643c7 · upstream ↗

Checked against the evidence by its author, an AI model, 2026-10-20.

Checked by a second AI model, 2026-10-21.

In the claim ledger

^ a b cMeasured in the game, Mario climbs 64.2 px held and 33.3 px tapped from a standstill, 72.6 px held at walking speed, 81.6 px held running, and 85.3 or 91.1 px held sprinting.VerifiedSMWDisX
How we know
```
9673DATA_00D2BD:
9674    db $B0,$B6,$AE,$B4,$AB,$B2,$A9,$B0
```
bank_00.asm lines 9673–9675 at 30643c7 · upstream ↗
```
10440    LDY.B #$01
10441    LDA.B byetudlrHold
10442    BMI +
⋮
10444    LDY.B #$00
```
bank_00.asm lines 10439–10459 at 30643c7 · upstream ↗
Measured by a script in MesenCE 2.2.1 (build 4b8a196), on . It fails if the result disagrees with the claim.
The numbers come from the run; its author, an AI model, checked the script measures what the claim says, 2026-10-25.
Checked by a second AI model, 2026-10-21.
Checked by a second AI model, 2026-10-25.
In the claim ledger
^ a bMeasured on flat ground, Mario's top speed is 20/16 px/frame walking, 36/16 holding Y, and 47/16 to 49/16 once the P-meter is full, near DATA_00D535's $14, $24, and $30.VerifiedSMWDisX
How we know
```
9764DATA_00D535:                                  ;!
9765    db $EC,$14,$DC,$24,$DC,$24,$D0,$30        ;!
```
bank_00.asm lines 9764–9765 at 30643c7 · upstream ↗
Measured by a script in MesenCE 2.2.1 (build 4b8a196), on . It fails if the result disagrees with the claim.
The numbers come from the run; its author, an AI model, checked the script measures what the claim says, 2026-10-20.
Checked by a second AI model, 2026-10-21.
In the claim ledger
^PlayerYSpdData starts a jump at −4 px/frame (rows 0–2) or −5 px/frame (rows 3–4).CodeXkeeper0/smb1 · Jdaster64 n.d.
How we know
```
4864PlayerYSpdData:
4865	.db $fc, $fc, $fc, $fb, $fb, $fe, $ff
```
src/prg.asm lines 4864–4865 at 1cc3c92 · upstream ↗
```
4972	LDA PlayerYSpdData,y
4973	STA Player_Y_Speed
```
src/prg.asm lines 4972–4973 at 1cc3c92 · upstream ↗
04000 | 04000 | 05000
JUMPING/VERTICAL PHYSICS, Mario table, Initial Velocity (−Y) · archived copy ↗
Checked against the evidence by its author, an AI model, 2026-10-20.
Checked by a second AI model, 2026-10-27.
In the claim ledger
^While a jump rises with A held, gravity is JumpMForceData's $20, $20, $1E, $28, $28 subpixels/frame² for rows 0–4.CodeXkeeper0/smb1 · Jdaster64 n.d.
How we know
```
4858JumpMForceData:
4859	.db $20, $20, $1e, $28, $28, $0d, $04
```
src/prg.asm lines 4858–4859 at 1cc3c92 · upstream ↗
```
4966	LDA JumpMForceData,y                         ; store appropriate jump/swim
4967	STA VerticalForce                            ; data here
```
src/prg.asm lines 4966–4967 at 1cc3c92 · upstream ↗
00200 | 001E0 | 00280
JUMPING/VERTICAL PHYSICS, Mario table, Holding “A” Gravity (+Y) · archived copy ↗
Checked against the evidence by its author, an AI model, 2026-10-20.
Checked by a second AI model, 2026-10-27.
In the claim ledger
^ a b cJumpSwimSub swaps in falling gravity, never back, once speed is zero or downward, or once the jump has risen at least DiffToHaltJump on a frame when A is not held, or was not held the frame before.CodeXkeeper0/smb1 · Jdaster64 n.d.revised
How we know
```
4757	BPL DumpFall                                 ; or moving downwards, branch to falling
⋮
4760	AND PreviousA_B_Buttons                      ; and was pressed in previous frame
4761	BNE ProcSwim                                 ; if so, branch elsewhere
⋮
4765	CMP DiffToHaltJump                           ; compare to value set here to see if player is in mid-jump
⋮
4768	LDA VerticalForceDown                        ; otherwise dump falling into main fractional
4769	STA VerticalForce
```
src/prg.asm lines 4756–4769 at 1cc3c92 · upstream ↗
so long as they are moving upward in a jump, holding “A” will make them rise more slowly
JUMPING/VERTICAL PHYSICS · archived copy ↗
Checked against the evidence by its author, an AI model, 2026-10-27.
Revised after a check by a second AI model, 2026-10-27: "Not held both this frame and last" read two ways; held gravity stays only while A is held on both frames.
In the claim ledger
^After the switch, gravity is FallMForceData's $70, $70, $60, $90, $90 subpixels/frame² for rows 0–4.CodeXkeeper0/smb1 · Jdaster64 n.d.
How we know
```
4861FallMForceData:
4862	.db $70, $70, $60, $90, $90, $0a, $09
```
src/prg.asm lines 4861–4862 at 1cc3c92 · upstream ↗
```
4968	LDA FallMForceData,y
4969	STA VerticalForceDown
```
src/prg.asm lines 4968–4969 at 1cc3c92 · upstream ↗
00700 | 00600 | 00900
JUMPING/VERTICAL PHYSICS, Mario table, Falling Gravity (+Y) · archived copy ↗
Checked against the evidence by its author, an AI model, 2026-10-20.
Checked by a second AI model, 2026-10-27.
In the claim ledger
^MovePlayerVertically gives ImposeGravity 4 px/frame as Mario's maximum fall speed; the clamp sets the speed back to 4 only when its whole part is at least 4 and its fraction byte at least $80.CodeXkeeper0/smb1 · Jdaster64 n.d.revised
How we know
```
6549	LDA #$04                                     ; set maximum vertical speed here
6550	JMP ImposeGravitySprObj                      ; then jump to move player vertically
```
src/prg.asm lines 6547–6550 at 1cc3c92 · upstream ↗
```
6688	CMP $02                                      ; compare to maximum speed
⋮
6691	CMP #$80                                     ; if less positively than preset maximum, skip this part
⋮
6694	STA SprObject_Y_Speed,x                      ; keep vertical speed within maximum value
⋮
6696	STA SprObject_Y_MoveForce,x                  ; clear fractional
```
src/prg.asm lines 6688–6696 at 1cc3c92 · upstream ↗
their vertical downward velocity caps at 04800 in most cases, wrapping back to 04000 when exceeded
JUMPING/VERTICAL PHYSICS · archived copy ↗
Checked against the evidence by its author, an AI model, 2026-10-20.
Revised after a check by a second AI model, 2026-10-27: The clamp sets the speed back to 4 only when its whole part is at least 4 and its fraction at least $80, so 4 px/frame alone overstated it.
In the claim ledger
^ a bMeasured in the game with A held, Mario's jumps peak at 66 px standing, 71 px walking, and 83 px running.VerifiedXkeeper0/smb1revised
How we know
```
4758	LDA A_B_Buttons
⋮
4763	SEC
⋮
4767DumpFall:
⋮
4769	STA VerticalForce
```
src/prg.asm lines 4756–4769 at 1cc3c92 · upstream ↗
```
6681	LDA SprObject_Y_MoveForce,x
6682	CLC
⋮
6684	STA SprObject_Y_MoveForce,x
⋮
6686	ADC #$00
6687	STA SprObject_Y_Speed,x
⋮
6690	LDA SprObject_Y_MoveForce,x
```
src/prg.asm lines 6664–6696 at 1cc3c92 · upstream ↗
```
4958	STA DiffToHaltJump
```
src/prg.asm lines 4957–4958 at 1cc3c92 · upstream ↗
Measured by a script in MesenCE 2.2.1 (build 4b8a196), on . It fails if the result disagrees with the claim.
The numbers come from the run; its author, an AI model, checked the script measures what the claim says, 2026-10-25.
Revised after a check by a second AI model, 2026-10-25.
In the claim ledger

^Vertical motion is 8.8 fixed point; each frame, ImposeGravity adds speed to position, the fraction via the YMF_Dummy subpixel byte, then gravity to speed.CodeXkeeper0/smb1

How we know

6668	ADC SprObject_Y_MoveForce,x
6669	STA SprObject_YMF_Dummy,x
⋮
6676	ADC SprObject_Y_Position,x                   ; add vertical position to vertical speed plus carry
⋮
6683	ADC $00                                      ; add downward movement amount to contents of $0433
⋮
6685	LDA SprObject_Y_Speed,x                      ; add carry to vertical speed and store

src/prg.asm lines 6666–6687 at 1cc3c92 · upstream ↗

Checked against the evidence by its author, an AI model, 2026-10-20.

Checked by a second AI model, 2026-10-27.

In the claim ledger

^In the air with neither Left nor Right held, Mario's horizontal routine returns before friction, so he keeps his speed.CodeSMWDisX
How we know
```
9998    LDA.B byetudlrHold
9999    AND.B #$03
10000    BNE CODE_00D6B1
```
bank_00.asm lines 9998–10000 at 30643c7 · upstream ↗
```
10021  + JMP CODE_00D764
```
bank_00.asm line 10021 at 30643c7 · upstream ↗
```
10125CODE_00D764:
10126    JSR CODE_00D968
10127    LDA.B PlayerInAir
10128    BNE Return00D7A4
```
bank_00.asm lines 10125–10128 at 30643c7 · upstream ↗
Checked against the evidence by its author, an AI model, 2026-10-20.
Checked by a second AI model, 2026-10-21.
In the claim ledger
^Holding a direction in the air accelerates Mario by MarioAccel_'s 1.5/16 px/frame each frame up to his top speed, or by 5/16 (2.5/16 without Y) while he still moves the other way.CodeSMWDisX
How we know
```
9699    dw $FE80,$FE80,$0180,$0180                ;!
```
bank_00.asm line 9699 at 30643c7 · upstream ↗
```
9717    dw $FD80,$FB00,$0280,$0500                ;!
```
bank_00.asm line 9717 at 30643c7 · upstream ↗
```
10061    LDA.B PlayerXSpeed+1
10062    BEQ CODE_00D713
10063    EOR.W MarioAccel_+1,X
10064    BPL CODE_00D713
⋮
10072  + TXA
10073    CLC
10074    ADC.B #$90
10075    TAX
```
bank_00.asm lines 10061–10075 at 30643c7 · upstream ↗
```
10107CODE_00D742:
10108    LDA.B PlayerXSpeed+1
10109    SEC
10110    SBC.W DATA_00D535,Y
⋮
10115    LDA.W MarioAccel_,X
```
bank_00.asm lines 10107–10123 at 30643c7 · upstream ↗
Checked against the evidence by its author, an AI model, 2026-10-20.
Checked by a second AI model, 2026-10-21.
Checked by a second AI model, 2026-10-21.
In the claim ledger
^Measured in the game, a running jump keeps 36/16 px/frame when Right is let go, and turning Left in the air reverses it within 8 frames and reaches 36/16 the other way 29 frames after the turn.VerifiedSMWDisX
How we know
```
10126    JSR CODE_00D968
10127    LDA.B PlayerInAir
10128    BNE Return00D7A4
```
bank_00.asm lines 10125–10128 at 30643c7 · upstream ↗
```
10061    LDA.B PlayerXSpeed+1
10062    BEQ CODE_00D713
10063    EOR.W MarioAccel_+1,X
10064    BPL CODE_00D713
⋮
10073    CLC
10074    ADC.B #$90
10075    TAX
```
bank_00.asm lines 10061–10075 at 30643c7 · upstream ↗
Measured by a script in MesenCE 2.2.1 (build 4b8a196), on . It fails if the result disagrees with the claim.
The numbers come from the run; its author, an AI model, checked the script measures what the claim says, 2026-10-25.
Checked by a second AI model, 2026-10-21.
Checked by a second AI model, 2026-10-21.
Checked by a second AI model, 2026-10-25.
In the claim ledger

Sources

Code

IsoFrieze, kaizoman666, mikeyk, and loveemu. 2026. “SMWDisX: Super Mario World disassembly (IsoFrieze/SMWDisX).” Commit 30643c7. IsoFrieze/SMWDisX @ 30643c7 · licence, all uses
doppelganger and Xkeeper. 2022. “smb1: Super Mario Bros. disassembly for asm6f (Xkeeper0/smb1).” Commit 1cc3c92. Xkeeper0/smb1 @ 1cc3c92 · licence, all uses

Secondary

Jdaster64. n.d. “A Complete Guide to SMB's Physics Engine.” original · archived · licence, all uses

#Jumping

#Running and the jump

#Compared with Super Mario Bros.

#Moving in the air

Related

See also

Mentioned in

Mechanics

References

Sources

Code

Secondary