---
title: "Tiny Perth · projects"
url: "https://colindismuke.com/build/tinyperth"
description: "All of greater Perth, from Mindarie to Henderson, drawn in one hand-drawn style by a small image model I trained, with traffic, trains, footy and weather moving on top."
published: "2026-11-19T03:40:19.961Z"
---

[projects](https://colindismuke.com/build) live 2026  19 nov 2026 

# Tiny Perth

All of greater Perth, from Mindarie to Henderson, drawn in one hand-drawn style by a small image model I trained, with traffic, trains, footy and weather moving on top.

#maps#perth 

[↗ live ](https://tinyperth.com) [↗ repo ](https://github.com/cpdis/tinyperth) 

Area**2,200 km²**

Pixels**\~20 billion**

GPU hours**\~165**

All-in cost**$726**

Can you draw a whole city by hand without a hand?

That was the bet. Not "can an AI make a pretty picture of Perth," because it obviously can, once. The question was whether you could make a map of the entire metro area, Mindarie to Henderson, the hills, Rottnest, every house and every tree, in one consistent hand-drawn style, where you can zoom from the whole coast down to a single backyard pool and never find the place where one picture stops and the next one starts.

I'd never rendered anything in 3D. I'd never trained a model. I'd never rented a GPU. I'd seen [tiny.london](https://tiny.london) and thought: Perth deserves one of those. So I tried it, and kept a journal, and this is what actually happened.

Short version: it works. It cost about the price of a decent bike. And nearly every interesting thing I learned came from something breaking quietly.

## The trick

You can't ask an image model to draw 2,200 square kilometres. It draws about 300 metres at a time. Ask it twice for two neighbouring squares and you get two different artists who've never met.

So the whole project is a pipeline for faking one artist:

1. Photograph Google's 3D model of Perth from one fixed camera.
2. Get a big, expensive model to redraw a few hundred of those photos in the style I wanted.
3. Teach a small, cheap model that style from those few hundred examples.
4. Let the small model redraw everything, in overlapping pieces that are forced to agree.
5. Clean up the water. (Always the water.)
6. Cut it into tiles and put it on the internet.

![](https://colindismuke.com/images/projects/tinyperth/phase1-explained/pipeline.svg)

Each step is simple. The hard part is that each step can fail in a way that looks like success.

## Step one: a camera that's infinitely far away

A normal camera has perspective. Towers lean away from the centre of the photo. Take two photos side by side and the same building leans two different ways, and they'll never line up.

The fix is an orthographic camera: every ray parallel, as if the camera were infinitely far away. A building looks identical anywhere in the frame. A "shot" is just a window you slide across the city by whole pixels. Neighbours meet perfectly, by construction.

![](https://colindismuke.com/images/projects/tinyperth/phase1-explained/camera.svg)

Mine sits 20 km back from the CBD, looking north-north-east, tilted 45°, at 0.293 metres per pixel. A web page on my laptop loads Google's 3D tiles and Chrome draws them on the laptop's own GPU. No cloud needed yet.

Every shot also saves a depth image, the distance to every pixel. That let me sanity-check the whole thing against reality: the Bell Tower measures about 78 m above the quay. The published figure is 82.5 m. Close enough that I stopped worrying.

Then I rendered inner Perth. 731 shots. The script finished with a proud **"731 rendered, 0 failed."**

It was lying.

![](https://colindismuke.com/images/projects/tinyperth/full-render/run1-overview.webp)

I'd cranked parallel downloads from 32 to 96 to go faster. Google started refusing requests. My renderer treated a refused tile as a finished tile, saved whatever blurry stand-in was on screen, and moved on. A whole band of the city came out blank or mush. The log was accurate and completely useless. I only saw it because I shrank every shot to a thumbnail and laid them out as one picture.

That became rule one for everything after: **look at all of it at once, every time.** Not the log. The picture.

The second run was clean. So was the third, bigger one: 4,640 shots for greater Perth, about 19 hours of my laptop downloading at 3 to 6 MB/s.

Network

Download during the larger render

4,640 shots · about 237 GB · peak 8.1 MB/s

- Megabytes a second, 4-minute averages

Perth time · from the laptop's byte counter, logged every 2 seconds

Except it wasn't clean either. Google's tile session quietly expires after about four hours, and every shot after that came out soft. Same failure, different cause. Now every shot records how many blurry tiles were on screen, and nothing gets drawn until a check reads those records.

## Step two: arguing with Gemini about water

Nobody has ever drawn Perth in this style, so there's nothing to train on. You have to make the training data. I used Gemini as the "teacher": hand it a render, tell it how to draw, get back a drawing. About 14 cents and 20 seconds each.

The rule I set early: tell it **how** to draw, never **what** to draw. No place names, not even for landmarks. Say "Optus Stadium" and it draws the stadium it remembers, not the one in the render.

It took nine versions of the prompt to get the look. Each one fixed something and broke something else. One painted the paving at Elizabeth Quay bright orange. Two drew pale halos around the river shore. And one, which asked for "pale turquoise shallows where the image has them," drew pale turquoise stripes across perfectly calm river.

![](https://colindismuke.com/images/projects/tinyperth/phase1-explained/looks-elizabeth-quay.webp)

That's the lesson I'd give anyone prompting an image model: **every noun lands somewhere.** If you mention a halo, even to forbid it, you get halos. The fix for water wasn't better words. It was fewer. A tiny script now measures each frame's actual water colours from the render and states them as numbers. One tone if the water's flat, the real range if it isn't. Water went from 3-in-6 right to 6-in-6.

Then I got a second opinion: a different model, told to attack my choices. It found three things I'd missed. My prompt named an "ochre" for dry ground, and that ochre was eating lawns. Drawing each frame as four enlarged quarters gave far more detail for the same price per call. And sending an example drawing along with each request was a disaster: the example's houses got pasted into 7 of 15 drawings. Two put houses in the river.

![](https://colindismuke.com/images/projects/tinyperth/fable-review/reference-copied.webp)

## Step three: 426 drawings nobody will look at

The small model needs a few hundred lessons that between them cover every kind of place in Perth. I picked 349: 28 landmarks, 90 "hard places" (ovals, pools, jetties, freeways, golf courses, the stuff most likely to go wrong), and 119 general frames chosen so that marinas get as many examples as plain suburb. Four places, Floreat, Osborne Park, Herdsman Lake and Point Walter, were locked away and never trained on, so I'd have honest ground to test against later.

Nobody can eyeball 426 drawings. So a program does: did the lawn stay green, are the outlines where the render's outlines are, is this even the same scene? A failed drawing gets set aside with its reason and drawn again. Every one of those checks exists because a real drawing failed that exact way first.

![](https://colindismuke.com/images/projects/tinyperth/teacher-job/loop.svg)

The full run took 34 minutes and **$57.94**. 342 of 349 passed. One check cried wolf on flat water, where there's no light and dark to compare, and threw away about $5 of perfectly good drawings before I caught it.

Then I looked at the landmarks and hated them. The Narrows Bridge, drawn as four quarters in four separate calls, had four different road decks. I tried two fixes on the teacher. Neither worked.

So I stopped polishing and asked a cheaper question.

## Step four: $1.50 that answered two days of fiddling

The small model is FLUX.2 klein 4B, an open model with 4 billion parameters. You don't retrain all of that. You train a LoRA, a little add-on of a few million numbers that sits beside the model and bends its style. Training is just: show it a render, ask for the teacher's drawing, measure how wrong it was, nudge. Repeat 2,000 times.

I rented one H100 on Modal, which bills by the second. Run time: 22.7 minutes. Cost: about **$1.50**.

By step 250 it had the look. And the thing I'd spent two days and $80 agonising over, quarters that didn't agree, just vanished. The small model learns one style from all the lessons together. The teacher's inconsistencies average out.

![](https://colindismuke.com/images/projects/tinyperth/pilot/test-floreat.webp)

That's Floreat, which the model had never seen. Left to right: the render, the untrained model, 250 steps, 2,000 steps.

If I could send one note back to the start of this project, it would be: **train a rough model on day one.** It's the cheapest way to find out which of your problems are real.

## Step five: forcing the artists to agree

The model draws one 1,024-pixel square. The city is about 250,000 pixels across. Draw neighbours separately and they disagree at the edges.

Image models build a picture in about 25 passes, from pure noise to finished. The joint sampler runs the model on many overlapping windows at every one of those passes and blends their answers before moving on. Every second pass, the grid of windows shifts by half a window, so no edge stays put. No window ever gets to finish on its own. They have to agree.

![](https://colindismuke.com/images/projects/tinyperth/area/city.webp)

That's central Perth, 1.9 km across, as one picture. On land there's nothing to find.

Water was different. Water gives the windows nothing to agree about, so each one settles on its own blue and you get a patchwork river. Hold that thought.

The whole map is still too big for one go, so it's drawn as overlapping areas of about 2.8 km, and each new area is pinned to the finished ones: at every pass, the overlap is forced back to the neighbour's pixels and the model draws the rest to fit.

The first block of four areas had a pale band down every join. About 20 brightness levels too light, 256 pixels wide. It looked like a matter of taste. It was a bug, and the width gave it away: 256 px is exactly how much two windows overlap. The model never sees pixels directly. An encoder squashes each window into a small grid of numbers first, and that encoder isn't local. I'd been placing the neighbour on a black background, and black in one part of a window made the rest of it encode too bright.

![](https://colindismuke.com/images/projects/tinyperth/block/band-before.webp)

![](https://colindismuke.com/images/projects/tinyperth/block/band-after.webp)

Before and after. One minute of measuring named a bug I could have spent a week "tuning."

It came back once more at the very end, in the corners of the big map, where the render itself runs out into black. Same cause, same cure: never let the encoder see black.

## Step six: ten GPUs and a bill I hadn't read

The map gets drawn in waves: batches of areas that don't touch, so each gets its own GPU and they all run at once. A little driver program picks the wave, rents the GPUs, waits, picks the next. The first map, inner Perth, was 62 areas over two days, about **$95**.

![](https://colindismuke.com/images/projects/tinyperth/greater/modal-containers-phase2.png)

Ten H100s at once, each dip a gap between waves.

That first run also hit a limit I hadn't read. Modal has two: a usage limit, and a spend limit on your card. I'd checked the first. The second killed the whole account 25 minutes into a wave of ten. Nine half-finished areas, gone. A GPU that's stopped halfway through a picture gives you nothing for the money.

That was the last time a step got to trust itself. From then on everything checks its own output. Every area measures the brightness step at its joins: good joins read under 5, the band bug read 20, and anything over 8 stops the whole run. The driver reads my actual bill before every wave and won't start one that could cross either limit. That guard stopped the big map four times. Twice it was right (the corners). Twice it was open ocean, which is supposed to be patchy until the water gets repainted. Each stop cost me time, never money.

## Step seven: Google's patchwork

Google's aerial photos of Perth were taken on different days, in different seasons. Out in the hills, the render is a quilt with dead-straight seams: dark here, hazy there. And the model, being a good student, draws exactly what it sees.

![](https://colindismuke.com/images/projects/tinyperth/greater/tone/tone-edge.webp)

I tried teaching the model to ignore the seams. Didn't work, because the seams aren't just colour: the trees genuinely look different in summer and winter. What worked was fixing the input. The Sentinel-2 satellites photograph the whole region in one pass, so one cloud-free pass has the same light everywhere. It's far too coarse to draw from, 10 metres a pixel. But it knows what colour every 100 m of ground should be. Nudge Google's render toward that at the 100 m scale, keep all of Google's fine detail, and the quilt flattens out.

![](https://colindismuke.com/images/projects/tinyperth/greater/tone/render-evened.webp)

(Licence footnote that matters: the ready-made cloud-free mosaic I tried first is non-commercial and share-alike. The raw satellite passes are open for anything with one credit line. That's why the map says _Contains modified Copernicus Sentinel data 2026_ in the corner.)

## Step eight: always the water

The model draws land beautifully because land is full of things to follow. Open water has nothing, so it invents streaks and every window picks its own blue.

So the water gets repainted. OpenStreetMap knows where water is. Anything near the shore, and anything the render shows as brighter or darker than the water around it (boats, jetties, buoys), stays as drawn. The rest becomes flat bands that follow the render's brightness, in the model's own colours, from one table learned across the whole map so nothing steps at the seams.

![](https://colindismuke.com/images/projects/tinyperth/area/water-city.webp)

One last silent failure, found on the final day: my water lookup decided "sea" by checking whether any coastline lay between a point and the open ocean to the west. Rottnest and Garden Island have coastlines too. So the strait and Cockburn Sound were, as far as the code knew, dry land. It now counts coastlines crossed. Even means sea.

## Step nine: a home on the internet

Nobody downloads a 20-billion-pixel picture. A web map uses a **tile pyramid**: the same picture saved at every zoom level, each half the size of the one above, all cut into small squares. Zoomed out, your browser fetches a handful of squares. Zoomed in, it fetches only the ones on screen. The big map is 100,578 tiles in 10 zoom levels, 6.6 GB.

The tiles sit in Cloudflare R2, which is cheap file storage that doesn't charge when people download from it. The page itself is a few static files on Vercel, which rebuilds the site every time I merge a change on GitHub. The viewer is OpenSeadragon, a free library built for exactly this: huge zoomable pictures. I bought tinyperth.com for it.

The first version was a bare viewer: a map and a zoom button. The second one is the one you see now. It's a pixel-art frame in Perth colours (sand, red-earth ochre, eucalyptus, Indian Ocean blue and wattle) with a pixel black swan for a logo. It has search (press `/`), a minimap, a strip of 13 landmark cards, a Play menu for the games, a share button and a dark mode. The landmark thumbnails are cut from the map's own tiles, so nothing on the page is a photo. It opens on the CBD rather than the whole map, close enough that you can see it's drawn.

![The map page in light mode, with the Life panel open](https://colindismuke.com/images/projects/tinyperth/ui/desktop-light.webp)

![Dark mode on a laptop and a phone](https://colindismuke.com/images/projects/tinyperth/ui/dark-desktop-phone.webp)

## Step ten: making it move

A still map is a postcard. The tiny cities people remember have things moving on them: traffic, boats, birds. So the last stretch of work went on life.

None of it touches the drawing. A transparent canvas lies over the map, and 60 times a second the page wipes it and draws every car, ferry, footy player and plane in its current spot. The tiles never change.

The hard part is putting a thing in the right place. The camera looks down at 45°, so something 1 m higher is drawn 2.4 pixels further up the screen. Put a footy oval at the wrong height and the players run around on the grass beside it. This is what the depth image from step one was for. Every shot saved the distance to every pixel, and a distance plus a pixel gives you a point in 3D, so the ground's height. It also tells you when something stands between the camera and the ground: if the depth at a spot on the oval is shorter than the oval's own distance, a roof is in the way. At Optus Stadium, 50 of the field's 192 grid squares are under the south stand's roof, and no player is drawn there.

All of that is worked out in advance, on my laptop, by a script that turns places from OpenStreetMap into map pixels and writes small data files. Programmers call this **baking**. The browser just reads the result.

![Footy at Optus Stadium. The players nearest the camera are hidden by the stand's roof](https://colindismuke.com/images/projects/tinyperth/life/footy-optus.gif)

What's on the map now:

- **Sport.** Footy from April to September, cricket the rest of the year, at Optus Stadium and on suburban ovals at the weekend. The matches are tiny simulations, not real games.
- **Traffic.** 4,553 km of freeway and main road from OpenStreetMap, cut into 3,962 chains. Cars keep left, drive at the road's speed, slow for the car in front and crawl in the peaks.
- **Trains.** Transperth's real timetable: 3,492 trips on a weekday, worked out from the clock alone, so every visitor sees the same train in the same place.
- **Water and air.** Ferries on their timetable, yachts that sail faster when the afternoon sea breeze comes in, black swans and pelicans, and live planes from the positions aircraft broadcast.
- **Weather and night.** Perth Airport's live weather report drives cloud shadows, rain, fog and the wind on the yachts. After sunset the whole map dims under a blue tint, and headlights, street lamps and lit windows glow on a layer above.
- **People.** Runners round Herdsman Lake and Lake Monger, cyclists by the Narrows, beachgoers between the flags, and the A-frame sandwich boards outside all 45 cafés that sell Filament Coffee.

![Morning peak on the Narrows Bridge and the Kwinana Freeway](https://colindismuke.com/images/projects/tinyperth/life/wave2/cars-narrows.webp)

![The CBD at 9.30 pm](https://colindismuke.com/images/projects/tinyperth/life/wave2/night-city.webp)

The first night tint was a heavy navy that hid the drawing. The first runners were drawn one screen pixel per sprite pixel, and were just dots. The first sandwich boards were a black square with an F on it. Most of the work on life was turning things up or down until they sat with the drawing instead of on top of it.

![The four poster designs on the Filament boards, enlarged](https://colindismuke.com/images/projects/tinyperth/life/boards/sprites.png)

![A board outside a café, before and after](https://colindismuke.com/images/projects/tinyperth/life/boards/flo-before-after.webp)

None of this cost money. No GPU, no image model, and every data source is free. The planes and the weather each come through one small function that all visitors share, so a busy day doesn't mean more requests.

## Step eleven: cars on the drawn road

Zoom in and some of the cars were driving on the verge.

There are three maps in play, and they don't quite agree. OpenStreetMap's road centre lines are off by a few metres in places. Out of the inner city the heights were coarse (more on that in a moment). And the drawing model, redrawing the render, sometimes shifts a road a little. Each one nudges the line the cars follow off the asphalt.

So the roads get **snapped** to the drawing. Every 8 m along each road, a script reads a strip of the finished map across the road and finds the asphalt by its colour. Where the band the cars drive in is mostly off asphalt, the line moves the least distance, up to 20 pixels, that puts it back on, smoothed over about 100 m so it doesn't wiggle.

It took six versions, and the failures taught the rules:

- Shifting a whole area at once dragged good roads onto footpaths.
- Perth has red asphalt. The first colour test read it as "not road", while the shadow of a tree read as road.
- A divided road is two one-way lines. Snapped freely, both collapsed onto the same side. Now a carriageway may never move towards its twin.
- A guard checks every 320 m stretch and keeps the move only if it clearly helps and almost nothing that was on the road comes off it.

![Three spots before (red) and after (cyan): lines on the verge and median now run down their own carriageways](https://colindismuke.com/images/projects/tinyperth/life/road-snap-before-after.webp)

Across the whole map, the share of road where the cars' band is 90% or more on drawn asphalt went from 50% to 56%. That sounds small. The colour test is strict on purpose, so the real figure is much higher than either number. In an early test around Optus Stadium, before the whole-map run, the share of road stretches with cars fully on the drawn asphalt went from 55% to 80%. What convinced me was looking: of 18 spots checked by eye, 17 were right, and the one miss is a divided road whose other half isn't in OpenStreetMap.

The same night, I noticed street lamps glowing out over the black past the edge of the map. The roads and train lines from OpenStreetMap carry on well past where the map is drawn, and the lamps followed them. A last script now walks every road and track and hides any stretch with no drawing under it, with a 24-pixel margin so lamps beside a road at the edge stay on the map. That hid 824 km of road and most of the outer Mandurah, Ellenbrook and Armadale lines.

## Step twelve: the depth I threw away

Here's a mistake that cost me a day and no money.

The big map's 3,909 shots were all rendered with depth images. Only the colour images were uploaded to the cloud for drawing, and when my laptop ran low on space, I deleted the local copies. At the time, nothing needed them. The next day the moving layers did.

For a while the outer map took its heights from a free satellite elevation model with a point every 30 m. That's fine for a footy oval and poor for a road on a hillside, where a few metres of height is a few pixels of screen.

Heights

Where the moving layers get their ground height

Inner map 731 shots, outer map 3,909 · widths to scale

Before re-shoot30 m grid

After re-shoot0.29 m

7313,909 shots

- Depth image from the render, one height per 0.29 m pixel
- Satellite elevation grid, one point every 30 m

1 m too high is drawn 2.4 px too far up the screen · the re-shoot took about 19 hours and under 10 cents of tiles

The fix was to render the depth again: 3,909 shots, about 19 hours of my laptop, 0 failed, and under 10 cents of Google tiles. This time both sets of depth images went straight to the cloud as well, so the next disk cleanup can't touch them. Then everything was baked again from the new depth, and the roads snapped and clipped again on top.

One thing got worse with better data. Lit windows at night are found in the depth image: a wall facing the camera shows as height climbing up the picture. In the outer map that test also fired on bush on hillsides and tall trees: 73,000 "windows", nine times as many as before, glowing in the forest. Lit windows stay in the inner city.

The lesson: a cleanup is a one-way door. Before you delete anything a render made, copy it somewhere you won't clean.

## Step thirteen: letting agents drive

Some visitors won't be people. An AI agent might open the map for someone who asked it about Perth. I wanted Tiny Perth to work for those visitors too, without adding anything that could cost money when a stranger uses it: no text box, no model call, no server that does work on request.

- **Every control is a link.** `?place=optus-stadium&at=19:40&season=footy&wx=RA` opens a wet footy night at the stadium. The view, the hour, the season, the weather, the layers, the theme and the games can all be set from the address.
- **The page has an API.** A script running in the page (or an agent driving a browser) can call `tinyperth.flyTo("Cottesloe")`, ask `tinyperth.whatsHere()` what's on screen, set the time, or get a link to exactly what it's looking at.
- **It explains itself.** `/llms.txt` is a plain-text guide written for AI models, a growing convention: what the map is, the link grammar, the API, and how a map pixel maps to latitude and longitude.
- **New life can be a file.** A "scene" is a short data file that says which sprite, where, when and how many. One engine draws every scene, and a checker refuses anything that breaks the rules: points off the map, too many figures, no credit. So an agent can add runners to a park without writing code.

Adding a whole system that's meant to change nothing visible raises a question: did it really change nothing? So a test harness opened the same 132 views of the map, in a browser with the clock and the dice fixed, against the site before and after. It compared every drawing call (over 21 million of them), the finished pixels, and a full-page screenshot. All 132 were identical. Then it checked itself: the same code twice matched 33 of 33 times, and one dark pixel slipped into each frame was caught 33 of 33 times. A pass that can't fail tells you nothing, so you prove it can.

## Step fourteen: a chart around the map

The map used to end in a staircase. Each drawn area is a square, so the coast and the ocean stopped in steps, and Rottnest floated on its own little raft in a flat void. It looked unfinished because it was.

![Before: the drawing stops at the stepped outline of the last tiles](https://colindismuke.com/images/projects/tinyperth/edge/before.webp)

I tried four treatments: endless ocean, a diorama base, clouds, and a nautical chart. The chart won. Then it got real data: land heights from Geoscience Australia's 1-second elevation model, and sea depths from its AusBathyTopo 250 m model of the sea floor, both free to use with a credit. Each pixel of the chart is treated as a ray from the map's camera, the same maths as the render, so the coast, Lake Joondalup and the wetlands land exactly under the drawing, and Garden Island and Cockburn Sound appear south of it.

The look I picked is a relief chart. Land is tinted by height and shaded in dithered pixels, so the Darling Scarp stands up in the east. The sea goes from pale shoals to the deep blue of the Perth Canyon. On top sit contours, a latitude and longitude grid, a compass rose, a few soundings (depths in metres) and spot heights on the hills, in a tiny pixel font.

![Zoomed out as far as the map now allows](https://colindismuke.com/images/projects/tinyperth/edge/final-light-max-out.webp)

You can no longer zoom out or pan past the chart, so you never see the void again. Planes vanish as they reach its edge, and cars and boats fade out with the drawing.

![The same at night](https://colindismuke.com/images/projects/tinyperth/edge/final-dark-max-out.webp)

## The bill

Spend

What each step cost

US dollars · about $726 in all

Look tests$13.75

Teacher drawings$63

Training, first areas$11.80

First map, 62 areas$95

Larger map, tests$6.51

Larger map, phase 1$49

Larger map, phase 2$256

Larger map, phase 3$230

- Gemini (teacher)
- Modal GPUs

Summed from runs/ledger.tsv · rendering with Google's tiles cost under $2

Gemini (teacher)**$77**

Modal GPUs**\~$650**

Google tiles**< $2**

Moving layers**$0**

About **$726** all in, and $542 of that is the big map. My first estimate for the big map was $440\. It was wrong by $100 because I took the cost per area from the first map, which had lots of cheap little edge-of-the-ocean areas. The big map is mostly full land areas at about 27 minutes of H100 each. Take your unit cost from units like the ones you haven't done yet.

The reason the bad estimate didn't hurt: the driver doesn't trust estimates. It reads the real bill before every wave. The mistake changed how far each phase got, not what got spent without my say-so.

Everything after the drawing was close to free. The moving layers, the snapping, the agent features and the edge chart run on my laptop or in the visitor's browser, and every data source they use is free. The depth re-shoot cost under 10 cents of Google tiles. Once the map existed, the expensive part was over; the rest was time.

## What's still wrong

Way out at sea, where Google's photo of the ocean ends, there are some rectangles of textured water that the repaint leaves alone. The weed in the south-west shallows is louder than the rest of the map. And on open water, if you go looking, you can still find a few faint seams.

On land, I can't find one. I've tried.

The moving layers have their own list. Some cars still drive a little off the drawn road, and one divided road out east has a line in the wrong carriageway because its other half isn't in OpenStreetMap. Lit windows only appear in the inner city. And the matches, boats, birds and beachgoers are made up to look right; only the planes, trains, weather and sun are real.

## What I'd tell you if you're about to do this

Look at all your output at once. Make failures loud before you make anything fast. Spend your first dollar on the scariest question: a $2 probe, a $1.50 model and a 50-cent test area each changed my plan more than a day of thinking did. Measure the thing that looks like taste, because it might be a bug with a width. Read every number on the billing page. Back up whatever a render makes before you delete anything. And keep a journal with pictures as you go, because half the images on this page could never be made again.

Now go [zoom in on Perth](https://tinyperth.com) and try to find a seam.

---

_Credits: 3D city model from Google Map Tiles. Contains modified Copernicus Sentinel data 2026\. Chart heights and depths from Geoscience Australia (SRTM 1-second DEM-S; AusBathyTopo 250m 2023), CC BY 4.0\. Water outlines, places, roads and railways © OpenStreetMap contributors. Train timetable from the Public Transport Authority of WA; this data is available free of charge from [www.transperth.wa.gov.au](http://www.transperth.wa.gov.au). Ground heights from Copernicus DEM GLO-30\. Weather from the Bureau of Meteorology via aviationweather.gov. Live planes from adsb.lol. The Life panel's controls are UI SDK. Teacher drawings by Gemini; small model FLUX.2 klein 4B, trained with ai-toolkit. Inspired by [tiny.london](https://tiny.london), using none of its images, model or prompts. Built with Claude._
