For decades, we've been building bigger systems by adding more networking.

More switches.
More cables.
More connectors.
More retimers.
More layers of fabric.

Meanwhile, the processors doing the actual computing remain separated by boards, connectors, and multiple tiers of networking.

It works. But as XPU clusters become larger and more tightly coupled, the interconnect becomes an increasingly significant part of the system.

At the other end of the spectrum, chiplets bring everything extremely close together. Chiplets solved one problem—reticle limits—but introduced another. To keep chiplets tightly packed, we've accepted increasingly complex packaging, finer wiring, denser interconnects, tighter thermal constraints, and growing manufacturing complexity.

Every generation pushes materials and process technology further just to scale the same architectural model.

Maybe there is another way.

What if the XPU—not the chiplet—became the building block?

What if we built larger systems out of XPUs rather than ever-larger collections of tightly packed chiplets?

And what if we stopped treating the scale-up fabric as a networking problem and started treating it as a packaging problem?

That's Rack-on-Package.

Instead of connecting XPUs through multiple tiers of switches, boards, connectors, cables, and retimers, bring the scale-up fabric onto the package itself.

Connect multiple XPUs directly with short, high-speed serial links. Use existing interfaces and standards where possible. Space XPUs where thermal, power, and mechanical design make sense rather than forcing everything into the smallest possible footprint.

The package becomes the interconnect.

The package becomes the scale-up domain.

The package is the fabric.

And modularity changes what is possible.

Signal and power integrity can be managed locally instead of scaling one enormous monolithic substrate.

Thermal management becomes modular, with physical separation between high-power XPUs and independent thermal solutions.

Mechanical stability becomes a modular engineering problem rather than a limit on total system size.

Yield becomes manageable by assembling the system from known-good blocks.

The result is something between today's advanced package and today's compute rack: a package-scale XPU fabric that can grow toward panel dimensions.

This isn't about eliminating networking.

It's about eliminating unnecessary distance and hierarchy from the most tightly coupled part of the network.

Instead of asking how many more chiplets we can integrate into a package, perhaps we should be asking a bigger question:

How many XPUs can we connect on one?

That's Rack-on-Package.

The package is the fabric.