What are "subpixels" in Super Mario Bros on the NES? How does it relate to wall clipping?

At 4:42 in the following video, the notion is mentioned in the context of how it relates to "wall clipping":


My own reasoning:

Subpixels is a term used to describe Mario's x,y coordinates as a float. This float increments (in "subpixels") as a function of time multiplied by some gravity constant (y axis), player input (x and y), etc. Eventually the increment is enough for a full pixel of movement. This allows for more smooth acceleration of the movement of Mario in the game.

It appears the collision detection is not perfect in this game. Not every pixel of Mario is checked for collision with every pixel of solid sprites such as pipes and bricks.

This is probably due to optimizations, but exactly how the collision detection in Super Mario Bros works eludes me, and I believe it is key to understand the collision detection in order to understand the wall clipping.

  • 4
    It's not a float, it's a fixed point fractional number. A float would have an additonal field telling where the boundary between full and sub pixels is.
    – Janka
    May 27, 2019 at 11:58

2 Answers 2


Subpixels in general are invisible fractional pixels that you cannot see, but are used internally to represent the positions of objects at a finer level than they're capable of being displayed at.

So far as Super Mario goes they're represented as an integer with 16 subpixels per visible pixel. This allows inertia to be loosely modeled so that you can start off moving slowly, but gradually speed up in a more realistic fashion than modeling by exact pixels would give.

Wall glitching tricks involve manipulating this value - by very short movements against the direction you're moving in to decrease it and jumping directly into a block to increase it - to get it to carry over and increase your pixel position so that the code that would normally push you back out of a wall results instead in sucking you further in.

  • 1
    Not completely related follow-up question: does that imply that the levels are at most 16*256 = 4096 pixels wide? I'm trying to reason as to why a four bit fraction was selected; fitting global ordinates into two bytes is a guess.
    – Tommy
    May 27, 2019 at 7:28
  • 1
    No, the subpixel count is an entirely different byte to the position in the level which is stored in two bytes. While this would theoretically allow for 256 subpixels (and you'll see some people give that answer for that reason) that's way more precision than the game needs. May 27, 2019 at 22:42
  • Right; I see from your other comment that an entire byte is used for the subpixel component, it's just that only the top nibble contains values. I was otherwise imaging an exactly-the-most-awkward-possible shift by four to convert to an integer, rather than a more standard just-ignore-a-byte fixed point scheme. So I started from a false premise.
    – Tommy
    May 28, 2019 at 3:45
  • 1
    @Tommy: normally when a program uses fixed-point math, you use the low n bits of a wider integer type. e.g. treating the low 5 bits of an int32_t as fractional gives you a certain range (32-5 integer bits), and 5 fractional precision bits. It's certainly reasonable to guess that Mario would use a 16-bit integer with a 12:4 bit fixed-point split, but on an 8-bit CPU even 16-bit requires extended precision so I can see why there might be some advantages to having the integer part accessible separately without a byte-crossing right shift. May 28, 2019 at 9:24

In many 8 bit games the position of the player's sprite is stored as the pixel coordinates it rests on. For many games that is adequate, but it has some limitations.

If the game only uses whole pixel coordinates then the minimum movement speed is 1 pixel. In other words the resolution of the player's speedometer is 1 pixel. They can be moving at 1 pixel per frame, or 2 pixels per frame, but not 1.5 pixels per frame.

In Super Mario Bros. that is inadequate. Mario has a lot of momentum and a major part of the game is managing it. If his speedometer had a 1 pixel/frame resolution he would feel "stiff" to control. One of the major innovations of that game, which many others soon adopted, was sub-pixel positioning and speed.

Super Mario Bros divides each pixel up into 256 sub-pixel divisions. 256 is used because it's the range of an 8 bit number, which the 8 bit Famicom / NES could handle easily. So Mario's position and speed has a resolution of 1/256th of a pixel.

When Mario reaches an obstacle the game pushes him away from it, so that he ends up outside of any solid blocks. However, the check for collisions with solid objects is only performed every other frame, so there is 1 frame where Mario can be inside a solid block before it starts pushing him. If he is moving fast enough to get deep inside the block it can end up pushing him the wrong way, allowing him to pass through solid walls. This is only possible because sub-pixel accuracy allows him to partially inside the block for two consecutive frames.

  • 16
    Just to add that, although there are 256 possible values in a byte, the subpixel mathematics is all done in multiples of 16, hence there are effectively 16 of them as per my answer. May 27, 2019 at 22:52

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .