Here's a claim I can't shake: almost every boundary inside a modern computer exists for exactly one reason — to copy data across it. And every one of those copies is pure tax.

Your CPU and your GPU have separate memory, so you copy across PCIe. Two processes can't see each other's memory, so you copy through a pipe. Two machines definitely can't, so you flatten your data to bytes, push it through a socket, and rebuild it on the far side. A program isn't "running" until you've copied it out of storage into RAM. We do this so constantly we've stopped seeing it. It's just how computers work.

Except it isn't. It's how these computers work — the ones we happened to build. And I've come to think we took a wrong turn a long time ago, threw the other road in the sewer, and never went back to look.

We optimized the wrong machine

The von Neumann CPU is a serial machine. One instruction, then the next, a program counter marching down a list. It's brilliant, it won, and everything we built afterward assumed it was in charge. Parallelism, accelerators, networks — all bolted onto the side of a fundamentally serial core.

We didn't choose serial-first because it was right. We chose it because it was early, and early advantages compound. Economists have a name for this: path dependence. It's why QWERTY outlived every faster keyboard layout, and why Brian Arthur's "increasing returns" lock a market onto a standard that was never the best one — just the first to get enough momentum that switching cost more than staying. The serial CPU is the QWERTY of computing.

The road we didn't take was parallel-and-dataflow-first: a machine where the base unit isn't "the next instruction" but "this operation, the moment its data is ready" — and where memory isn't a place you copy into, it's just there, one owned addressable space that everything shares. On that road, the CPU-versus-GPU split, the syscall, the socket, the "application," the "install" don't get optimized. They stop existing. They were all just names for different copies.

The copy tax, itemized

Walk the stack and count the copies:

  • RAM to VRAM. Your data lives in system memory. Your GPU can't see it. So you copy it across a bus to "GPU memory," compute, and copy the answer back. For LLM inference, a shocking fraction of the wall-clock time is that shuffle, not the math.
  • Host to device. The GPU can't even start the work itself — a CPU has to orchestrate it, hand it off, wait, take it back.
  • Process to process. Two programs on one machine, inches apart in the same RAM, can't touch each other's memory. So they copy through a pipe.
  • Machine to machine. The big one. You take a live structured object, flatten it to bytes, shove it through a protocol designed for slow, unreliable 1970s networks, and reassemble it on the other end.

Every arrow is a copy, and every copy is latency, energy, and complexity you're paying to move data that never needed to move. So ask the naive question: what if none of those boundaries had to exist?

The discarded road is being paved — by four teams who don't know they're on the same road

Here's the part that made me sit up. "Parallel-first, one shared no-copy space" isn't science fiction I have to argue from scratch. It's shipping. In pieces. In four different places, built by people who — as far as I can tell — haven't noticed they're building the same machine.

Apple killed the RAM-to-VRAM copy. Apple Silicon's Unified Memory gives the CPU, GPU, and Neural Engine coherent access to one pool. There is no "VRAM." Nothing crosses a bus, because there's no bus to cross. AMD sketched the same thing a decade ago as hUMA; NVIDIA is collapsing the same divide with Grace-Hopper. Boundary one: gone.

CXL is killing the machine-to-machine copy. CXL 3.x exposes another machine's memory as hardware-managed load/store at cache-line granularity. You read a remote address and the fabric fetches it — no serialize, no socket, no copy. It's the honest version of a wild-sounding idea I kept circling ("the network is just a memory controller that happens to span machines"), and it's real, funded, and rolling out inside racks right now. Its grandfather is Barroso and Hölzle's The Datacenter as a Computer. Boundary four: going.

Cambridge and Arm built the thing that makes a shared space safe. The obvious objection to "one big flat memory everyone can touch" is that it's a security nightmare. The answer already exists in silicon. CHERI, shipped as Arm's Morello, makes every pointer a hardware capability — carrying its own bounds and permissions, checked by hardware on every access, impossible to forge. Ownership becomes a property of the memory itself. That's the missing primitive: capabilities are what let a flat shared space be safe instead of anarchic.

Unison killed the copy in software. The Unison language identifies code by the hash of its content, not its location. No "install," no dependency hell, no copying a program into place — you reference a function by what it is, and it runs here or on another machine transparently, because identity stopped being tied to location. Same idea, software side.

Unified memory. Memory-semantic fabric. Hardware capabilities. Content-addressed code. Four teams, four boundaries, one architecture — and nobody has said out loud that they're the same design. That's the whole thesis: the copy is the original sin, and the redemption is already being built in four labs that haven't compared notes.

The honest wall: it's not transistors, it's the speed of light

Let me be straight about where this stops, because the failure mode of an idea like this is to promise infinity.

A single unified address space is only coherent if coordination is instant. It never is. The moment your "one memory" spans any real distance, you're bounded by how fast a signal can cross it — and that's c. Local DRAM answers in tens of nanoseconds; the far side of a datacenter is already meaningfully farther in time; the far side of a planet is a hundred milliseconds; the far side of a galaxy is a hundred thousand years. You cannot have one globally-coherent computer larger than its own light-cone. Seth Lloyd made this rigorous in "Ultimate physical limits to computation": a computer's speed is bounded by its energy, and its coordination is bounded by c. The limit on one big machine was never the transistors or the watts — it's the relativity of simultaneity, the fact that "now" quietly stops being one shared thing once the machine gets big enough. That's a stranger and more beautiful ceiling than "we ran out of nanometers," and it's the honest place this whole line of thinking lands.

What I'm not claiming

I have a whole speculative machine built around this — a chip, an OS, a language, the works. I'll spare you the spec sheet, and I'll be honest that the hardware-and-cost half of my own notes does not survive contact with a real fab quote. That's fine. The idea doesn't need the chip. Every load-bearing part of it can be argued from technology that already ships or is one product cycle away. That's exactly what makes it worth writing down instead of building a demo nobody asked for.

The point

We told ourselves the copy was fundamental. It isn't. It's a scar from a fork we took because it was early, not because it was right. And for the first time, four separate teams are independently paving the road we skipped — unified memory, memory-semantic fabric, hardware capabilities, content-addressed code — without anyone naming the thing they're collectively building.

So I'll name it. The copy is the original sin. And the interesting question was never whether we can undo it — it's how big a computer we can build before the speed of light makes us start copying again.