We wrote the world in C. Operating systems, networks, flight controls, grid controllers, the libraries sitting underneath everything else. It was the right language for machines that no longer exist.

That code never retired. It accumulated. Something on the order of a hundred million lines now holds up modern life — much of it maintained by volunteers, some of it maintained by no one at all. When Log4j broke the internet, a handful of unpaid people were on the other end of the phone.

The failure mode is not exotic. Roughly seven in ten of the serious vulnerabilities in these codebases come from the same small set of mistakes: a pointer freed twice, a buffer read past its end, a length that was trusted. We have known the cause for thirty years, and we have answered it one patch at a time.

We know the cure works. Android moved its new code to memory-safe languages and watched memory-safety bugs fall by two thirds as a share of all vulnerabilities. Nothing clever happened. An entire class of bug simply stopped being written.

Rewriting was never impossible. It was uneconomic. Moving even part of the Linux kernel to Rust cost millions of dollars in engineering time, and no single beneficiary of a shared library could justify paying for all of it. So the work sat there, and everyone kept paying interest instead of principal.

Models write idiomatic Rust — not transliterated C wrapped in unsafe, but code an engineer will defend in review. The bottleneck moved from writing to reviewing, and reviewing is a bottleneck you can staff.

The window is the point. The same automation that lets defenders rewrite lets attackers search, and it is cheaper to find a memory-safety bug than to fix one. Whoever refactors first stops playing that game. Everyone else keeps playing it forever.

Pathways takes the C and C++ a team can no longer afford to touch and returns Rust they can own.