Citadel — the boot-up terminal, and the logo of a company you are not yet supposed to be suspicious of

Citadel is out.

It is a first-person shooter for the Mac, in the Doom idiom, and it is the ground war of the story that started with Strataris. That game was the air war — you flew low over six colony worlds and held the sky against a marauder fleet for as long as you could. You did not hold it long enough. This is what happened next.

The swarm landed. The colonies of Demeter, Tantalus, Boreas, Pandora, Vulcan and Vesper went dark, one after another. Everyone who could get underground got underground, and then something followed them down. You spent all of it in a medbay bunk with a head injury, which is the only reason you’re alive and the reason you remember none of it — and it leaves you, when you finally stand up, as the only trained soldier still standing down there.

So you go down there on foot. Forty-eight floors. Six citadels, eight levels each, all the way to the bottom of every one of them.

It’s free, like everything I make. It’s public domain, source and all. And I am, if I’m honest, prouder of it than of anything else I’ve built.

The rule that changes everything

Here is the single design decision the whole game hangs off, and it took me an embarrassingly long time to realise it was the good one.

Every floor is held by a Queen — a rooted, enormous brood-mother who births fresh drones for as long as she’s alive, hates your headlamp, and sits between you and the freight elevator. Only the plasma rifle wounds her. Fine. That’s a boss fight; you’ve had a hundred of those.

Except when she goes down, she isn’t dead. She’s down. And if you walk away, she gets back up, and the floor never ends.

To finish her, you have to walk up to the body and burn it. Flamethrower. Close range. Standing over the thing you just killed while its drones are still coming, holding a trigger, watching a fuel gauge that only tops up at a drum somewhere else on the floor.

That one rule reorganises the entire game underneath it. Fuel stops being a weapon and starts being a budget — every gout you spend on a drone in a corridor is fuel you won’t have for the thing that actually matters. The plasma rifle and the flamethrower stop being alternatives and become two halves of one job. And the fight has a coda: there’s no clean moment of victory where the music swells and you walk out. There’s a body, and a chore, and it has to be done properly.

I didn’t design that from first principles. I stumbled into it while trying to solve a completely different problem, played it once, and knew immediately not to touch it again.

The flamethrower is a genuine volume of burning fuel — it blooms, it rolls, it goes sooty, and it lights the room as it goes

Two castes, three weapons, and a lot of arithmetic

The colony holds one organism in two forms. The drone is a slick green-black melee hunter — slow, but it is not stupid. It comes in numbers, it comes around corners, and it will happily let you commit to the one in front while two more work their way down the flank. It has to reach you to hurt you, which sounds generous until three of them have you in a doorway. And the Queen sits at the heart of the floor making more of them for as long as you leave her alive.

Against that you carry the plasma rifle and the flamethrower permanently, and you’ll find a rocket launcher out in the field. The rifle is the workhorse and the only thing that wounds a Queen; it will nudge a shot onto a nearby target for you, but the cone is narrow and deliberately unhelpful — it is an assist, not an autopilot. The rockets hit hard enough that standing too close to your own blast is a real and recurring way to die. And you carry proximity mines, which you can walk over and the swarm cannot, which is the entire point of a mine.

Everything is finite. Every plasma cell, every litre of fuel, every rocket you’re carrying. What keeps it from being miserable is that the colony itself is the supply line: shoot a fuel drum and it ruptures into a bomb, or stand beside it and it refills your flamethrower. Plug into a wall-mounted recharge socket and it tops up your cells — and sockets slowly rebuild their own reserve, so a floor you’ve stripped bare will have a little something for you if you come back through it later. You are never permanently starved. You are, permanently, doing sums.

A drone comes over the fuel drum. Shoot the drum, or shoot the drone.

All light is man-made

You are underground for the entire game. There is no daylight, no skybox, no ambient glow from nowhere in particular. Every single photon in Citadel comes from something you could point at: a bulkhead lamp, a flickering terminal, the sick green self-light of a nukage pool, the fire you just started, and the lamp on your own helmet.

That sounds like a technical note. It is actually the whole atmosphere. The upper floors of a citadel run bright — the fixtures still work up there, mostly. The deeper you go, the more of them are out, until by the bottom of a building you are essentially carrying the only light in the world and the corners are genuinely, unhelpfully black. The lowest floors are flooded, so you wade, and you can hear yourself doing it.

There is no status bar. I tried one; it made the game feel like a spreadsheet with monsters. So the 3-D view fills the entire screen and every readout is projected onto the inside of your helmet visor instead — vitals, weapon pods, a live cells/fuel/mines telemetry strip, and an Aliens-style motion tracker with an objective caret riding on its rim. The caret points at the living Queen. Once she’s ash, it swings around and points at the exit. You never need to open a menu to know what the floor still wants from you.

I will not pretend the debt to Ridley Scott isn’t enormous. Wet corridors, a crew that didn’t make it, a corporation whose logo is on everything and whose intentions you should probably examine, and a thing in the dark that is better at this than you are. Alien is the reason I find industrial corridors frightening, and Aliens is the reason I find a chirping motion tracker frightening, and I have taken both entirely without shame.

I told you it was all equations. I was wrong.

In July I wrote a post explaining, at some length and with obvious pleasure, that this game had no models in it. Not one. The world was a signed distance field — every wall, every pipe, every rusted surface and every monster described as a mathematical function, sphere-traced on the GPU, a few hundred thousand times a frame. A corridor is an equation. I was thrilled with myself.

Reader, I tore it out (I know, it’s becoming a habit).

It was about seventeen hundred lines of Metal compute kernel, it was the cleverest code in the project, and by the middle of July it had lost an argument to a boring old triangle rasteriser on both counts that matter: the raster path looked better and it cost less. Not one or the other. Both. Raymarching a distance field is gorgeous for organic, grown-looking things and quietly miserable at sharp machined edges — and it turns out a colony built by an industrial mining concern is mostly sharp machined edges. Meanwhile every additional creature on screen was more maths per pixel per frame, and the frame budget on a real-time renderer is 16.7 milliseconds and it does not negotiate.

So the kernel is gone. Deleted. The level is built into vertex buffers once when it loads, materials are still shaded procedurally in code, and the whole thing is lit in HDR, bloomed and tonemapped on the way out. The only trace of the Raymarcher that remains is a file called GPURaymarch.swift, which no longer raymarches anything and survives purely as the home of some shared types I couldn’t be bothered to rehouse. It sits there like a pub that kept its name after the brewery closed.

I mention this partly because it’s honest, and partly because it’s the second time in two games I’ve deleted a renderer I loved. There may be a pattern. I am choosing not to examine it.

The four things I let in

Strataris shipped with no asset files at all — no textures, no audio, no fonts, no models, the entire game generated in code and small enough to fit on a floppy disk. It remains the constraint I’m proudest of.

Citadel breaks those constraints in exactly four places, and I want to be straight about all of them, because I’ve been loudly pure about this before and it would be pretty cheap to go quiet now.

The bodies. The drone and the Queen ship as 3-D meshes with baked colour maps. Organic, ridged, biomechanical anatomy reads better sculpted than generated, and after weeks of trying I couldn’t make maths produce something that looked like it had grown. So yes — this game ships textures. Two of them are monsters.

Three hero plates. Cinematic images behind the front-end screens, the title among them.

Five imported models, geometry only. A dormitory bunk and four pieces of plant machinery, downloaded, decimated to budget, and then stripped of every material they arrived with and re-surfaced in code. The shapes are borrowed. The surfaces are mine.

Audio. This one I’ve already confessed to at length. You can synthesise a gun. You cannot synthesise a living thing, and a game like this lives or dies on the noise something makes when it notices you. So Citadel ships a small, curated set of CC0 and CC-BY samples — all properly credited, all free for me to give away and for you to have. But the code still does most of the work: the Queen’s snarls are pitched down because she’s enormous and randomly nudged each time so she never repeats herself, and a drone two rooms away comes to you muffled and drowned in reverb, as though it’s carrying through a hundred metres of steel. There’s no soundtrack either — just a stack of layers and a live signal measuring how much trouble you’re in, thickening as things close and thinning when you’re safe.

And the synthesiser I built for Strataris? Still in the binary. It got demoted to the safety net: if a sample is ever missing, it quietly generates a stand-in so the game never falls silent. The old religion is on night shift.

Forty-eight floors, and every one of them proven

Levels are generated fresh every time you play — rooms, corridors, doors, coloured keycards, hidden secrets, hazard-walled fuel stores, an exit you have to earn. Play it twice, you’ll never see the same building twice.

Which raises the question that will keep you awake: what if it builds one you physically cannot finish? Random doesn’t care about you. Give it enough rolls and it will happily lock the red key inside the room that needs the red key, hand it to you with a straight face, and let you conclude I shipped a broken game.

So the generator doesn’t get the final say. Before you ever set foot on it, a solver floods the floor from your starting position — reach, collect a key, unlock what that key opens, reach further — and if it can’t touch the exit, the whole level goes in the bin and it tries again. I wrote about this in July, back when I’d only just discovered that the furniture can quietly ruin a certified-solvable floor by parking an oil drum in a doorway like a cork in a bottle. That’s covered now too. You will die on these floors. You will never be trapped on one.

Clearing a floor has a small ritual attached, and I’m fond of it. You call the freight elevator, the leaves part, and you step into the car — and there’s a panel in there that totals up what you did on the floor you’re leaving: kills, secrets, score. Then it takes you down. Eight of those and the building is yours, at which point you teleport to the next planet and start again at the top of a fresh one, brighter at the surface, worse further down, with the difficulty scaled to how deep you are rather than how long you’ve been playing.

You can save whenever you like, into any of ten named slots. A save is about three hundred bytes, because it stores the checkpoint — the state you arrived on this floor with — and nothing else. The map isn’t written down; it’s regenerated from the run’s seed when you load, and the lift rides you back down to it. You always resume on a clean floor start, never stranded half way through a fight you were losing.

The deeper you go, the fewer fixtures still work

The quiet things

The parts I like best are the ones the game never mentions.

A sick bay always holds a med-kit, and standing in one slowly closes your wounds — ten health every thirty seconds you stay. A room the nukage has reached does exactly the reverse at exactly the same rate, pool or no pool, because the air in there is the hazard. Neither is announced. There’s no icon, no chime, no tutorial pop-up. The only tell is your own health quietly moving, and working that out for yourself is the whole point.

Use a computer desk and the game zooms into an amber CRT. Most of them are jokes. Three of them aren’t: three interactive, paged documents that tell the same slow catastrophe from three different angles — a Director’s log, a stack of corporate memos, and a young scientist’s emails home to her mum. Read all three and you’ll know considerably more about why this happened than the marine does. Nobody makes you read any of it. There’s also a fully playable Space Invaders on one of those terminals, with its own persistent high-score table, because of course there is.

And somewhere in the run there are seven bodies. Colonists who sealed themselves into rooms when it all went wrong, and have been lying there a very long time. One pool of seven, dealt out across the six citadels, never more than two to a building — so a full campaign is the only way to find them all. The game does not tell you they exist, does not mark them, and does not congratulate you when you find one. The only thing you can do for them is the flamethrower, and it’s worth a thousand points a body and fifty thousand for all seven, awarded in complete silence.

I thought about putting a notification on that. I’m glad I didn’t.

What it cost

Strataris took five months. Citadel took six weeks (give or take) — first commit on the twenty-second of June, released today. A hundred and ninety commits, thirty thousand lines of Swift, one renderer deleted, one rule about pure code broken in four places, and one stretch in late July where the same two test frames kept coming out differently on every run and I genuinely began to doubt my own arithmetic. It was Swift seeding its dictionary hashing per process, so two tied walls kept swapping places. I found it by fingerprinting every field of the generator and bisecting, after two days of reasoning about it got me (and even the AI) precisely nowhere. Measure, don’t reason. I keep having to relearn this.

It runs on Apple silicon only, and that’s deliberate rather than lazy: it’s a real-time Metal renderer tuned to a 16.7 ms frame, every measurement behind that tuning was taken on an M-series Mac, and an Intel slice would have shipped without ever once running on the hardware it claimed to support. I’d rather say no than ship a maybe.

The Hall of the Fallen — name, score, how deep you got, and which colony took you

Go and get them out

Citadel is out now. It’s free — properly free, public domain, no catch, no telemetry, no account, no launcher. I’ve written before about why everything I make is free so regular readers know the drill by noe, except to say that I built this because I wanted it to exist and now it does, and you should have it.

You’ll need an Apple silicon Mac running macOS 14 or later. There’s an installer and a zip, both signed and notarised, and the source is on GitHub if you’d like to see how any of it works or take it apart for parts.

Take the plasma rifle to the Queen. Take the flamethrower to what’s left of her. Get your name into the Hall of the Fallen.

And keep an eye on the light on your helmet. It’s the only one down there that’s definitely still working.

P.S: It plays best with a gamepad, it’s damn hard with just the keyboard.

Photo by Jakub Żerdzicki on Unsplash

Most of what I do to these little menu-bar apps never earns a headline. A control that was hard to see. A feature someone asked for. A thing macOS quietly broke on a Tuesday. This is a roundup of the recent small stuff across two of them — MenuTidy and ActiveSpace — and the short stories behind each change, because the why is usually more interesting than the what.

MenuTidy learns to tidy itself

The itch had a name before it had a feature. You expand your menu bar to grab a hidden icon, you use it, and then… it just sits there, expanded, until you remember to click it shut. MenuTidy’s whole job is a tidy menu bar — and here it was leaving the mess out on the side.

Then someone opened an issue asking for exactly that: auto-collapse a few seconds after your pointer leaves the menu bar. (Thank you, fuzzy76.) I’d been quietly wanting it myself, so in it went.

It started life as a hidden setting — the sort you’d only find if you knew the incantation — while I lived with it for a while and made sure it felt helpful rather than fidgety. It did. So it’s now a proper, first-class setting: right-click the chevron, open Settings, and there’s an Auto-Collapse switch with a delay you can set anywhere from 0 to 999 seconds. Zero means “the instant I move away”; a few seconds means “give me a beat to change my mind.” The countdown resets if you move back up to the bar, so it only tidies once you’ve genuinely wandered off.

It’s off by default — nothing changes unless you decide you want it.

When Tahoe moved the furniture

MenuTidy has a feature for notched Macs called Reveal Hidden Icons: the menu-bar icons that get swallowed by the notch, gathered into a little panel you can click. fuzzy76 came back with a puzzle — clicking an icon in that panel did nothing. Except sometimes it did. First click: dead. Every click after: fine.

“Works on the second try” is the kind of bug that makes you distrust your own eyes. It turned out not to be my code at all — it was macOS 26, Tahoe. The trick MenuTidy uses to “click” a hidden icon is a little accessibility nudge, and on Tahoe the very first nudge to another app’s menu-bar icon comes back with a shrug — the line’s cold. The second one connects. So MenuTidy now warms the line: if the first nudge doesn’t take, it quietly tries again, and the click lands the first time, every time.

While I was in there, I tidied the panel itself. It used to flash a cached list and then redraw with the real one — which meant, for a moment, you couldn’t quite trust what you were looking at. Now it shows a brief spinner and then the real list, once, so what you see is always the finished article. Choosing Reveal again closes the panel; collapsing the bar closes it too.

ActiveSpace: which app am I about to land on?

ActiveSpace has a lovely trick — a commandtab that shows only the apps on your current Mission Control space, instead of every window across every desktop. It works beautifully. But the highlight marking which app you’d switch to was a pale, translucent thing, and on a bright wallpaper or under a bit of glare it all but vanished. You’d tab across the row and genuinely not be sure where you’d end up.

So the highlight grew up. It’s now a filled chip in your system accent colour, with a crisp outline and a soft shadow — the same visual language macOS uses for a selected thing everywhere else. It reads at a glance on any background, and it follows whatever accent colour you’ve chosen. No more squinting.

The theme, if there is one

None of these is a big feature. A switch, a retry, a brighter highlight. But this is most of what keeping software good actually is: listening when someone tells you what’s annoying them, noticing when the ground shifts under you, and refusing to let “you can just about live with it” be the finished state. Small, careful, and ideally invisible — right up until the moment you’d have missed it.

All shipping now, via the built-in updater or the download pages, whichever you prefer.

Photo by Kyle Glenn on Unsplash

I keep a small dashboard running that watches this website for me. Is it up? Does the sitemap still match what’s actually on disk? Are the update feeds live? And, once a night, the unglamorous one: are there any dead links — anywhere on the site — quietly rotting?

One morning it told me there was. One broken link, on one page. The page was a post I’d written a couple of weeks earlier, the one about tearing out my renderer and rebuilding a whole game out of equations. The dead link, it reckoned, was the one pointing at Shadertoy — which, if you read that post, you’ll know I was practically writing a love letter to.

The link worked fine

I clicked it. It loaded instantly. Of course it did — Shadertoy is very much alive and the wizards are still conjuring worlds out of a screenful of maths on it every day.

So why did my tool insist it was broken?

Because my tool doesn’t click links the way you and I do. It knocks. It sends a tiny HEAD request — the web’s equivalent of tapping on the door and waiting for a “yes, come in” — and it reads the answer. A missing page answers 404, gone. Shadertoy answered something different: 403, forbidden.

Not “there’s nothing here.” “There’s something here, and you may not have it.”

Shadertoy, like an awful lot of the modern web, sits behind bot defences — the machinery that waves humans through and slams the door on anything that smells automated. And a link-checker knocking with no browser, no mouse, no history is exactly the sort of thing that machinery exists to keep out. My robot looked like a robot, got treated like one, and dutifully filed the silence under “broken.”

It wasn’t wrong about what it saw. It was wrong about what it meant.

The three wrong fixes

There are three easy ways to make a warning like this go away, and all of them are worse than the warning.

The first is to delete the check for that one link. Quick, clean — and now that link is invisible forever, including the day it genuinely dies.

The second is to reach for a bigger hammer: whitelist the whole domain, or just stop checking external links at all. That throws away the entire reason I built the thing.

The third is the worst, and the most tempting: just… ignore it. Let the little red number sit there and learn to scroll past it. The trouble is that a warning you train yourself to ignore is worse than no warning at all, because the day it’s telling you something real, you’ll scroll past that one too. A smoke alarm that cries wolf gets its battery taken out — and then it’s just a plastic disc on the ceiling.

Known, and accepted

What I actually wanted was to tell the tool something I knew and it couldn’t: I’ve looked. It’s fine. Stop counting it as a fault — but don’t stop watching it.

So that’s the feature. There’s now a Mark known button on any external link that fails the probe. Press it and the link steps out of the red “broken” list and into a quiet one called Accepted — known good. It stops counting against the site’s health. The nagging stops.

But — and this is the whole point — it does not stop being checked. Every nightly sweep still knocks on that door. The link just gets filed under “yes, I know” instead of “something’s wrong.” One click puts it straight back on the naughty list the moment I change my mind, and if the link ever disappears from the site altogether, the tool tells me that, too — so an old judgment can’t quietly go stale behind my back.

The honest bit

It is a tiny feature. A button and a list. I could describe the whole thing to you in a sentence.

But I think the small distinction underneath it is the part worth keeping. A false positive you silence by deleting the check is a little lie you tell yourself: there was never a problem here. A false positive you record a judgment about is something else entirely — it’s honesty with a memory. One quietly unplugs the alarm. The other says “I heard it, I went and looked, here’s what I found” — and leaves every wire exactly where it was.

The most dangerous state for any watchdog isn’t being occasionally wrong. It’s barking often enough at nothing that you stop looking up when it barks.

Peace with the doormen

The people behind Shadertoy conjure entire animated worlds out of a few lines of maths — the exact trick I borrowed to build a monster. It turns out they also conjure a very firm “no” for robots. Fair enough; it’s their door.

My little watchtower and I have made our peace with it. The link isn’t broken. I know it isn’t. And now my tool knows that I know — without ever once agreeing to stop checking.

Photo by clasiqh on Unsplash

I have been building the same music library since I was a teenager, and it shows.

There are pub bands on it — actual bands, in actual pubs, recorded by someone’s cousin. There are buskers I liked enough to hunt down. There are CDs I bought off support acts at the merch table, half of whom never troubled a streaming service and never will. There is an almost-complete collection of The KLF, a band so committed to standing alone that they deleted their own back catalogue in 1992 and set fire to a million quid for an encore — music you genuinely cannot find in a tidy, mastered, modern form anywhere, because they made sure of it.

I love all of it. But here is the thing about music assembled over thirty years from every corner of the world: it is recorded at every volume known to engineering. The pub band is a whisper. The remastered pop single is a wall. And when you press shuffle, they come at you one after another, at random, with no warning.

Loud, quiet, loud

You know the dance. A quiet track comes on, so you nudge the volume up to hear it properly. The next track is a brick-walled banger and it takes the top of your head off. Down goes the dial. Track after that is a demo someone recorded in a shed, so up it goes again. On speakers it’s annoying. On headphones it is genuinely unpleasant — there’s nowhere for the loud one to go but straight into your skull.

For years my thumb never really left the volume control. And when I got tired of that, I did the worse thing: I started skipping. Skipping tracks I actually liked, purely because I couldn’t face the volume lottery of finding out how loud the next one would be. That’s the moment that finally got me — when I realised the fiddling had quietly talked me out of listening to my own music. The volume knob was winning.

So I built Ballast.

The thing I refused to install

The obvious way to get at everything your Mac is playing is to install a virtual audio driver — a fake output device that intercepts the sound, hands it to an app to muck about with, then passes it on to your speakers. It’s how the serious tools do it, and it works. It also means installing a system component you have to approve, possibly reboot for, and then live with forever, squatting in your Sound settings whether the app is running or not.

I did not want to ship that. A free little utility has no business re-plumbing your Mac.

Happily, I didn’t have to. A while back macOS quietly grew Core Audio process taps — Apple’s own, built-in way to read the system audio mix without any of that. Nothing to install, nothing added to your Sound settings, no driver, no router. Ballast puts a (muted) tap on the mix, does its work, and plays the result back through whatever output you were already using. Quit the app and it’s gone without a trace, because there was never anything installed to leave behind. Your chosen output stays chosen. There is nothing to route.

That was the first thing I got right. Most of what followed, I got wrong at least once.

False start one: the compressor

My first instinct was to ride the volume live — hear it get loud, pull it down; hear it go quiet, push it up. A compressor, essentially, or an automatic gain control.

It works, and it sounds dreadful, because it flattens the music. The whole soul of a good recording is the swing from quiet to loud — the hush before the chorus, the drop, the breath. A live gain-rider squashes exactly that, and everything comes out as the same lifeless, even mush. I’d have made my music quieter and worse.

The mistake was aiming at the wrong target. The problem was never the dynamics within a track. It was the mismatch between tracks.

False start two: measuring the wrong way

So: don’t compress. Normalise. Work out how loud a whole track actually is — as a human ear perceives it, not as a naive peak meter sees it — and apply one gentle, fixed adjustment across the entire thing, leaving every quiet-to-loud swing completely intact.

Measuring perceived loudness is, thankfully, a solved problem. There’s an international standard for it — EBU R128 / ITU-R BS.1770, the LUFS scale that streaming services and broadcasters use to stop the adverts being louder than the programme. Same maths. Ballast steers every track toward one comfortable target and leaves its insides alone.

Except — and this is the wrinkle that cost me the most sleep — you cannot know a track’s true loudness until you’ve heard it, and the loudest moment might be the final chorus. You can’t normalise the first second correctly until you’ve heard the last.

So it learns

The answer was to stop pretending I could get it perfect on first listen, and to let Ballast remember instead.

The very first time it meets a track, it does the best it honestly can, live — anchored to the loudest thing it’s heard so far, so nothing suddenly blasts you. But it’s also measuring the whole track properly as it plays, and it files that reading away under the track’s identity. The next time that track comes round, Ballast recognises it and applies one exact, fixed adjustment from the very first sample — no ramp, no guessing, no compromise. The more you listen, the more of your library it simply knows, and it keeps quietly re-checking its own numbers as you go, so a library assembled over thirty years slowly sorts itself out in the background while you get on with enjoying it.

There was one last piece of stubbornness in me — and this is the one I ended up talking myself out of. For a while, whenever Ballast met a new track, it would narrow its listening to only the music app while it took the measurement, walling off any stray notification that might skew the number. Clever. Also, it turned out, needless: measure a whole track and the odd interruption averages away to nothing, and every later play quietly corrects the figure anyway. Worse, the trick had a cost — switching what it listened to left a faint seam you could hear at the edge of every new track. So I pulled it out. The very first measurement of a track is a hair less pristine now, and not one of us will ever hear the difference. Track changes still come from the same public notifications Apple Music and Spotify broadcast, so it stays in step even across a gapless album.

The honest bit

I could tell you it all worked first time. It did not.

The first night I left it running unattended, it decided that a track fading gently to silence was a broken audio tap, and cheerfully rebuilt its whole audio graph eleven times in under a minute — every time a song got quiet. Teaching it the difference between a fade (a slow, graceful sink into silence) and an actual fault (an abrupt cliff to dead zero) was an entire afternoon of its own. That’s the unglamorous reality of something meant to run silently in the background for hours and never once get in your way: most of the work is in the failures nobody will ever see.

And, yes, the dancer

A few days ago I wrote about an afternoon I spent failing to animate a dancer, and I signed off by saying she lived “at the quiet edge of a bigger project I’m not ready to talk about yet.”

This is the project. She was hiding in a loudness normaliser the whole time.

