Claude Fable 5.2 wrote the code that renders a 110-second cat's-eye film, with no video generation model
Table of Contents
- What it did
- One shot, 110 seconds, no cuts
- "A cat, not a person crouching"
- The engine: a path tracer written for this one film
- The sound is computed from the same data as the picture
- How the QC works
- Why it matters: this is a renderer and a simulation, not a generated video
- How it compares with the films we render from code
- Limits and observations
- How you can start
- Sources
On November 16, the GitHub account BubbleBrainBB added a 110-second film to awesome-fable-5.2. A cat squeezes under a fence into a botanical garden, stares at a ladybird, meets a bumblebee, drinks at a koi pond, gets pricked by a cactus in the greenhouse, misses a butterfly, and ends up on a stone wall in the sun with its eyes closed. It is one continuous shot, and the camera is the cat's eyes.
It was not made with a video generation model. The first lines of the README say the code was written by Claude (claude-fable-5-2) in Claude Code, the picture and sound were computed by that code, and no AI generation, photos, textures, models, sound assets, Blender or off-the-shelf renderer were used.
Every fact here comes from the repo's main README and the cat-garden README (storyboard, point-of-view design, QC report), checked on November 17, 2026. The repo has no license file, so we do not quote its code or repost its frames. Watch the film itself (304 MB). The picture below is our own illustration.

