Writing
Writing 02

How the 3D monitor was made

Claude wrote the code that builds the 3D monitor on my home page. I took the last 10% into Blender by hand.

7 min read

The monitor on my home page looks like an object. It has plastic, a slight taper toward the back, and scuffs on the corners. You can grab it and turn it.

My home page is a terminal inside that monitor, in a small room whose light follows the clock. You can switch the screen between a Mac look and an orange terminal.

So how much of a 3D object can you hand to an AI?

For this one, about 90%, if you count the building: the code, the renders, the plumbing. I know Blender, and I still handed that part to Claude. It modeled the case in a script, ran Blender with no window open, and stood up the whole frame: the model, the faces, the corner strips, the pipeline from model to page. The last 10%, the part that decides whether it looks finished, I did myself, by hand, in Blender. It took longer than the other 90%, because every call came down to taste.

A box that already turned

Before any of this, the case was CSS: six flat planes in a 3D box, drawn with gradients. You could drag it and it would swing back on a spring.

My first idea was to model the monitor properly, export one good image, and put it on the page. That doesn't survive the first drag. A single image is a photo from one angle, and as soon as the box turns, it reads as a cardboard cutout.

So Claude and I kept the box and replaced its skin. Blender renders each face straight on, and each render goes onto its own plane: the front, the bezel, both flanks and the roof. Turn the box and every side is still a real surface.

The same box at the same angle: the CSS case before any of this, and the renders on it now.

The page changes size and a render doesn't, so the front and the bezel are cut like a picture frame: the four corners stay exactly as rendered, and only the flat strips between them stretch.

A visitor can't tell a box from a picture until it moves, so the first visit ends with the case turning to show its side.

The case turned to show its right flank. Every side is its own render.

One command

Everything runs headless, which means Blender never opens a window. One command builds the model, lights it and renders every face:

Blender -b -P scripts/monitor/build_monitor.py -- OUT_DIR

The script is 825 lines of Python. It models the shell, the bezel around the screen, the deck below it and the knob, and renders them with Cycles, Blender's ray-traced renderer, at 96 samples, two image pixels for every CSS pixel.

Then Claude looks at the images, changes a number, and runs it again. For this whole stretch, nobody drags a vertex. A change is one line, like BZ_Y = 0.32 for how far the bezel sits below the top of the case, followed by a fresh set of renders.

The corners that poked out

When the corners got rounded (one of my calls, below), the box broke. Flat planes meet in a knife edge, and those edges stuck out past the round corner like the spine of a book.

Fixing it took more geometry. Along each of the four edges that run front to back, two thin strips now wrap the rounded corner, each showing a render of its own slice of the curve. The case tapers toward the back, so each strip also has a second, angled piece that follows the shell inward.

A second script, 147 lines, works out where each strip sits. It writes both the CSS that places a strip and the camera that renders it, so the page and the renderer read the same numbers and can't drift apart.

One corner of the turned case, without the edge strips and with them.

Cut and uncut

The deck has a floppy slot and a speaker grille, and I wanted them to sit right on any color of plastic.

The script renders each part twice over the same crop, once cut into the plastic and once not. The export keeps only the pixels the cut changed, which leaves the recess and its lip and nothing else. That leftover is a decal: it sits on whatever plastic is behind it.

The slot uncut, cut, and the decal that's kept.

The last 10%

By then the frame was done. The proportions were right and the faces lined up on the page. It still looked like a very good render, not like a thing that had sat on a desk for twenty years.

That's where I opened Blender. The script saves its scene as monitor.blend, so I opened that file, pushed things around until they looked right, and wrote the numbers I landed on back into the script. The next render kept them. The shape I set there: the corners and the tube. The wear and the color I judged on the live page, and the script applies the numbers I picked.

Corners, taper and color off, then on. The wear is added on export, so neither render shows it.

The corners

