The PS1 had no floating-point unit for 3D geometry. Its CPU handled coordinates as integers (whole numbers, no decimals). That limitation is what caused the wobble, and it affected basically everything the console tried to render in 3D. ## The core issue: no sub-pixel precision When the PS1 calculated where a vertex should appear on screen, it snapped that position to the nearest whole pixel. No fractions. So as the camera moved or an object rotated even slightly, each vertex jumped from pixel to pixel in discrete, visible steps rather than moving smoothly. Polygons would stretch and warp frame to frame. Straight edges looked unstable. This is called vertex jitter, and it came from the PS1's GTE (Geometry Transformation Engine), which used fixed-point arithmetic with limited precision. Coordinates were snapped to integer positions at the screen level. The hardware simply had no concept of sub-pixel accuracy. There was also a second problem, somewhat related: texture warping. The PS1 used affine texture mapping, which assumes texture coordinates change linearly across a polygon. They don't, not on a 3D surface viewed at an angle. They change with perspective. The GTE skipped the perspective-correct division because it was too expensive to compute, so textures on large polygons would slide and skew as the viewing angle shifted. Floors especially looked wrong. Not broken exactly, just rubbery. ## What developers did about it Most developers found ways to work around it rather than through it. The most common approach was using smaller polygons. If you split your geometry into more, smaller triangles, the error per polygon stays the same but becomes less visible because each individual polygon covers less screen space. Games like *Crash Bandicoot* and *Metal Gear Solid* had noticeably denser geometry than most of their contemporaries, partly for this reason. Camera design also played a big role. Fixed cameras, like the ones used in *Resident Evil*, largely sidestepped the problem because the view wasn't changing constantly. Slow panning cameras over ground geometry were some of the worst-case scenarios for both jitter and texture warping, so many developers simply avoided them. Fog was another tool. Pulling in the draw distance and covering the cutoff with fog reduced how many distant polygons were on screen at once. Distant geometry, where small angular shifts caused the most dramatic pixel-snapping, just got hidden. The more drastic workaround was pre-rendered backgrounds. *Final Fantasy VII*, *Resident Evil*, *Silent Hill*: they all put fully pre-rendered 2D images behind 3D characters. The characters still wobbled, but the environments were stable. It worked, and to be fair it also let artists put far more visual detail into the backgrounds than real-time geometry would have allowed at the time. On the texture side, artists learned to avoid large flat surfaces with solid colours. Busy, detailed textures made the warping harder to see. It wasn't a fix, just a way to make the problem less noticeable. ## What couldn't be fixed The workarounds helped, but they didn't eliminate the problem. Collision detection could end up slightly misaligned with what the player saw, because the visual and logical geometry weren't always in sync. HUD elements and text had to be rendered separately to keep them stable. And games that pushed for open environments, early racing games and anything with a wide-open world, generally look the roughest today because they had fewer places to hide. ## How it actually got solved The Nintendo 64 had sub-pixel rendering and a more capable geometry pipeline, which reduced jitter meaningfully. It had its own texture problems though, so it wasn't a clean solution. The real fix came with the PlayStation 2, which included a proper floating-point math unit for geometry. Vertex positions could be calculated with decimal precision and rounded correctly, so no more integer snapping and no more jitter. The PS2 also did perspective-correct texture mapping by default, which handled the rubber-floor problem without developers having to work around it. Later hardware moved all of this onto dedicated GPU silicon with programmable shaders, making it less of a design constraint and more of a solved engineering problem. By comparison, the PS1's GTE was doing the bare minimum needed to push 3D polygons onto a screen with mid-90s consumer hardware budgets. None of it was really a bug. It was just what 3D on affordable hardware looked like in 1994, before anyone had fully worked out what that hardware needed to actually do the job well.