December 1994. The PlayStation lands in Japan promising real polygonal 3D graphics running on a home console, something no competitor had really pulled off up to that point. Except Sony cut a corner that almost nobody else cut that generation. The PS1's GPU had zero texture filtering hardware. None at all. Not even basic bilinear, let alone the trilinear filtering that would show up shortly after on the N64. Every texel got read raw and dumped straight onto the screen, with no smoothing between one pixel and the next. That wasn't a cosmetic detail. It was an engineering decision with consequences that rippled through the rest of the graphics pipeline, and it's worth understanding how studios at the time worked around it. Honestly, the story is less about "heroic creativity" and more about well executed hacks. ## What Was Actually Missing First, a point that trips up almost everyone. "Shaky textures," "blocky textures," and "melting textures" aren't the same thing, even though they tend to show up together in the same scene and ended up getting treated as synonyms. Missing texture filtering is specifically about sampling. Without bilinear, the GPU just grabs the color of the nearest texel and that's it, no interpolation at all. The result is that blocky look anyone who played PS1 recognizes, especially up close, and the flickering (the so called shimmering) when the camera moves, because there's nothing smoothing the transition between texels. But that was only part of the package. There were at least four more limitations bundled in, and it's almost impossible to talk about one without running into the others. ## The Flaws, One by One (They Blend Together, And That's Fine) Affine texture mapping, not perspective correct, that's the technical name for the problem most people (wrongly) call "lack of filtering." The GPU interpolated UV coordinates in screen space, in 2D, instead of accounting for the polygon's actual depth in 3D. At low angles, or on large polygons, this produced that "melting" texture effect as the camera turned. It's a different problem from unfiltered sampling, except the two show up together almost every time. No Z-buffer either. Without a per pixel depth buffer, the PS1 relied on the painter's algorithm: draw back to front using a linked list called the Ordering Table, which sets the approximate draw order based on each primitive's depth. It works most of the time. It fails visibly when polygons cross each other or the scene gets too complex for simple ordering, which is where that classic "pop" comes from, a piece of scenery suddenly appearing in front of something that should be behind it. Then there's the precision problem. The geometry coprocessor (the GTE) worked in fixed point, not floating point, and handed the rasterizer only integer vertex coordinates. The real issue isn't even the missing FPU itself. It's that the rasterizer simply wouldn't accept fractional position values. So vertices snapped to the nearest pixel on the grid, and any tiny calculation variance between one frame and the next made the geometry shake, even while standing still. Last, the VRAM. Just 1 MB split between framebuffer and textures, with a small cache controlling what the GPU could actually fetch each frame. That pushed artists toward small, tiled, repeating textures in 4 bit or 8 bit indexed palettes to save space, which, combined with the lack of filtering, made the aliasing even more obvious. None of this existed in isolation. It was a set of cost decisions that prioritized raw drawing speed over any kind of visual smoothing, and it was up to each studio to figure out the hard way what to do about it. ## What Studios Actually Did And here's the most interesting part, I think. Almost none of this got "solved" in the strict technical sense. There was no firmware trick that handed bilinear filtering back to a chip that never had that circuit to begin with. What actually happened was a mix of engineering workarounds, artistic adaptation, and, in good part, luck with the display technology of the time. Polygon subdivision was the most common technique against warping. Since affine distortion grows with polygon size and the angle relative to the camera, slicing a wall or a floor into smaller pieces cut down the visible effect a lot, without fixing the actual cause, just hiding it. Racing games usually subdivided the track as it got closer to the camera. Even the PS1 port of Quake II leaned on this to keep environments readable. There was dithering too. With 15 bit color, banding in gradients and lighting would have been a constant problem. Sony built a dithering pattern right into the output hardware, mixing pixels of nearby colors to fake intermediate tones. That subtle noise, which today we recognize as part of the PS1's "look," also helped, sort of by accident, disguise the blocky appearance of unfiltered textures by breaking up large solid color blocks. Fog and depth cueing weren't just for atmosphere. Cutting visibility at a certain distance hid both the painter's algorithm sorting errors and the stronger shimmering on distant textures, which is exactly where the lack of filtering hurts the most. Silent Hill is the example everyone brings up, but it was basically standard in any game with long corridors or a more open world. When the automatic algorithm couldn't keep up, some studios went further and precomputed the draw order per level. The best known case is Crash Bandicoot. Naughty Dog ran a precomputation process that took well over an hour per level, spread across several SGI workstations, just to hit a high polygon count on hardware without a Z-buffer. It was production brute force papering over a hardware gap. And maybe the most underrated part is the work of the texture artists themselves. Textures with noise, a more organic pattern, softer contrast, those hid aliasing way better than a flat surface or a hard, high contrast edge. A high contrast checkerboard is about the worst case scenario for unfiltered hardware, because every wrong texel jumps right out at you. Teams learned this through trial and error, there's no magic formula here. Tighter geometry and camera work helped with vertex jitter too. A lot of level design from that era (corridors, closed arenas, tracks with gentle curves instead of long straights) wasn't purely an aesthetic choice. It was also a way of keeping the shaking under control, avoiding scenarios where it became too obvious. And there's a somewhat accidental ally in all this: the TV itself. This point tends to surprise anyone who only knows the PS1 through emulation. Almost nobody played in high definition. The image went out through composite or, at best, RGB SCART, into a relatively small CRT television. The composite signal already blurs the image on its own, and the CRT's interlaced scan smooths out hard edges and pixel blocks even more. In practice, the tube worked like a free analog bilinear filter that Sony never had to put on the chip. That's why running the same game on a modern emulator, at native resolution, on a big LCD screen, exposes a level of flaw that almost nobody saw, or complained about seeing, back in 1996. Worth a caveat here, calling this a "solution" is a bit of a stretch. In most cases there was no real fix, there was accommodation. Studios learned to put together scenes, textures, and geometry in a way that made the limitations less visible, and they got lucky that the screens of the time cooperated without anyone planning it that way. ## So What? It's tempting to frame this as "creativity born from limitation." There's something to that, but the full picture is less flattering. Sony made a cost bet: a simple, fast GPU, without the filtering and Z-buffer circuits that would have cost silicon and money, and pushed the bill onto software and art. It worked well enough to compete, and it worked even better because the screens of the time absorbed part of the problem for free. The curious side effect is what came after. That look (pixelated textures, shaking vertices, textures warping at low angles) became a style with its own identity, today recreated on purpose in shaders, indie games, mods. Decades after it stopped being a limitation and turned into a choice for people who wanted that visual back. --- ## Questions That Keep Coming Up And Rarely Get a Good Answer **1. Are missing texture filtering and "texture warping" the same problem?** No, and it's the most common mix up about this topic. Missing filtering is about texel sampling, visible blocks, no smoothing between pixels. Warping is about the affine mapping method, which distorts textures at low angles because the interpolation happens in 2D screen space instead of real 3D space. They're different hardware causes that just happen to show up together in the same scene. **2. Why did characters shake even when standing still, with no camera movement?** Because vertex jitter doesn't depend on camera movement. It comes from the rasterizer's lack of subpixel precision, which rounds every vertex position to the nearest whole pixel. Any tiny calculation variance between one frame and the next, even in a standing "idle breathing" animation, was enough to make a vertex jump from one pixel to the next. **3. If the problem was so visible, why did practically nobody complain back then?** Because practically nobody saw it at the intensity we see today. Low resolution, an already blurred video signal (composite or RGB), a CRT with interlaced scanning smoothing out blocks and hard edges. Running the same game on an emulator, at native resolution, on a big LCD, exposes a level of raw detail that the 1996 audience never actually got to see. **4. The N64 had texture filtering and a Z-buffer. Shouldn't that have just made its games look better, full stop?** It solved the PS1's technical problems, but brought a different one. The N64 became known for a somewhat blurry, almost "vaseline smeared" look, because of the aggressive bilinear filtering applied over low resolution textures. More technically correct isn't the same as better looking, or aging better. That's why there's still debate today over which of the two visuals held up better, and I don't think there's an obvious answer. **5. Can you emulate the PS1 without any of these artifacts, or does that change the game's identity?** Technically, yes. Modern emulators let you turn on bilinear filtering, perspective correction, subpixel precision, even a software Z-buffer, which eliminates pretty much all four problems described here. The result splits opinion among players. For some it's the "correct" way to play, free of the hardware's limitations. For others it's almost a different game, because a good chunk of that generation's visual identity (including art choices made specifically to live with these limitations) depends on the very artifacts that filter erases.