The first real commit of the campaign is constitution.md — I literally began by writing a constitution. Within two days there was a party: a Host process, a separate CaptureWorker to grab the screen, and soon a separate OverlayWorker to draw on it. Viewing happened in a native desktop app. It all felt very correct, very architected.

Almost everything on this opening screen — the multi-process party, the native viewer, the framework choices — dies somewhere further along the road. I didn't know that yet. That's what the map is for.

The viewer client was born on WinUI on October 24th. On October 25th its project file was renamed wholesale to WPF. One day from this is the client framework to it isn't — the fastest reversal of the whole campaign, and a gentle tutorial-level preview of the next nine months. The code survived; only the .csproj name changed.

The native viewer client — the WPF app people were supposed to install to watch a session. It was made functionally obsolete on 22 November 2025, the day the web viewer reached feature parity. I deleted it on 30 March 2026.

That is 128 days of carrying a dead party member and telling myself it might still be useful. When the doubt hits — and it does — surely I could have taken a better path isn't a rhetorical flourish. There are 128 days of evidence sitting right there in the log. On the map this is the faint road that keeps going long after the party stopped walking it.

November was the first real dungeon, and it paid out the first real treasure. Annotations arrived — ink over your live screen, drawn by viewers from a browser. And on November 22nd came the quiet, pivotal moment of the entire campaign: the web viewer reached feature parity with the native client. The web version worked. Nobody would need to install anything to watch a session. From that day, the browser was the product's centre of gravity — even though (see the long dead road) I kept the native client on life support for four more months.

A standalone web-client project, created October 30th, deleted October 31st. The idea was right and won completely — the packaging was wrong and died in a day. The browser path would live inside the Host itself, not as a project of its own.

I celebrated the browser's victory by burning the server down. There is a commit from November 19th titled, in full:

— a snapshot taken the way you'd save your game before a boss room. I stood up a new .NET 10 server next to the old one, and within a day the old one was deleted. A week later: “Gigantic rendering / performance improvement.” The day after that, pen input was ripped out of Blazor and rewritten in JavaScript, because latency is felt in the hand, not measured in a benchmark. Pen drawing worked. Drawing on your own screen, live, while someone across the world watches the stroke land in their browser — that one felt like magic. It still does.

SBOM generation — a software bill of materials, added in November, removed in February without ever being needed. A scroll listing the contents of a keep nobody had attacked. It sat by the road for 85 days and not one traveller asked to see it.

Then: nothing. December produced two commits. January produced one. On the map this is a long, empty, snowed-in stretch of road, and it would be easy to cut it from the story — but it's where the next decision grew. Back in November I'd left myself a note that the worker-process structure was asymmetric: a polite way of writing I think the party is wrong. All winter that doubt sat there. In February, it hatched.

The separate Capture, Overlay and Server processes were folded into one app. The workers became libraries; their executables left the building. The multi-process architecture I'd so carefully constituted in October — deleted, in the largest structural rewrite so far. This is also where MSIX packaging appeared and the downloadable client binaries came off the Host: the shape of the real product, emerging by subtraction.

Born at the One Process rewrite: a self-tuning capture-quality controller that measured throughput and adjusted itself. Clever, alive — and it slowly spread its assumptions into capture, display, telemetry and tests until nothing around it could be reasoned about. It survived 134 days. When I finally disabled it as an experiment in July, the whole organism turned out to be replaceable by two static numbers: a relay upload ceiling and a recording FPS floor. Four and a half months of adaptive machinery, beaten by two constants. I wrote it a death certificate (ADR-0033) and mopped the floor.

Architecture Decision Records are the campaign's durable treasure: 34 of them by launch. This one is a death certificate. It records, in writing, that four and a half months of self-tuning machinery lost to two constants — so that no future version of me, feeling clever, quietly builds the ooze again.

March built the topology the product still runs on today: the Host dials out through a tunnel, a Relay in the cloud issues a six-digit code, and viewers reach the session with that code and nothing else. No firewall incantations, no downloads. Waystations followed over the months — Sydney, then Europe, then the US — and in fairness the relay line is the only quest in the whole campaign that never once went wrong. It just kept adding waystations.

The gate condition was darker: the native client had to actually die before this topology made sense. Both happened this month.

Most decisions on this map were reversed at least once. This signpost marks the exception: the relay topology built in March was still standing in May, when the first ADRs were written, and it was retroactively locked in as ADR-0002. Browsers only, through the relay, with a six-digit code. Every other road on the map bends around this one.

Over four days in late March, three separate branches attacked the operator UI — a React client, a “new UI”, another React attempt. All three are still in the repository. All three end with a final commit whose entire message is one word:

