Photographing a world nobody had time to look at

Everything below this is machinery. This is what the machinery is for: photographs of other people's buildings, framed by arithmetic, on a server where no human ever lined up the shot.

The world is a community server sixteen eras old. Its save file holds roughly 3.15 million player-placed building pieces. Somewhere in there are the builds worth looking at, and there is no index of them — a Valheim save is a flat bag of objects with coordinates, not a list of buildings.

So the whole job is a funnel: turn a bag of pieces into a list of structures, rank the structures, photograph the top of the list, then rank the photographs.

The first version of this had a person in the middle: read a shot list off a second monitor, teleport, look around, press a key, repeat. That works for twenty shots. It does not work for fourteen hundred.

The fix was to make the plan a file the game reads at startup, and to make the game write back a receipt for every frame it takes. Once both halves exist, the loop closes and the operator's only job is launching it.

The two halves are written in different languages, run in different processes, and cannot call each other. Everything they share is a file. That constraint turned out to be a feature — each handoff is inspectable, replayable, and diff-able.

One deliberately unglamorous choice: the plan the mod reads is tab-separated text, not JSON. The plugin has no JSON parser, it scrapes with regex, and one flat line per shot is far harder to misparse than nested objects.

Every layer already existed for another reason. The world cache was built to answer steward questions. The perception model was on the box for a photo library. The mod started life as a proof that a camera could be moved at all. The work was wiring, not invention.

There are four small pieces of arithmetic in this, and none of them are clever. What made them work was measuring instead of guessing.

1 — Finding a building in a bag of pieces

Building pieces are snapped to a 16 m grid. A cell holding at least four pieces is "occupied". Occupied cells touching in a 26-neighbourhood get unioned together. What falls out is one cluster per structure, with a true 3-D bounding box.

Doing this in three dimensions rather than two is not optional here. This world has builds stacked vertically, and a flat grid merges a sky platform with whatever sits on the ground beneath it — producing "structures" with nonsense five-kilometre bounding boxes.

2 — Where to stand

Given a bounding box and a field of view, the standoff distance is secondary-school trigonometry. The part that took a second attempt was deciding what to frame.

The first version framed on the bounding diagonal, and every photograph came back as a smudge in the middle of a hazy frame. A cluster's diagonal is inflated by sprawl — outbuildings, walls, a dock — so framing on it pushes the camera back past the thing people came to see. Framing on the compact extent instead fixed it: on one build the diagonal wanted the camera 267 m out, the compact extent wanted 136 m. The second one is the photograph.

There is no heightmap. Valheim generates terrain from the world seed and the save holds only objects, so no offline elevation data exists at all. The trick is that a cluster's lowest piece is ground at that build, because a foundation rests on it. Only the in-game runner needs a real ground query, and only to stop a camera landing inside a hillside.

3 — When to shoot

The first planner used time-of-day 0.70 and 0.30 for the two light variants, because those sound like golden hour. Then a 207-frame sweep measured luminance and contrast across the whole day, and both guesses turned out to sit past the good light.

4 — Which frame is any good

The number on a gallery tile used to be the structure's ranking score, which is identical across all six photographs of the same building. It ranks places. It cannot tell a good picture of a place from a bad one, which is the thing a gallery actually needs.

So each frame now goes through a CLIP ViT-L/14 image encoder and a small LAION aesthetic head — the same model and weights already sitting on the box for an unrelated photo library. No new download, no new dependency.

The clearest way to explain a pipeline is to show what falls out of each end of it. These are real records from the run that produced the photographs above, with coordinates removed — they attribute real builds to real people, and this is a public page.

A cluster's identity in the save file is cluster 439. That is useless in a gallery. The obvious fix — read the prefab names and infer "this is a longhouse" — does not work: the analytics cache stores prefabs as hashes like hash:538325542, and the offline name table holds 617 item names and no building pieces at all.

So the naming step skips the metadata entirely and shows a vision model the photograph. It gets back a name, a one-line description, and a feature list.

• Prefab names are hashes. "Dominant material" is a stable ID, not a word. The fix is a one-time in-game dump of the prefab table, joined thereafter.
• Builders are numbers. 351 distinct creator IDs across the ranked clusters, none of them zero — so attribution works, but turning an ID into a name needs records that only exist in the running server.
• No metric can judge a photograph. The aesthetic head sorts competently and is confidently wrong at the edges. It is a filter that makes a 1,411-frame pile reviewable, not a critic.
• Dense forest still eats the camera. The occlusion raycast catches a wall in front of the lens. It does not catch a pine branch across a third of the frame.
• It runs on one machine. The world cache, the model weights, the game install and the gallery are all local. Nothing here is a service, and this write-up is not a promise that it will become one.