"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.
controls
- ← → navigate modes
- 1-4 jump to mode
- P toggle parameters
- L freeze time
- mouse controls failure parameters