Three heads, three attempts, three identical last words. The monster won. The WPF shell it was guarding is still the operator UI today.

Sydney first, then configurable relays, then dynamic ones, then AU / EU / US1 by launch. Included here mostly as proof that one quest line can just… go well. It's the only one that did. On the map it's the green sea route: three waystation isles, each flying its flag, and a ship that never sank.

The codebase was cut into a portable core plus native shells per platform — and then the Mac version happened in one furious week in late April: screen capture, overlay, the lot. The first architecture decision records were written the moment the Mac forced real decisions. The lesson of this era, learned the hard way from the chimera: don't unify platforms. Split harder, and share the middle.

The unfinished rope: the Mac still can't record a movie. The bridge is built; the last plank isn't. It's the single largest known gap in the product, and it's still on the horizon roads today.

It promised one body for every platform. One head was a phone app that would find your session over Bluetooth so nobody had to type the code — it lived thirteen days, until I admitted that typing six digits was never the problem. The other head promised a single host binary for Windows and macOS; it never even merged. Both heads cut. The winning move was the exact opposite of what the chimera sold.

A Bluetooth broadcast of the share URL, so a nearby device could join without typing anything. It even merged to main for twelve days before being walked back out with its MAUI host. The six-digit code from the relay was already good enough; this was a side quest that briefly rejoined the road and was then politely asked to leave.

The Mac crossing, done properly this time: a native shell on Avalonia, screen capture, overlay and tests all landing in a single week. It succeeded exactly where Maui failed, by accepting two shells instead of forcing one — and it rejoined the main road dragging an unfinished rope behind it: the Mac can capture and draw, but it cannot yet record a movie. The gap analysis is written and sits on the horizon, unstarted. The bridge is built; the last plank isn't.

Six quests sit written-but-unwalked at the edge of the map, each one a planning document waiting for its day. This is the biggest: the Mac has capture and overlay but no recording pipeline. The plan exists. The road is drawn in dotted ink. Nobody has taken the first step yet.

A recording library was carved out of the core, and the operator finally got a proper Session Control window. The UI redesigned itself twice in a fortnight — a sharing carousel shipped and was thrown away four days later for a flat pane. Small experiments died fast here: auto-start recording when sharing, a separate stroke-mirror layer for the movie, a media-server sidecar for live pixels — each has its own marker by this gate. And one experiment didn't die small: this gate opens the single longest, deepest quest of the campaign. The mines are just up the road. Keep walking.

The sharing carousel. The commit that introduced it asks its own fate out loud:

A flat scrollable pane superseded it four days after it shipped, and the carousel's types were swept out of the codebase within the week. Its decision record was deleted too — see the headstone beside this one.

ADR-0011 was the carousel's decision record. When the carousel died, the record was deleted with it — so on the main branch the ADR numbering simply skips from 0010 to 0012. The gap is the headstone. (Deeper lore for completionists: ADR-0023 exists twice — once on main, and once as a completely different decision on an abandoned branch. The campaign's paperwork has both a missing grave and a duplicate ghost.)

Auto-start recording when sharing. It lasted a day. The product retreated to intentional recording only — you press the button, from Session Control, on purpose. Some traps are only visible after you've built them and stepped in them yourself.

A separate stroke-mirror layer that re-drew the annotations into the recorded movie, in parallel with the screen capture that already contained them. Dropped in the same commit as the helpful trap. Screen capture — which already carries the overlay ink — is the single source of truth.

The alternative to shipping live pixels through the relay was a real media-server sidecar riding alongside every session. The spike worked; the branch was never merged; the two ADRs proposing it remain in the tree, never adopted. The relay won the argument a few weeks later by learning to cache frames instead — a simpler road that needed no second wagon.

The single longest and deepest quest of the campaign: the recording and movie-encode adventure. Fifty-eight days underground, 108 commits in the recording tree alone, six discarded architectures, three audio monsters slain along the shaft, and one final boss that is still down there. The camps of the descent, the mine's bestiary and the boss chamber each have their own markers inside the mountain — this entrance is just where the light stops.

The prize that finally came out: an in-process, hardware-accelerated, audio-mixed movie encoder with no downloads and no subprocesses. It rejoined the main road in June, carried in a chest.

A standing stone at the entrance to the mines, carved with a single numeral. The recording pipeline was completely rebuilt six times in eight weeks, and every rebuild was honestly better than the one before it. The stone is here so that travellers understand what the mines cost before they judge how long the party spent inside.

Every camp on the way down was honestly better than the one before it. None of them was right:

• Camp 1 — record everything, encode at the end (the user waits at the end)
• Camp 2 — zero-copy GPU spike (a dream, parked; it comes back later)
• Camp 3 — thousands of PNGs fed to ffmpeg (thousands. of PNGs.)
• Camp 4 — raw video piped to an external ffmpeg.exe (an .exe the user must download)
• Camp 5 — smarter pipe, honest frame rate (still a subprocess)
• Camp 6 — everything in-process, bundled libraries, no download. SHIPPED.

On June 10th the whole thing moved in-process, audio joined the movie, and the commit from the next day says it with more honesty than I could fake:

Video recording finally, finally worked. By July it even did zero-copy encode on NVIDIA hardware — frames going from screen to encoder without ever touching the CPU. There were weeks where I'd have told you that was a fantasy.

Recordings came out with no audio, because the mixer waited forever for a silent desktop to produce sound that was never coming — the loopback leg delivered zero chunks and the mix starved politely, eternally. Slain by making the mixer drive time itself instead of waiting on the quietest input. First of the three audio monsters in the mine's bestiary.

Recorded audio drifted out of sync with the video — an offset correction fighting a loopback backlog, each convinced the other was wrong. Slain, and a golden test now stands over the grave so it cannot silently return: audio start-time must match video start-time, forever, by law.

The UI stuck forever on “preparing recording…” — and the same three words on screen turned out to be two completely different bugs, months apart. One was an audio stop deadlock; the other, far more subtle, was a cross-thread device handshake failing in a way that quietly killed the coordinator loop. One of them I blamed on the encoder for weeks. It was never the encoder.

When a catch-up encode finished and the NVIDIA hardware encoder was disposed, the dispose would sometimes never return. Not slowly — never. Native stack walks all ended in the same place: deep inside the driver, waiting on a kernel semaphore with a count of zero that nothing would ever signal. Only the driver could release it. It never did.

I attacked it six times. The casualty list:

1. Flush before finalize — doubled the hang rate
2. Shared graphics device — 60% pass
3. Shared device + aggressive GC — 80%, still flaky
4. GPU event-query drain — no better than baseline
5. Full by-the-book teardown — worse than the GC hack
6. Push the watchdog deeper — broke back-to-back recordings

Six broken weapons on the floor in front of a boss whose health bar hadn't moved. The turn came when I identified the blocking object for what it was: driver-owned, kernel-mode, shared across sessions. No user-mode spell would ever release it. The fight was unwinnable on its own terms — so I stopped fighting on its terms. The movie is fully finalized before the encoder is ever disposed; a three-second watchdog ships the finished file and walks out of the mine while the encoder stays wedged behind us; the catch-up path retreats to software encoding entirely. Ten out of ten on the regression harness.

Six architectures were thrown away in this quest and every one was replaced by something better. This monster is the only problem in the entire campaign that could not be solved by building a better thing. It is still down there. The XP came from refusing the fight.

The recording quest returned to the main road carrying its prize, and the relay learned to cache frames instead of pushing them naively. Then the product renamed itself: 2Reflect became Expressed — new name in the code, the DNS, the UI. Except the Microsoft Store package identity is immutable, forever, and the git repository still carries the old name. The rename is permanently 95% complete. The hero changed his name mid-campaign and the world's ledgers will always remember the old one. I've decided to find that funny.

Five weeks of scrubbing: code, DNS, UI, installer, docs. Two things can never follow. The Microsoft Store package identity is immutable — the operating system selling the app will call it by its dead name forever — and the git repository is still named after it too. A rename that took five weeks and can never be completed. On the map, the new signboard hangs squarely over the old one, and the old one shows through.

Across the water, faint in the haze, a city where the operator UI lives in the browser and the Trihydra's WPF shell is finally retired. A plan document exists. Not one stone has been laid. It is also the Trihydra's unfinished business — the monster technically won, and somewhere at the edge of the map there's a plan to storm it again someday.

July rewrote capture and invented the commercial layer at the same time. A whole GPU capture subsystem was built on July 5th and deleted on July 8th — a three-day kingdom — in favour of one capture path to rule them all. The Adaptive Ooze was finally put down the same week. Licensing, a free tier, tier limits and a first-run tour all landed in a single fortnight, and the version line sprinted from 0.2.37 to 1.0.10 in four days. The product was suddenly, unmistakably, a product.

An entire GPU capture subsystem — built on July 5th, crowned, and deleted on July 8th when Windows Graphics Capture was made the one capture path to rule them all. The kingdom fell but its treasury was looted first: the GPU compositor work built for it survived and moved into the winning path. Even three-day kingdoms leave roads behind.