What it did
One shot, 110 seconds, no cuts
1920×1080 at 30 fps, 3300 frames, with a stereo soundtrack. The garden is one continuous 3D world of about 38 × 30 m, and the cat covers about 45 m of it on a dewy morning with the sun about 28° up. The README's storyboard splits the 110 seconds into 14 stretches. Roughly:
- 0 to 7 s: crawling under a snapped fence board and out of a box hedge, where the auto-exposure lags and briefly overexposes as the garden opens up
- 7 to 31 s: moving in to 7 or 8 cm from a seven-spot ladybird and following it up to the sky when it takes off; a bumblebee flies up to hover in front of the nose and the head turns with it
- 31 to 66 s: sitting up to look down the path while a white butterfly drifts past less than half a metre away; under the bench; drinking at the pond until a koi surfaces and the cat jerks back
- 66 to 92 s: the lens fogs on entering the greenhouse; a sniff at a golden barrel cactus, a prick, a jerk back and a head shake; a crouch and a leap at an orange butterfly that misses
- 92 to 110 s: a jump onto a dry-stone wall, a look back over the route, lying down with two front paws in frame, a slow blink, eyes closed
"A cat, not a person crouching"
Section 2 of the README is about this, and we think it is the best part of the repo.
- Eye height: 20 to 23 cm walking, 10 to 13 cm stalking or crawling, 6 cm above the water when drinking, about 75 cm on the wall. Grass, dead leaves, pebbles and bricks are modelled at real size, so they are large in frame.
- Gait: the step phase advances with distance travelled divided by stride length, so a faster cat steps faster and lengthens its stride at a trot, and each step's bob varies a little. The vertical bob is only 3 to 8 mm, because a cat's head is very steady.
- Gaze: an "attention script" says what the cat is looking at at each moment (ahead, a point, or a particular animal). Head yaw and pitch are each a second-order spring, stiff when something moves (a saccade of about 0.15 s with a little overshoot) and soft when idling. When the target is an animal, the gaze tracks its actual position.
- Focus follows the gaze: the focus distance is a lagging spring whose target is the real distance of whatever is being looked at, so the background dissolves as the cat moves in on the ladybird.
- Small motions: a 6.5 Hz nod while sniffing, a dip of the head for each lap while drinking, a head shake after the cactus.
- Lens: a 96° stereographic projection with slight barrel distortion, depth of field through a 0.72:1 vertical elliptical aperture that borrows from a cat's pupil, 180° shutter motion blur and lagging auto-exposure.
One trade-off is spelled out. There is no cat colour-vision filter. Cats are insensitive to red, but greying out the poppies and the ladybird would cost the picture its looks and realism and turn it into a science demo. Only three things were kept: a wider view, very close near objects and slightly soft distance.
The engine: a path tracer written for this one film
- The host is C++ and Objective-C++, and the renderer is a path tracer in one Metal compute kernel. It does not use Metal's ray-tracing acceleration structures; the BVH is built on the CPU and traversed by hand in the shader.
- About 380,000 instances, 2.16 million unique triangles and about 395 million after instancing, from about 400 prototype meshes: 14 kinds of sod tile, poppies, foxgloves, water lilies, and a golden barrel cactus with about 1500 spines, all built by code.
- Every material is a procedural function in the shader (leaf veins, insect holes, brick, moss, koi patterns, ladybird spots). There are no bitmap textures.
- Wind shears each plant by height; insects and fish get a small BVH rebuilt every frame; leaves transmit light, so backlit leaves and petals glow.
- 16 samples per pixel per frame.
The sound is computed from the same data as the picture
The renderer first exports an event timeline: each footfall with its time and ground type (dead leaves, grass, soil, gravel, stone), sniffs, laps, the distance and bearing of the bee, dragonfly and ladybird from the head, the splash, the landing. The audio script synthesises from that timeline with numpy and scipy, so footsteps land on the steps in the picture, and the bumblebee (a harmonic series around 188 Hz) gets louder and pans with its distance and bearing. The ambience has seven kinds of synthesised birdsong, and inside the greenhouse the outdoor sound is low-passed and lowered under ventilation hum, mist hiss and a short reverb. No music, no narration.
How the QC works
From section 6 of the README and qc_report.txt:
- A guard at render time: the alpha channel of the accumulation texture stores how many samples each pixel actually received, and a frame with any pixel under 16 is rejected and re-rendered. It guards against silent bad frames when the GPU is contended. It never triggered in the full render.
- Frame-by-frame decode check: 0 black frames outside the fade-in and the blink, 0 frozen frames. 22 "lost tile" candidates, each laid out with its previous and next frames and checked by eye: all real content (blades sweeping past the lens, bench slats, motion blur in fast head turns), none a rendering fault.
- An independent re-render: 330 frames (every 10th) re-rendered at 320×180 and compared block by block with the film. Median difference 9.1/255, largest 19.4/255.
- Audio: −19.6 LUFS integrated, −2.1 dBFS true peak, 0 clipped samples; the splash at 58.72 s is 23.1 dB above the preceding 0.2 s. The prick at 84.00 s is only 1.3 dB up, and the README says that sound is probably masked and hard to hear.
What impressed us most is section 8, "What was not verified": nobody, including the model, has listened to the soundtrack, and the film has not been watched in continuous playback; the checks were on sampled frames. It has run on one M4 Max only, byte-identical output across two full renders was not tested, and render.sh has never run from an empty directory in one go. The known shortcomings are just as specific: at 16 samples, large defocused foregrounds and shaded walls are grainy and "boil" in playback; the bricks look like soap; grass does not move when the cat walks through it; the head motion is steadier than a real cat's, closer to a stabiliser.
Why it matters: this is a renderer and a simulation, not a generated video
A video generation model hands you pixels. This repo hands you a program. How the world is built, how light travels, how the head moves, how the sound lines up with the picture and how bad frames get caught are all decisions written down in code. Eye height is a number, focus is a spring, the seeds are fixed, and a single render.sh is meant to rebuild the film from scratch (the author says it has never been run from an empty directory in one go, and a from-scratch run would expose slightly differently from the published film).
Three things stood out to us.
- Scale. About 5000 lines across C++, Objective-C++, a Metal shader, Python post-processing, audio and QC. Not a function or a web page: a small film pipeline.
- Judgement inside a long task. The first full render ran at 20 samples per pixel and had finished only 4 segments after 36 minutes. The model found its speed estimate was off by 2 to 3 times (it had been measured before the trees, hedge and greenhouse existed), so it stopped, profiled, optimised and restarted at 16 samples. All 55 segments of the final render succeeded first time.
- QC as part of the deliverable. The report says what was checked, what was not, and where the film falls short. Version 2 removed a passer-by from version 1 "after feedback" because the figure looked like a dummy, re-rendered only the 9 affected segments in 22.3 minutes, and checked that brightness does not jump at either join.
To be clear, the README does not publish the prompts or the conversation, so we do not know how much direction a person gave or how many rounds they reviewed. What is certain is that the code came from claude-fable-5-2 and that there was at least one round of human feedback (the passer-by).
How it compares with the films we render from code
Ultra Lab renders films from code too, on a much cheaper path: frames are computed one by one in a headless browser (three.js rasterisation, not path tracing), and the music is synthesised with numpy. Both films below have internal reports, and the numbers are from those reports.
A one-person-company short (27.4 s, 60 fps, vertical and horizontal)
- The engine is three.js. Each frame stacks 16 sub-frames for motion blur, plus 7 depth-of-field layers, a sharp text layer, bloom, chromatic aberration and grain. The soundtrack is fully synthesised in numpy with no external assets.
- Rendering one aspect ratio takes about 60 seconds; re-making both ratios end to end (render, mix, upload encodes, checks) takes about 12 minutes.
- Automated checks: the longest still stretch from frame-to-frame differences (limit 0.5 s, measured 0.083 s), per-frame brightness to find black frames, a probe every 0.05 s for any on-screen text crossing a 5% safe frame (548 time points per ratio, 0 crossings), and loudness at −14 LUFS.
- The checks caught something real. The first cut had 5 fully black frames: a rim-light shader raised a negative number to a power at certain angles, got NaN, and bloom spread it over the frame. We fixed the shader and added a script that finds single frames more than 50% darker than their neighbours and re-renders them automatically, up to three rounds. Both ratios came out at 0. It is the same instinct as Fable 5.2's sample-count guard against silent bad frames.
A weekly GitHub top-10 cheat-card short (15 s, vertical)
- The frames are an HTML layout rendered to video by the open-source HyperFrames: ten cards light up in turn, each with its own small animation.
- Before delivery it runs a set of gates: length, loudness at −16 LUFS, safe-zone coordinates for every element, wording rules, and whether the music or main visual repeats recent videos. Black-frame and freeze detection both return 0.
- The ten names and star counts are compared in code against the source ranking, card by card: 10 out of 10.
- The weekly re-run takes about 2 minutes. The first two versions were 3D, but on review every transition looked the same, so the third went back to the cheat-card format.
Side by side, the most striking thing is a shared blind spot. Our one-person-company short's report says the film was never played through or listened to, and so does the Fable 5.2 README. Machine checks prove "not broken, to spec". They do not prove it looks or sounds good. That still takes a person: play it once, listen once.
| Fable 5.2's cat film | Our one-person-company short | |
|---|---|---|
| Rendering | Own path tracer | three.js rasterisation, frame by frame in a headless browser |
| Length | 110 s, one shot | 27.4 s |
| Render time | 183.9 min | ~60 s per ratio |
| Motion blur | 180° shutter | 16 sub-frames |
| Bad-frame guard | Sample count at render | Dark-frame scan after |
| Sound | From event timeline | From storyboard timing |
| Watched, heard? | No | No |
Limits and observations
- Mac only. The three films need macOS on Apple Silicon (Metal), and the renderers are Metal shaders, so Windows and Linux cannot run them directly. Only the still image is plain C++17 and compiles anywhere.
- No license. There is no LICENSE file and the GitHub license API returns 404. Nothing is open for reuse: you can watch and learn from the approach, but not modify, repost or commercially use the code or frames.
- Slow rendering. 110 seconds took 183.9 minutes, and the slowest stretch (just out of the hedge, looking at grass from the ground) took 8.4 s per frame. The README explains that a cat's eye looks along the grass, so nearly every ray grazes hundreds or thousands of blades, and that cost is intrinsic; larger sod tiles, removing the trees and hedge, and simpler distant bounces together gained only a little over ten percent. The hiking film in the same repo is about 5.6 hours of pure rendering; the dive film about 1 hour 45 minutes in total.
- Still short of real. The README's own verdict: single frames from the lawn, the border, the pond and the greenhouse come fairly close to real macro or action-camera footage, but watched continuously it can still be recognised as a render. The sound is all synthesiser timbres, and the birdsong would not be taken for a recording.
- A big file. 304 MB at about 21.9 Mbps, because grain and noise are expensive to encode; the first encode at crf 20 came out at 1.0 GB.
Our take: in this repo, the bottleneck for AI-written film is no longer whether the code can be written. It is render time, hardware, licensing, and whether a person ever actually watches and listens at the end.
How you can start
- Watch the film: cat_garden.mp4 (304 MB), with the storyboard table in the cat-garden README open beside it. Watch the focus during the ladybird at 7 to 14 s.
- Read its "What was not verified" section. When you give an AI a long task, ask for that section in the hand-off. It is worth more than one more round.
- Make a small one on your own machine. You do not need a Mac or a path tracer. We keep open-source video tools in the video and animation section of /picks: HyperFrames, which we use for our cheat cards (write the frame in HTML, render straight to MP4), a local tool that lets coding agents record HTML animations as MP4, and a skill pack for modelling and rendering inside Blender. Every card says whether the license allows commercial use. This collection has its own inspiration card too.
- Add checks from day one. Black frames, frozen frames, text out of frame: one small script each, run on every render before you look. That is how the five black frames in our one-person-company short were caught.
Sources
- awesome-fable-5.2 main README (works, requirements, no-assets statement): github.com/BubbleBrainBB/awesome-fable-5.2
- cat-garden README (storyboard, point of view, engine, sound, timings, QC, shortcomings, what was not verified, revision history): cat-garden/README.md
- cat-garden QC reports: qc_report.txt, audio_report.txt
- The film: cat_garden.mp4 (GitHub release cat-garden-v1.0)
- Mountain Hike README (the edge-tts narration exception, about 5.6 hours of rendering): mountain-hike/README.md
- Deep Dive README (about 1 hour 45 minutes in total): deep-dive/README.md
- Claude Fable 5.2 and upgrading Claude Code: our November 10 write-up
FAQ
Is the cat film AI-generated video?
No. The README states that no AI generation, photos, textures, models, HDRIs, sound assets or off-the-shelf renderer were used anywhere in the film. What Claude Fable 5.2 wrote is code: a path tracer, a procedurally modelled botanical garden, a simulation of the cat's head motion, a sound synthesiser and QC scripts. The picture and sound were computed by that code, and ffmpeg only encodes and muxes.
Can I reuse its code or its frames?
No. The repo has no license file (the GitHub license API returns 404), so the author has not granted any right to modify, repost or use it commercially. You can read the README and the code and watch the films; ask the author before using any part of it. That is also why this post quotes no code and reposts no frames.
Can I re-render it on a Windows PC?
Not directly. The README lists macOS on Apple Silicon (Metal), clang++, Python 3 with numpy, scipy and Pillow, and ffmpeg. The renderer is a Metal compute shader, and Windows and Linux do not have Metal. The full render took 183.9 minutes on one M4 Max.
How long did the whole film take?
From the README's timing table: about 1.5 hours to write the engine, model the garden, make storyboard stills and run three or more rounds of self-critique (estimated from file timestamps); a first full render aborted after 36 minutes because the speed estimate was off by 2 to 3 times; the final render at 183.9 minutes, 3.34 s per frame on average; then 2 min 53 s for despeckle, final encode and mux.
Is the sound computed too?
Yes. The renderer first exports an event timeline (every footfall with its time and ground type, sniffs, laps, the bee's distance and bearing from the head, and so on), and the audio script synthesises from that timeline with numpy, so sound and picture come from the same data. There is no music and no narration. The one exception in the whole repo is the English narration in the hiking film, which comes from the online text-to-speech service edge-tts.