Ballast has a real-time music visualiser — six styles, the smoke-and-shadow Dancer among them. Because it rides the same audio tap that does the levelling, it reacts to anything playing, not just your music app. It started life as a debugging toy: a way to actually see the levels moving while I chased bugs. It got completely out of hand, as these things do, and now it’s one of my favourite parts.

Set it once

Ballast is free, there’s no telemetry, and nothing you play is ever recorded, stored, or sent anywhere — it measures your audio on your Mac, in the moment, and the only thing it ever writes down is a small list of how loud your tracks are.

Set the volume once. Put on the remastered single, then the pub band, then a support-act CD nobody else on earth has a copy of. Let it shuffle.

And take your thumb off the dial.

Photo by Liana S on Unsplash

I did not set out to learn anything about human beings. I set out to draw a dancer. The human beings turned up uninvited and taught me a lesson anyway, which is very much their way.

Here’s the setup. A small macOS app I’ve been chipping away at — I’ll tell you what it actually does another day — grew a music visualiser almost by accident. Once it existed, I couldn’t leave it alone. I’d seen one of those lovely minimal audio visualisers: a lone figure moving in a hazy, backlit room, a slim waveform riding over the top. And what I wanted from it wasn’t the waveform. It was the room. The presence. The sense that someone was in there, dancing, just out of focus.

So, obviously, I tried to draw the someone.

So I drew her

The house rule still applied, the one I keep for my games: nothing loaded from a file. No stock video, no motion-capture, no borrowed footage of an actual dancer. If I wanted a figure, I had to build one out of maths, drawn fresh on the GPU every frame.

And I did. A circle for a head. A soft column for a torso. Two arms on little sweeping cycles, rising and falling. A skirt that flared from the waist and rippled at the hem. She swayed. She lifted her arms. She was, unmistakably, a woman dancing.

She was also awful, and it took me an embarrassingly long time to work out why.

The trouble with people

Here is the thing nobody warns you about. The instant a shape reads as human, the person watching stops looking at a shape and starts watching a person — and everyone, without exception, is a lifelong expert on how people move. My dancer held her arms overhead a beat too long. Nobody dances like that. Her sway was a touch too even, too metronomic. Nobody dances like that. Every frame invited the same four words, and the better I made the figure — the more clearly human — the louder those words got.

I had built myself an uncanny valley and moved straight in.

The fix, it turned out, was not a more convincing dancer. I could have spent a month on inverse kinematics and weight-shift and secondary motion and still landed on “good puppet.” The fix was to stop drawing a person at all.

The black blob

So I abstracted her. Off came the head, the arms, the skirt, until what was left was just a soft vertical presence — a shadow in the beam, swaying. No anatomy to get wrong. Problem solved.

Reader, it was not solved. I had walked straight into the second trap.

A shape with soft edges is still a shape. What I had now was a flat, dead, coal-black column — a hole punched in the smoke. A blob. I stared at it. The AI I do this work alongside stared at it too. We agreed, in as many words: blob.

The mistake was the same one, wearing a different coat. I was still drawing a thing — filling in a region and softening its border — and a filled region, however soft its edge, always reads as an object cut out of the world. The trick I’d been missing all afternoon was this: don’t draw a shape. Draw a density.

Vapour, not silhouette

The old question was “is this pixel inside the figure?” — and any yes/no question gives you an edge, and an edge is a thing to be wrong about. The new question was gentler: “how much shadow hangs in the air right here?”

Instead of a body, a soft haze that’s thickest along a slowly-wandering spine and fades to nothing in every direction, all of it broken up by the same procedural smoke drifting through the rest of the room. No border. No flat core. Light seeps through the thin parts and catches in the dense ones, unevenly, the way light actually behaves in a smoky room. And just like that it stopped being a blob in the smoke and started being smoke, with something alive moving inside it. Same maths family as the monsters in my game, pointed at a kinder subject.

Move with the music, not at it

Then, motion. My first attempt jerked on every beat — twitching on each kick drum like a cheap club light with a wiring fault. Which makes sense on paper and looks terrible in practice, because a beat is a hammer, and a dancer is not being hammered.

So I stopped moving to the beat and started moving to the tempo: a slow, smoothed reading of how much energy is in the music right now, feeding a clock that quietly speeds up as the room gets busy and eases off when it calms. The presence drifts faster through a loud passage and lingers through a quiet one — carried by the music without lurching on any single hit. Then I gave it company. One hard key light, the smoke machine wound up to full, and half a dozen of these presences drifting across the floor, each on its own path. A crowd.

The whole scene is a few equations per pixel. It runs cold and silent — no fans, no fuss — because there was never anything to load. There’s no dancer on disk. There’s only code, and the dark doing most of the work.

The actual lesson

Here’s what stuck with me, scrubbing off hours of iterative experimentation.

Every time I tried to say more — here is a head, here are her arms, here is precisely how she sways — the thing got worse, because I was writing cheques the animation could never cash. And every time I said less, it got better, because I was leaving room for the one renderer I will never out-code: the person watching. Tell someone “this is a woman dancing” and they will lovingly itemise everything wrong with her. Show them light and shadow shifting in smoke and they will tell you, unprompted, that it’s a dance floor — because they want it to be. Their eye finishes the sketch I was never able to.

I’ve written before about constraints as craft, but this was a sharper version of it. The skill wasn’t in drawing the dancer. It was in drawing less than a dancer, and trusting the dark to do the rest.

The visualiser is a small thing at the quiet edge of a bigger project I’m not ready to talk about yet — that’s a post for another day. For now I just wanted to tell you about the afternoon I sat down to animate a human being, failed completely, and discovered that failing was the entire point.

Put some music on. Watch the floor fill up. The illusion is complete.

Photo by Amsterdam City Archives on Unsplash

I spent a happy week furnishing the next game. The colony you fight through used to be a working place — people lived and worked there before the swarm came — and empty rooms read as exactly what they are: empty test boxes. So I filled them. Bunks against the walls, steel lockers beside them, desks with dead terminals still flickering, oil drums in the corners, recharge panels on the walls. The rooms went from ‘level geometry’ to ‘somewhere’ almost overnight. I was thrilled.

And it was all a lie, because you could walk straight through every single piece of it.

Ghosts with good lighting

This is the dirty secret of set-dressing: by default it’s a picture of furniture, not furniture. A drum that looks like four hundred solid pounds of steel is, to the game, nothing at all — you stroll through it like a ghost, and so do the monsters. It looks superb right up until the first time your shoulder passes through a locker, and then the spell breaks completely. Suddenly the whole world is cardboard. You can’t un-see it.