A spike proved that a fancy 3D-transition library could power the first-run tour. The spike succeeded at proving the idea and failed at being the implementation: the shipped tour is a hand-built replica of the launcher, which means it drifts whenever the real launcher changes. The carnival packed up; the debt stayed in town.

Mid-July, a two-day experiment: crop a recording down to a clip. The commit that opens it asks the real question out loud — “I'm still not sure if this should be a separate product, so trying it out.” The branch was parked, eight commits ahead, and hasn't been touched since. On the map it's a treasure chest sitting at the end of a road nobody finished walking: a little door into what might be a different game entirely. It's still closed. For now.

And the chest is real: the project's own written history — the document this whole map grew from — exists only on this abandoned branch. On the main branch, its folder contains eight empty image directories and nothing else. The record of the journey was marooned in a dead end. The map itself was found here.

Six machine-named branches appear in two bursts in July, each carrying exactly one ticket — several AI agents attacking the same task in isolated worktrees, best result merged, the rest left where they fell. Three merged, three abandoned. Not a feature: a way of working. Summoned figures walking beside the party, half of whom fade.

Five weeks building freemium enforcement. Then, on August 9th — one day before launch — the decision the previous post is all about:

I built the tollgate and then wedged the barrier open, because with zero users the only question that matters is whether anyone finds the road worth walking at all.

Nineteen release tags mark the road by launch; this is the one where the product first went live to the world, quietly, weeks before anyone was told to look. The commit message is all capitals about it: “0.2.37.0 - published LIVE”. The flags after this one come fast.

One day after going live, the version line jumped to 1.0 — and then sprinted: five versions in three days, 1.0.2 through 1.0.10. On a map of nine months, this is the stretch where the milestones stand almost close enough to touch each other.

Tagged the night before launch: the build that went to Product Hunt on Monday the 10th, with three relay regions warm and the tollgate deliberately standing open. Every flag before it was practice.

The last stretch: session auth rewritten to fix multi-client reconnect, a third relay region, the last traces of the old name scrubbed from DNS, Product Hunt images checked in, and the recordings got an endcap — a closing card on the movie, a small bow on 58 days of mining.

And then launch day itself, when the only commits are metrics and dashboards. Because the question had changed, and I knew it.

On launch day, the 10th of August, the commit log contains no features and no fixes — only session-length metrics and dashboards to watch them in. The question had changed from does it work? to is anyone using it?, and the hero spent launch morning building a pool to stare into. He is, as far as anyone knows, still staring.

🐉The TDR Wyrm — eats the display driver when a session ends. Four crash dumps, same address, every time. The app survives it every time; the driver does not. Undefeated. Documented, tolerated, circling the map's edge.

👻The Fluent Revenant — someone else's bug, living in this process (a known WPF framework issue). Can't be killed from inside this repo; there's a ward chalked on every dispatcher door instead.

⛏The Semaphore — still at the bottom of the mines, wedged, walled off, walked past.

🐍The Trihydra — technically victorious. The operator UI it defended is still WPF, and a plan to storm it again someday sits written at the edge of the map.

Four out of four crash dumps at session stop land at the same address, deep in the display driver, during hardware-encoder teardown. The application survives it every time; the driver does not. It cannot be slain from up here — the app was hardened to live through the bite instead of preventing it. Undefeated. Documented, tolerated, circling in the water near the mines. The serpent is still down there.

Changing screen resolution crashed the app — and the fault was never in this codebase at all. It is a known framework bug in WPF's Fluent theme, triggered on background overlay threads. A ghost that walks through walls: it cannot be killed from inside this repository. Instead there is a ward chalked on every dispatcher door — every new dispatcher thread must attach a crash guard before it runs. The ghost still walks; it just can't get in.

One of the six horizon quests — roads planned but not walked, each written down as a document waiting at the repo root. This one: partial-screen and single-window capture. The naming in the code is already designed to generalise; the road is drawn in dotted ink off the top of the map.

The web viewer's pen path has been rebuilt for speed three times — the JavaScript rewrite in November 2025, stroke storage in June 2026, a lag hunt in August 2026 — and there is still a written plan for more. Some roads get repaved forever because they matter forever: drawing is the product, and the hand always knows.

The growth quest, deliberately parked until the scrying pool says someone is actually using the thing. The plan connects directly to the telemetry shipped on launch day: don't buy attention until you can see whether attention converts into sessions that last longer than a minute.

Medieval cartographers drew dragons where their knowledge stopped. Everything on this map — every road, camp, monster and grave — is the part of the story I could control. Past this corner lives the part I can't: whether anyone shows up. That territory is still unmapped. The dragon is real; I just haven't met it yet.