"Every medium has its own specific fingerprint of failure. The glitch is not the enemy of the medium — it is the medium revealing itself." Rosa Menkman, A Vernacular of File Formats
the question

What does a GPU sound like when it lies? Not crashes — those are honest. The interesting failures are the quiet ones. The precision that degrades so slowly you don't notice until the grid dissolves. The buffer that forgets to clear and lets time accumulate in the framebuffer. The integer that wraps silently and tiles the universe.

Menkman catalogued the vernacular of file formats — JPEG's 8x8 block artifacts, PNG's scanline prediction residuals, GIF's dithered palette quantization. Each encoding fails in its own signature way. The error IS the fingerprint of the medium.

We asked the same question of the GPU. Not the file format but the compute substrate. What are the native failure modes of floating-point arithmetic, framebuffer management, integer overflow? And can those failures become a vocabulary — not bugs to fix, but a language to speak in?

the method

Each failure mode above is a live WebGL shader that demonstrates one specific GPU behavior. Move your mouse to control the parameters. The mouse isn't adjusting an effect — it's tuning the conditions under which the GPU reveals itself. Move far enough right in PRECISION LOSS and the float32 mantissa runs out of bits. Adjust the decay rate in BUFFER ECHO and watch temporal smear emerge from a skipped glClear.

These are not simulations of failure. They are failures, running live on your GPU, right now. The only difference between this and a bug report is intention.

failure catalog
01
PRECISION LOSS
Float32 mantissa degrades with distance from origin
IEEE 754 single-precision: 23-bit mantissa gives ~7 decimal digits. At coordinate 80,000 the representable spacing exceeds grid spacing. Coordinates quantize. The grid dissolves into itself not because it's broken but because the numbers can't reach that far.
02
BUFFER ECHO
Previous frames bleed into current — temporal accumulation
Without glClear, each frame draws atop the last. The decay multiplier controls how fast old frames fade. At 0.99, ghosts persist for hundreds of frames. Time becomes visible in the framebuffer. This is how temporal accumulation works in every GPU-accelerated VFX pipeline — the "bug" is the technique.
03
QUANTIZATION STEP
Insufficient bit depth — smooth gradients become staircases
A smooth gradient needs many steps. At 2 bits: 4 colors. At 8 bits: 256. The banding between levels is not distortion — it's the truth of digital encoding. The staircase is what digital color actually looks like before interpolation papers over it.
04
OVERFLOW WRAP
Integer arithmetic wraps at type boundary — tiling emerges
The accumulator overflows. The GPU does not check. The counter starts over and the pattern tiles. This is modular arithmetic made visible — the same principle behind hash functions, pseudorandom generators, and every tiling texture in every game ever shipped.
audio vernacular

The drone is three static oscillators. A1, E2, A2 — an organ in water. Underneath, four failure modes of the digital audio substrate. Toggle each and listen: aliasing, denormals, cent quantization, phase cancellation. These are to the ear what precision loss and buffer echo are to the eye — the medium's fingerprint made audible.

controls
  • ← → navigate modes
  • 1-4 jump to mode
  • P toggle parameters
  • L freeze time
  • mouse controls failure parameters