So the furniture had to become solid — properly solid, for you and for the things hunting you, so a drum is cover you can hide behind and a bunk is something a drone has to go around.

The bit I was nervous about

Here’s why I’d been putting it off. As I wrote about the other day, this game draws its entire world — walls, creatures, furniture and all — as maths on the graphics card, and that card is already working hard. The machine runs warm as it is. The obvious way to make things solid — hand all that geometry to a full physics engine — felt like exactly the wrong thing to bolt onto a renderer that was already at the edge.

I didn’t want a physics engine. I wanted the cheapest possible honesty.

The trick: one source of truth

The thing that saved me is that the furniture’s shape already exists. The renderer has to know precisely how big a bunk is in order to draw it. So rather than build a second, separate collision shape — the classic route, and the classic source of bugs — I derived a dead-simple box from the exact same description the renderer draws from, once, when the level loads.

After that, ‘is the player touching the furniture?’ is a few lines of schoolbook arithmetic: is this circle overlapping that box? It runs on the ordinary processor, costs effectively nothing, and never goes anywhere near the graphics card. Solid furniture, zero rendering cost. The fans didn’t even notice.

The part I’m quietly proud of is the one source of truth. The thing you see and the thing you bump into are generated from the same description. They physically cannot disagree. There’s a whole genre of game bug — the invisible wall, the hitbox that doesn’t match the model, the bullet that hits thin air — that comes entirely from the picture and the collision being two separate things that have drifted apart. If they’re the same thing, that bug can’t exist.

Choosing what’s solid

‘Make it all solid’ would be lazy, mind. Solidity is a design choice, not a default. The drums and bunks and lockers are solid because cover and obstacles make the fight better. The proximity mines you drop are deliberately not — you step over your own mines; the monsters have to blunder onto them, which is the entire point of a mine. So the rule isn’t ‘everything is solid’. It’s ‘everything is solid on purpose, and the exceptions are exceptions on purpose.’

Nobody is ever going to praise a game for having solid furniture. It’s not a feature; it’s an absence of a problem, and the best you can hope for is that no one notices. But they’d notice instantly if it were missing — the moment they walked through a wardrobe, some quiet part of their brain would file the whole game under ‘fake’.

That’s the job, really. The details are the software. A locker you can’t walk through is a tiny detail. It’s also the difference between a place and a backdrop.

Photo by Joana Godinho on Unsplash

The next game I’m making builds its levels itself. Every floor is laid out fresh: rooms and corridors stitched together, doors hung, a few of them locked behind coloured keycards you have to find first, the odd hidden room for the curious, an exit you have to reach to descend. Play it twice and you’ll never see the same place twice.

This is a wonderful way to make a game. It is also a wonderful way to lie awake at night, because of one question that will not leave you alone once you’ve thought it:

What if it builds a level you can’t finish?

The cruelty of random

Random doesn’t care about you. Give it enough rolls and it will, eventually, hand you the red keycard locked inside the room that needs the red keycard. It will wall the exit off behind a door whose key sits on the wrong side of that same door. It will build a beautiful, atmospheric, utterly impossible maze and present it to you with a straight face. And the player — reasonably — will assume you are the idiot who shipped a broken game, because they have no way of knowing a dice roll did it.

You cannot test your way out of this by hand. There are effectively infinite levels. You will never see the broken one in testing; your players will see it on day one.

Don’t trust it — prove it

So the generator doesn’t get the final say. Every time it lays out a floor, a little solver walks the result before you ever see it.

It starts exactly where you’ll start. It floods outward through every space it can reach. When it reaches a key, it picks it up. When it reaches a door it now has the key for, it opens it and floods on through. It keeps going — reach, collect, unlock, reach further — until one of two things happens: it touches the exit, or it runs out of anywhere new to go.

If it can reach the exit, the floor is real, and you get to play it. If it can’t — if the keys and doors have tied themselves into a knot — the whole level is thrown in the bin and the generator tries again. It’s cheap, it’s quick, and it means every single floor you ever set foot in has been proven beatable before you arrive. You might die on it. You will never be trapped on it.

The bugs the solver couldn’t see

Here is where it gets humbling, because ‘solvable’ turned out to have layers I hadn’t accounted for.

The solver checks the layout — the rooms, the doors, the keys. It does not, it turns out, know anything about the furniture. And so I got a run of beautiful, certified-solvable levels that were nonetheless quietly impossible, because something solid had been parked in the way after the solver signed off:

• A fuel drum — a big, solid, explodable barrel — that generated dead in the middle of a doorway, sealing the room behind it like a cork in a bottle. The solver swore the level was fine. As far as it knew, the doorway was wide open. It had no idea a barrel had moved in.
• A length of wall pipework that routed straight across a doorway, like someone had installed a turnstile and forgotten the gate.
• A bed that stuck out just far enough into a corridor to wedge me in place. Solvable on paper. Not solvable with shoulders.

Each one taught me the same lesson from a different angle: the layout can be perfectly winnable while the furnishing quietly makes it not. So now the set-dressing gets the same suspicion the layout does. Nothing solid is allowed to block a way through, and the automated checks that run on every build don’t just confirm the maze is solvable — they confirm nothing has wandered into a doorway and ruined it.

The actual philosophy

I think people hear ‘procedural generation’ and picture letting the computer do the work. In my experience it’s almost the opposite. The generator is a slot machine — gloriously productive, completely untrustworthy. The real work isn’t the generating. It’s the refusing-to-trust: the bouncer standing at the door, turning away every level that can’t prove it’s fair before it’s allowed anywhere near you.

You’ll never play a floor of mine I didn’t prove you could finish. What you do with that floor is entirely your problem.

Photo by Peter Herrmann on Unsplash

In the post about my first game, Strataris, I confessed to one of those decisions that cost me weeks: I tore out a renderer I was genuinely pleased with — the old Voxel Space terrain trick — and rebuilt the entire world as a proper 3D triangle mesh, because I wanted to be able to bank and roll and fly properly. It was painful and it was right.

I’m making a second game now. And reader, I did it again.

A different shape of problem

The first game was about flying over a world. The next one is about being inside one — on foot, down through a tight, occupied place, room by room, in the dark, with something in there that wants you. A flying game wants a big open landscape. A game like this wants walls, corners, corridors, the half-second before the adversary steps into the light.

Triangle meshes would have done the job. I’ve got one, working, from last time. The sensible thing — the grown-up thing — would have been to reuse it.

I did not do the sensible thing. When will I learn?

