He Claims to Have Generated a Ghibli Animation with Pure Code; the GitHub Repo Contains Only a 48MB MP4

The video is here first.

Sunrise, mist covering an abandoned forest. A giant robot has been kneeling here for so long that moss, wildflowers, and old trees have grown all over its body. A small bird lands on its shoulder; the first ray of sunlight hits that weathered face, and something flashes deep in its chest. The ground begins to shake, and the bird bursts away from the treetops. It slowly stands up, as dirt, vines, and leaves pour down from its armor. It raises its head, the engine ignites, a ring of wind pressure sweeps across the forest, and it drills into the golden sky, dragging out a curved trail of light and mist.

The poster is X user Chetaslua. He says this is the result of a single generation by the model, written by Fable 5.5, pure code, with no external assets, just a self-contained HTML file dropped directly. His tone is aggressive: video and image models are doomed; in six months no one will care about new video models.

He gave two ways to verify it yourself. One is to ask the model, with internet and memory turned off, 'Where did @karpathy go in 2026?' He says only the new Fable knows the answer. The other is to run the prompt he used.

The screenshot of the test post is below. The answer says Andrej Karpathy joined Anthropic in May 2026 to do pretraining research and used Claude to accelerate the work. The responder added that this was from memory and had not been verified.

What this test is really meant to show is something else: a knowledge cutoff date does not mean the model knows everything that happened before the cutoff. Some things it simply does not remember.

Then there is the prompt. It is very long and very specific: 2D Japanese animation, hand-drawn lines, cel shading, Ghibli-style backgrounds and atmosphere. Original giant robot, no people in the scene. It must look like a frame from a theatrical animation, not like 3D, not like SVG, not like web animation, and not like an AI-generated image. At the end it also says: check random frames; if any frame does not look like real 2D animation, keep revising, do not stop.

The project is called moss-keeper, and the code is on GitHub.

The problem lies in this repo.

A few hours later, commenters started going through the directory. Someone posted the file structure.

His claim was: this is not some rendering engine; it is a 48MB mp4 wearing a trench coat. The README says the film is base64-encoded, and the actual code is only about 9KB.

Another reply was more direct: the page's script converts a long string of text into bytes, labels it video/mp4, and stuffs it into a video tag to play. The file itself is a video; anyone can check.

The poster replied to one of them, saying 'absolutely not a loaded image,' and did not explain further.

There was also a calmer comment in the thread, from Freedom. He said generating with code and generating with video models are two different sets of tools. The advantage of code is that every frame is computed; the robot will not melt or deform, and if you want to change the shot you just change a number. Video models cannot achieve that kind of controllability. But the takeoff smoke in this clip is also clearly several stacked sprites. He asked a key question: were those painted backgrounds drawn by code, or loaded in?

This question determines how much of 'pure code' is left.

Writing a player in JS, decoding the mp4 byte stream and playing it, is code. Computing the pixels of every frame with code is also code. Both can be called pure code, but there is an entire industry between them.

My judgment is that the point of this whole thing stopped being whether the video looks good a long time ago. The film does look good: the composition, the lighting, and the sense of weight when it takes off are all there. But the credibility of a demo does not depend on the finished film; it depends on whether you can reproduce it. The prompt is in the screenshot, the code is on GitHub, and anyone can clone it and run it to know which parts are actually computed. The moment the repo was opened, the discussion shifted from 'model capability' to 'what exactly did you do?'

One more thing worth mentioning. The way this post spread is very typical: first give a finished film shocking enough, then give a conclusion big enough (video models will be dead in six months), and finally give two entry points to 'verify it yourself.' The first half is for spreading; the second half is for making skeptics go dig through the code. There will always be people who dig through the code.