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:
The rest of this is how they were built, because the method turned out to be more interesting than the film.
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.
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%.
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.