Never, I hope — because the learning is the point. Reusing last year’s maths teaches me nothing; I only learn by building the thing I don’t yet know how to build. That means hours, days, weeks of studying other people’s source code, watching tutorials, falling down Wikipedia holes — and, these days, leaning on AI to sanity-check the maths and catch the mistakes I can’t see.

Maths instead of models

So for this new game I built the whole world out of signed distance fields, and I’ll try to explain that without turning this into a lecture, because I promised myself a long time ago these posts wouldn’t be lectures.

Here is the entire idea. Instead of describing a wall as a list of corners — a model, a mesh, a thing you’d load from a file — you write a tiny function that can answer one question for any point in space: how far are you from the nearest surface? That’s it. That’s the whole description of the world — a function that measures distance.

To draw it, the graphics card fires a ray out through every pixel and just… walks it forward. At each step it asks ‘how far is the nearest surface?’ and takes a step exactly that big, safe in the knowledge it can’t overshoot anything. A few steps later the distance drops to nothing and the ray has found a surface. Do that for a few hundred thousand pixels, sixty times a second, and you have a world.

No vertices. No meshes. No model files. A corridor is an equation. The pipework bolted along the walls is an equation. The rust is an equation. And — this is the part that sold me — so are the monsters. Horrors like the ones that stalk within this new game are not sculpted models; they are a handful of soft blobby shapes blended together with a bit of maths that melts them into one another. Distance fields love organic, wet, bio-mechanical things. They’re terrible at sharp machined edges and wonderful at things that look grown rather than built. For a game about something living in the walls, that’s exactly the right kind of wonderful.

It also means the ‘no asset files’ rule I’m so fond of doesn’t just survive — it gets easier. There’s no model to ship because there was never a model. There’s only code.¹

The part where it fought back

I will not pretend this was free. It was a different kind of hard, and in some ways a nastier one.

With triangles, your mistakes are at least visible. Last time I had buildings floating serenely in the sky and, on one memorable evening, the entire planet rendered as a single spike stretching to infinity. Funny, in hindsight. But you could see what was wrong.

Distance-field bugs are sneakier. Get a single sign backwards and the world turns itself inside out — you’re suddenly inside the walls looking at the back of everything. Get the maths for a surface slightly wrong and it shimmers, flickering in and out as the ray can’t quite decide whether it’s hit anything. And there’s a performance cliff waiting the whole time: every extra creature on screen is more maths per pixel per frame, and it is entirely possible to write something correct that also turns your laptop into a small, furious heater. A good chunk of my notes from this stretch are just the word “WHY” at increasing font sizes.

Standing on shoulders of giants, again

None of this is mine. I want to be clear about that, because it matters. This technique is the beating heart of the demoscene — the people who fit entire animated worlds, with lighting and music, into programs kilobytes in size, as a sport. It’s what the wizards on Shadertoy do for fun, conjuring landscapes and creatures out of a screenful of equations. I learned it from people far cleverer than me, who did extraordinary things with it long before I came along and used it to make a monster.

I just keep finding that the harder road teaches me something. You can’t drop in a model, so you have to understand what a wall actually is. And it turns out a wall, in this game, isn’t a picture of a wall. It’s the answer to a question — how far am I from the nearest one? — asked a few hundred thousand times every frame.

I think that’s rather beautiful. I also think it cost me weeks of stress and frustration. Both things are true. That’s the deal.

Photo by Anne Nygård on Unsplash

A few weeks ago I published a post that was, in hindsight, a little smug. I told you Strataris shipped with no asset files — no textures, no sprites, no audio, no fonts — everything generated in code, maths all the way down, the whole thing small enough to fit on a floppy disk. I meant every word. I’m still proud of it.

This is the post where I tell you I have now broken that rule.

The rule

Strataris was built on a constraint I set myself for no sensible reason: nothing could be loaded from a file. If I wanted a sound, I had to build a sound — sit down with a synthesiser I’d written and work out, properly, how a laser or an explosion or a crackly distress call is actually made of waveforms. It was slower and harder, and that was the point. Constraints make you understand a thing instead of importing it.

So when I started on the next game — currently a work in progress — I assumed the rule would carry over untouched. This game — I’ll tell you more about it another day — is a Doom-shaped thing: on foot this time, down through an occupied subterranean structure, room by room. Dark. Claustrophobic. The kind of game where what you can’t see often matters more than what you can.

That, it turned out, is exactly where my lovely rule fell apart.

Where the rule held

First, the good news, because the rule mostly won. The world of this game is, if anything, more extreme than Strataris. There isn’t a single texture or 3D model anywhere in it — the walls, the floors, the pipework, the rust, and even the creatures themselves are pure maths, drawn in real time on the GPU. The ‘everything in code’ rule didn’t just survive the move to a shooter; it got more stubborn. Visually, I never had to compromise at all.

It was sound that broke me.

The thing I couldn’t fake

Here’s what I learned, sitting in the dark with headphones on: you can synthesise a gun. A laser, a thump, a pickup chime — those are honest little sounds, and a synthesiser does them proudly. What you cannot synthesise, at least not with the tools I have, is a living thing. The awful noise a predatory creature makes when it notices you. The gap between “that’s a sound effect” and “there is something in here with me” is enormous, and my from-scratch creature noises landed firmly, embarrassingly, on the wrong side of it. The synthesised sounds said ”video game”. I needed them to say ”run”.

This sort of game lives and dies on atmosphere — on dread, on the half-second before you see the thing. And I’d built myself a rule that actively prevented me from delivering the single most important ingredient. That’s not a principle any more. That’s a man losing an argument with himself.

So I relented. There are now real recorded samples in the game. Actual throats. I’m at peace with it.

How to break a rule without betraying it

But I didn’t just buy a sound library and bolt it on, because that would have been a betrayal — and because everything I make is free, public domain, no catch, and I wasn’t about to ship something I couldn’t give away clean. So two rules held over the rule I’d broken.

First: every sample is Creative Commons or public domain, properly credited, free for me to ship and free for you to have. Not one borrowed byte I don’t have the right to give away.

Second — and this is the part I’m actually pleased with — the code still does nearly all the work. The sample is only the seed.

Take the worst thing in the game. Her voice is a handful of short, mammalian growls — a few seconds of audio, all told. But you never hear them as they were recorded. Every time she snarls, the game pitches the clip down — she’s enormous, she should sound enormous. We also shift the pitch and speed by a random nudge each time, so no two snarls are ever quite the same. A few seconds of source becomes a creature that never repeats herself. The maths is still running; it’s just running on top of a real throat instead of trying to be one itself.