The first corners were sharp and read as a box with a skin. I rounded them out to 24 pixels, which is what set off the strips above, and rolled the front edge over, so the face meets the sides in a curve instead of a seam. Then I put a 1.2-pixel bevel on every edge in the material. You can't see it as a shape, but it catches a thin line of light, and that line is most of what makes plastic look molded instead of cut.

The tube

A flat box reads as a modern monitor. Real CRTs are deep and taper toward the back, because the tube does. So the shell runs straight for the first 40% of its depth, then narrows to 93% of its width and 89% of its height by the shoulder. From the front you barely see it. Turn the case and it stops looking like a box and starts looking like a television.

The same case from behind, as a straight box and with the CRT taper.

The age

New plastic looked wrong on a computer meant to be from 1984. I added a pass of years on export: the color fades in patches and warms a little, the edges rub pale, fine scratches cross the faces, and dust settles, three times as much on the roof as on the sides. My first pass was too polite. The one that shipped lays it on 1.7 times as thick.

The front and the bezel are two renders laid edge to edge, and when each faded in its own patches, the bezel looked like a tile of a different plastic. Those two fade evenly. Only the flanks and the roof get the patchy wear.

The roof, clean and at the wear that shipped. Dust settles three times as thick up here.

The color

I tried seven plastics, from near white to near black. I didn't judge them as swatches. Each one went onto the actual home page, with the room's clock pinned to 2pm so the light stayed the same between them.

Seven plastics, lightest to darkest.

Platinum was the obvious choice and the wrong one: on a dark site it glowed. Charcoal disappeared into the background. Dark stone, half a step lighter, is what shipped.

Charcoal came back the same day, for the orange terminal screen, so it reads as a terminal rather than a Mac with the lights off. Before the script, that would have meant drawing a new case. This time it was one argument:

build_monitor.py -- OUT_DIR color=charcoal
The Mac screen in dark stone, the terminal screen in charcoal.

The final numbers are easy to type into a prompt. Finding them wasn't: I had to see it, nudge it, and look again.

The part that wasn't the monitor

Under the monitor there's now a small computer of its own, with a disk drive that works (the slot on the monitor's deck is only for show). Three floppies sit on the floor beside it. Drag one into the drive, or just click it, and what's on it starts on the screen.

The first version had one disk per ASCII animation the terminal can play. It worked, and then I asked whether those were really the right ones. They weren't. Now there's one of each kind of thing: a game, music and a surprise. Picking what goes in the drive mattered more than the drive.

A disk on its way into the drive.

At first, a click just loaded the disk, with nothing worth watching. I'd seen an import animation where photos break apart and stream into a card, and I wanted that. Now a click breaks the label into pixels, pulls its colors out into streaks, and the streaks turn into light on their way to the slot. The first version looked like a rainbow bridge. It took 13 commits to make it look like light.

What went wrong

A boolean cut, which carves one shape out of another, silently deleted the whole shell. Exposure that adjusted per color worked so well that every swatch came out looking the same. The local preview server cached old images, so for a while I was judging the previous render.

Then it went live, and using it found the rest. The turn at the end of the first visit stuttered because it started on the page's busiest frame; now it waits for eight smooth frames. In Safari's engine, two edge strips drew as a black shard over the deck, so the four strips that sit behind the base, where nobody sees them, came out. Disks sometimes showed as hollow frames until their labels loaded; now every label sits on solid plastic.

None of the launch bugs showed up in a render.

One thing is still missing. On a phone, the base and the disks don't show at all, because the screen is too narrow to fit them under the monitor.

What I actually did

Claude got it 90% of the way: the script, the headless renders, the corner strips and the pipeline onto the page. I decided the corners, the color, how old the plastic should look, and which three disks deserved to exist. Then I took the last 10% into Blender by hand, and that part took the longest.

I could have modeled all of it by hand. I didn't want to spend my time on the parts a script does better: re-rendering five faces, re-cutting the decals, re-placing the strips and exporting it all again after every change. I wanted my time on the part that decides whether it looks finished.

The frame is the part I hand off. The finish is the part I keep.