Option 22: glitch art. The bot's footage is broken on purpose. The datamosh mode is a real (tiny) video decoder: it estimates motion for each 8×8 block, then deliberately drops the keyframe at every scene cut. The other modes sort pixels, split colour channels and corrupt blocks.

**Datamosh is real decoding, broken on purpose.**
Video files store occasional full pictures (keyframes) and, in between, only instructions: "move this 8×8 block by (dx, dy), then add a small correction." The code does exactly that.

**The break happens at a scene cut.**
Every 7 seconds the background changes. With "Drop keyframes" on, the new scene's full picture is thrown away. The bot's movement then drags the old scene's pixels around like paint, until the next clean keyframe resets everything.

**Five modes:**
**Datamosh: tap "Scene cut."**
The new scene fails to appear. Instead, the bot's hop smears the old sunset into bot-shaped streaks. Tap "Keyframe" to clean up.

**Tick "Motion vectors."**
Green ticks show which blocks the encoder thinks moved and where. Only the bot's blocks move; the sky reads as still.

**Tick "P-frame bloom."**
The last motion is applied again and again, so pixels stretch and bloom out of the bot. This copies the classic trick of duplicating one in-between frame many times.

**Untick "Drop keyframes" and cut.**
The picture switches cleanly. That's normal, healthy video.

**Pixel sort, intensity 100%.**
Bright areas melt into horizontal gradient streaks.

**Why only moving things mosh.**
Still blocks just copy their own old pixels. Datamosh lives where there's motion, so the character becomes the brush.

**The patterned blocks are real compression building blocks.**
The ripple patterns in "Macroblocks" come from the same cosine waves JPEG and MPEG use. A damaged stream shows its raw ingredients.

**Search is local and lazy.**
Each block checks 81 small offsets, and only if it changed at all. Real encoders do this at much larger scale, which is why video encoding is expensive.

**Healthy vs moshed decoding**
```
healthy: [I: new scene] → P → P → P (P = old block moved + correction) moshed: [I: new scene]✗ → P → P → P P frames now build on the OLD scene result: old picture dragged by new motion vectors
```

**One P-frame block**
```
current block (x,y) ≈ reference block (x+dx, y+dy) + small correction decoded = output_prev[x+dx, y+dy] + (source_now[x,y] − source_prev[x+dx, y+dy]) if output_prev is the wrong scene → the error persists and moves
```

**Pixel sort on one row**
```
before: ▁▂█▆▇▃▁▁▆█▅▇▂▁ dark │ bright run │ dark after: ▁▂▃▆▆▇█▁▁▅▆▇██▁ (each bright run sorted by brightness)
```

**Critical thinking:**
glitch art exposes how a medium works by breaking it. Is it critique of technology, or just a look? Once a glitch is a filter button, does it lose its meaning?

**Lateral thinking:**
datamosh is a "missing context" error: new instructions applied to an old state. Where does that happen elsewhere: out-of-date spreadsheets, stale caches, a new manager following the last manager's playbook?

**First principles:**
why does video compression store motion plus corrections rather than whole pictures? What does that trade-off say about how much actually changes between frames?

- How do tools like FFmpeg let artists datamosh real files?
- Can glitches be triggered by music beats?