blog

5 min read Field note for CluTerm

One Film, Five Machines

I made a music video about my own mesh, on the mesh. A film is a pure function of time, a Raspberry Pi drew the first scene, and every frame came home with a receipt.

I needed an ad for CluTerm and did not want to make an ad. What I wanted was for the product to make its own: a music video about a mesh of machines, produced by that mesh, with each machine doing a real share of the work and able to prove it.

There are four finished cuts now, each in landscape and portrait. The fourth is on YouTube:

Title card of the film: P(DOOM) v4.5, three rounds, one owner, a CluTerm film. Beside it a dancing figure drawn as white dots. A line in the corner names the machine that drew the frame. Watch on YouTube 2:37
The fourth cut, as revised: its title card says v4.5. The dancer is me, drawn from a depth camera's infrared dots.

The rest of this is how they were built, because the method turned out to be more interesting than the film.

Nine frames from the third cut, one per chapter: a green 1-bit cat, an 8-bit rocket, a 16-bit side-scroller, low-polygon 3D, a vector grid, a network map of five machines, a neon scene, a wall of masked text, and the end card.
One frame from each chapter of the third cut. The line at the top right of every frame names the machine that drew it: the first says a Raspberry Pi 4, the rest say the Mac.

A film is a function

The whole thing is a web page. Every scene is HTML, canvas and shaders, and the page exposes exactly one control: seek(t). Give it a time, it draws that instant. No animation loop, no wall clock, no state carried from the frame before.

That one constraint is what makes everything else possible. If frame 3,338 depends only on the number 3,338, then:

  • any machine can draw any range of frames, in any order;
  • a crashed render resumes where it stopped instead of starting over;
  • two machines drawing the same frame can be compared.

Rendering is then just a headless browser stepping t and saving pictures. The second cut is 4,700 frames at thirty a second; the Mac drew each aspect ratio in under nine minutes, both at once.

Giving the small machines real work

The mesh at the time was a Mac mini, a Raspberry Pi 4, a Linux VM, a Windows PC, and a second Pi that was switched off.

The Mac directed and rendered most of it. The VM’s agent wrote lines. The Windows machine received the finished cuts. And the Pi rendered a slice: the scene bundle gets pushed to it, it draws its frame range, hashes every frame on the Pi, and the frames come home to be re-hashed and counted before the splice will accept them.

In the third cut the Pi drew the entire first chapter, frames 0 through 565, in 375 seconds. That chapter is in 1-bit black and white, which is both an aesthetic choice and a practical one: it is the era a Pi 4 can comfortably draw.

Who drew the third cut: 3,570 frames
Raspberry Pi 4frames 0 to 565, the 1-bit chapter 566 frames · 16%
Mac miniframes 566 to 3,569, six workers 3,004 frames · 84%
render receipts, third cut, landscape
Seconds to draw one frame
Raspberry Pi 4software rendering 0.66 s
Mac minisix pages at once 0.01 s
375 seconds for the Pi's 566 frames; about 30 seconds for the Mac's 3,004. The Pi is some sixty times slower per frame, which is why it got the chapter with two colours. render logs, third cut

There is a badge in the corner of those scenes that says which machine rendered them. The page reads the hostname at draw time, so the badge is written by the machine that did the work. I could have typed “rendered on a Raspberry Pi” into a caption. The point of the exercise was not being able to fake it.

The switched-off Pi did nothing, so it was cast as a sleeping cat.

Deterministic in time is not deterministic in pixels

Here is the result I did not expect. I rendered the Pi’s chapter on the Mac as well and compared them. They are not identical. The mean difference is 0.86 on a 0-to-255 scale: invisible, and not zero.

seek(t) makes the scene a pure function of time. It does not make two different GPUs, two rasterisers and two font stacks agree on the last bit of an anti-aliased edge. So the checks had to be split into what each one can actually promise:

  • Transfer integrity is exact. A frame that left the Pi is the frame that arrived, by SHA-256.
  • Render parity is a tolerance, measured and written down.
  • The splice is checked structurally: the right number of frames, no seam at the joins, the bass drop landing on the frame it was scored for, and the audio within 0.3 dB of the source.

Conflating the first two would have given me either a check that always fails or one loose enough to wave through a wrong frame.

The machines’ lines are real

In the second cut, the on-screen text is what the agents on two machines actually said when asked, eighteen replies from each. The rule printed in the film is “replies real and verbatim, timing edited.” Replies that named real people were dropped rather than edited.

I held to that for the same reason as the hostname badge. An ad about machines that answer back is worth nothing if a person wrote the answers.

The shoot that came back crooked

The fourth cut has me in it, dancing, captured by two depth cameras, one on the Mac and one on the PC, clock-synced across the mesh to about a millisecond and a half.

The footage did not line up. Before guessing, I fitted a floor plane to each camera’s point cloud. A floor is a wonderful calibration target: it is large, flat, and you know its true orientation. The fit said the second sensor was tilted about six degrees and sitting 13 to 14 centimetres low. A registration pass between the two clouds then recovered the rest: a 3.2 degree yaw and a 16 centimetre offset. The share of points agreeing to within 3 cm went from 3.1% to 21.8%.

Points from the two depth cameras that agree to within 3 cm
As shot 3.1%
After registration 21.8%
fourth cut, floor-plane fit then point-cloud registration

Still not a motion-capture stage. But it went from unusable to usable without a reshoot, by asking the data where the cameras were instead of trusting where I thought I had put them.

Eight directors

The third cut climbs through graphics eras: 1-bit, CGA, 8-bit, 16-bit, early 3D, vector, HD, ray-traced, and finally recursion. Each era is a chapter with its own renderer, and each chapter was written by a separate AI agent working in parallel against a shared contract: the seek(t) interface.

Six of the eight ran into usage limits mid-chapter. Because the contract was the interface and not a conversation, resuming them was uneventful. The same constraint that lets a Pi draw frames 0 to 565 lets an agent come back later and finish its chapter.

Small things that mattered: the strobe sections passed a three-flashes-per-second accessibility check, and the first audio encode overshot true peak and was remuxed 1.4 dB lower.

Where the films are

The fourth cut is the one on YouTube. The music is another artist’s track, “P(doom)” by MusicPerson. The third cut’s premise also adapts a public project by John Heibel, and its end card says so.

The film is two and a half minutes. The method is what I would keep if the film were deleted. Make the work a pure function of one variable. Let every participant sign what it did. Decide in advance which of your checks are exact and which are tolerances. That is a render pipeline, and it is also most of what I know about distributed systems.