Ghost Font isn’t unreadable by AI

I decoded Ghost Font with Claude, and it wrote the decoder itself

The decoded message by Claude

Last week I heard about Ghost Font.

The headlines call it “a font AI can’t read.”

I downloaded one clip, handed it to Claude Code, and asked it to pull out the hidden text.

Two minutes later it returned three words, RECOVER THIS MESSAGE, rendered by a decoder it had written from scratch.

Freeze a frame and the message disappears

One of the video frame from original clip

Ghost Font is a random-dot kinematogram. Each letter is a cloud of dots painted the same colour as the background, so in any single frame the screen is a uniform field of noise.

Nothing to read.

The letters live only in motion.

The dots that make up a glyph drift together, while every other dot moves at random, and your visual system (tuned to spot coherent motion long before it ever learned to read) assembles the moving cluster into words the instant the clip plays.

That is the whole trick, and it is genuinely elegant.

The model really can’t read a screenshot, and that part is true

I want to be fair to the illusion before I take it apart.

A single frame is structureless. The first thing I checked was whether some cheap trick would surface the text, and none does. Even the obvious shortcut, a per-pixel variance map across time, is useless here, because the dots move everywhere and every pixel changes, so nothing stands out as a letter.

So for a system whose only input is one frame, or a handful of sampled keyframes (which is how most multimodal models actually ingest video), there is genuinely nothing there.

The interesting part is what happens when the model is allowed to stop looking and start working.

So it wrote a program instead of looking harder

Given a terminal and the goal, Claude Code treated the clip as a motion problem and wrote a program.

Here is what the program does.

First, it split the clip into 108 frames at 1280×720 and confirmed what we already suspected: every frame on its own is uniform noise, with no readable structure. Point proven, in code.

Then it computed dense optical flow (the Farneback method) between each pair of consecutive frames.

Optical flow is the same math behind slow-motion interpolation and image stabilisation: for every pixel it estimates a small velocity vector, which direction and how fast the texture at that spot is moving. Now, instead of a static picture, there is a field of motion.

The key move is motion coherence.

In a Ghost Font clip the letter dots share a direction and the background dots do not, so for each pixel the decoder compares the “average of the nearby velocity vectors” against the “average of their speeds”.

coherence = | blur(v) | / blur(|v|)

After that, contrast-stretch the result and save it.

The whole decoder is about forty lines of Python on top of opencv and numpy

flows = [cv2.calcOpticalFlowFarneback(a, b, None, 0.5, 3, 20, 3, 7, 1.5, 0)
             for a, b in zip(frames[:-1], frames[1:])]

    s = len(flows) // 3   
    sel = flows[s:s + win]
    acc = np.zeros((H, W), np.float32)
    for f in sel:
        vx, vy = f[..., 0], f[..., 1]
        mvx, mvy = cv2.blur(vx, (k, k)), cv2.blur(vy, (k, k))
        local_mean_vec   = np.sqrt(mvx * mvx + mvy * mvy)
        local_mean_speed = cv2.blur(np.sqrt(vx * vx + vy * vy), (k, k)) + 1e-3
        acc += local_mean_vec / local_mean_speed
    acc /= len(sel)

Run it against the sample clip and the render reads, in three clean lines:

RECOVER THIS MESSAGE

Ghost Font beats the model’s eyes. It doesn’t beat its hands.

“AI can’t read it” quietly assumes the model is a passive eyeball that gets handed a single screenshot and nothing else. That is not how anyone builds with these tools now.

None of this is a knock on Ghost Font. It’s one of the coolest things I’ve seen this month, and the illusion is real.

The point of interest is the headline wrapped around it, because “AI can’t read it”? That’s not entirely true.

What I’d point at a harder clip next

So the obvious next test is a clip where the entire message drifts bodily across the frame (not just wobbling in place), which would need motion tracking layered on top of the coherence map before the letters would hold still. That one’s still open.

The decoder is on GitHub if you want to run it yourself. Point it at any Ghost Font clip, watch three words fall out of the noise, and tell me where it breaks.