The lesser horrors get the same trick from the other direction. When one is right behind you, you hear it clean. When one is far off down a corridor you haven’t reached yet, you hear it muffled and drenched in echo, as though it’s carrying through a hundred metres of steel — the same clip, run through reverb and a filter, turned into a thing you can hear but not yet find. None of that is in the sample. That’s code, doing what code is good at.

And the ‘soundtrack’? There isn’t one, not really — there’s no track. There’s a stack of looping layers (a low room-tone, a pulse, a dissonance…) and a live signal that measures how much trouble you’re in and quietly crossfades between them. The music doesn’t play at you; it responds to you. It thickens as the things close in and thins out when you’re safe, and most players will never consciously notice it’s happening. Which is exactly the point.

Oh — and the synthesiser I was so proud of, the one I built for Strataris? It’s still in there. It didn’t die. It became the fallback: if a sample is ever missing, the game quietly synthesises a stand-in so it never falls silent. The old religion got a job as the safety net. I find that quite funny.

The actual lesson

The mistake people make with constraints — the mistake I made — is letting them curdle from a tool into a dogma. The floppy-disk rule was the best creative decision on Strataris. It would have been the worst decision on this one, if I’d held it like scripture. The craft was never in the rule. It’s in knowing which afternoon to keep it and which afternoon to break it — and then, when you do break it, breaking it with enough discipline that the result still feels like yours.

Playability beats fidelity. I’ll die on that hill. But atmosphere beats purity — and it took a monster in a dark room to teach me the difference.

I’ll tell you when you can play it. For now, just know that when you finally hear her in the dark, that wasn’t a synthesiser. That was the one time maths wasn’t enough — and I’m glad I stopped arguing with myself and listened.

Photo by Evan-Amos, CC BY-SA 3.0, via Wikimedia Commons

Something set me thinking about the ZX81¹ today, and once I’d started I couldn’t stop. The first computer I ever touched. A black plastic wedge about the size of a paperback, one kilobyte of memory, a flat membrane keyboard with no give in it at all. I’d have been twelve, maybe thirteen. Forty-odd years ago now, and I can still feel it under my fingers.

The thing I remember most vividly isn’t even the machine. It’s the manual.² They don’t make them like that any more — it was sublime, honestly, a proper ring-bound book that taught you from nothing. I worked through it cover to cover, typing the listings in, running them, watching them do their thing. And then changing one line just to see what happened. Make the number bigger. Swap two lines round. Take that bit out — does it still work? Why not? Hours went like that. I didn’t know it was the same process loop I’d still be running four decades later. I just thought it was the best game in the world.

The magazine listings were another matter. You’d see this gorgeous artwork next to the code — spaceships, dungeons, whole worlds — and you’d type the whole thing in over an evening, hunt down the one character you’d got wrong that stopped it running, finally get it going, and… a few blocky black shapes shuffling about on a white screen. Nothing like the picture. I wasn’t even really disappointed. I was too busy being amazed that those lines made that happen at all.

Fun Fact

That 16KB, 3.25 MHz machine ran Doom. No, not really, but we did have 3D Monster Maze, which was the Doom of its day.

Image Credit: 3D Monster Maze (Malcolm Evans, 1981), screenshot via Wikipedia

And I had to earn the time to do any of it. We had one television in the house — one — and the ZX81 plugged straight into it, so computing meant taking over the only screen the whole family shared. So I did housework for it. Washing-up, hoovering, mowing the lawn, washing the family car, whatever was going, traded for an hour at the keyboard. Funny the things that stick. I’ve never since had to work quite that literally for a go on a computer, and I don’t think I’ve ever valued an hour at one quite as much either.

Then there was the tape. No disk, no anything — you saved to a cassette recorder, an ordinary one, and loaded back the same way, this banshee shriek of noise while the screen tore itself into stripes. And the waiting. What felt like hours of it. Watching, hoping, only for the thing to fall over two-thirds of the way in. The volume had to be just so — too quiet and it wouldn’t catch, too loud and it garbled — and finding that sweet spot was black magic. Rewind. Nudge the dial. Try again. Hold your breath at the bit where it died last time. Sometimes the fifth attempt worked when the first four hadn’t, and none of us ever knew why.

The real heartbreak, though, was the RAM pack. One kilobyte is nothing, so like everyone I had the 16K pack that plugged into the back to give you room to actually do something. And it wobbled. The connection was just a friction fit on an exposed edge, and the slightest knock — a nudge of the desk, a heavy footstep, an elbow, a shadow in the wrong place — could jolt it and crash the whole machine dead. No autosave. No save at all unless you’d done it yourself, to tape, with all the ritual that involved. So when the wobble caught you halfway through an hour of carefully typing a listing in, line by single-keyed line, it took the lot. Black screen. Start again. I learned to save early and save often the hard way, aged twelve, at the hands of a loose connector. Blu-tack was the technical solution to the problem. But it never stopped feeling tenuous and I’ve never quite lost the little flinch I get near unsaved work. Don’t think I’d want to.

But the joy. The first time I got a program of my own working — not from the manual, not from a magazine, mine, dreamed up and built line by line — that was something else entirely. I couldn’t tell you now exactly what it was; a daft little loop, I think, that filled the screen with my own name scrolling away over and over. It was nothing. And it was one of the purest hits of happiness I’ve ever had. I’d told a machine what to do, in a language it understood, and it had just… done it. Exactly, instantly, without a word of complaint. You only get to feel that for the first time once, and I got to feel it on a one-kilobyte wedge wired into the family telly, in between rounds of washing-up.

After the ZX81 came a Commodore 64, an Acorn Electron — “it’ll help with my schoolwork”, an Atari 800XL (and with it a 14-inch colour TV of my own), then the great leaps to a 520ST then a 1040ST, an Amiga 1200 — that whole tribal, fiercely-argued-over era when the machine you owned said something about who you were. Then PCs, as one did. Then the original Bondi-blue iMac, which is where my Mac story started. A PowerMac G5 after that, and then a long line of MacBooks right up to the one I’m typing this on, which has something like thirty-six million times the memory of that first little wedge. I’m not exaggerating for effect. The maths just lands there.

Funny how it works out. A hobby — mucking about with games and listings on a borrowed telly in 1982 — and it quietly set the course of my entire working life without my ever quite deciding it should. The loop I fell into back then, the one the manual taught me — type something, run it, change a line, run it again — is the very same principle I use today. Forty years on, I’m still writing code. And after all of it, all those machines, all those years, I’m still faintly amazed that I can get this little electronic box to bend to my will.