Wires Between Macs

"Inside a package, terabytes a second. Between two Macs, ten gigabytes a second on the best day. Every claim about pooling Macs is that ratio, and the ratio is 250."

The Household's Wires

Nine Macs are tied together three ways. A Thunderbolt cable joins the two 512 GB Studios directly — office and server — and their Thunderbolt network names resolve only between the cabled pair; the household's own notes record that a macOS privacy rule blocks launch daemons from those names, so the image engine addresses the hub over the tailnet instead. A tailnet — a private mesh over the internet — reaches every Mac from every Mac, including the laptop in another city, and is how every command-line tool in the fleet talks to the control plane. And the local network carries the rest. The code block puts the vendor bandwidth of each beside the time a 16 GB checkpoint takes to cross it: 1.6 seconds over Thunderbolt 5, 13 over 10-gigabit Ethernet, a minute or two over Wi-Fi, five minutes across the tailnet from a remote Mac.

The Ratio

Thunderbolt 5 carries 80 gigabits a second bidirectionally, 10 GB/s, with an "up to" 120-gigabit boost for displays; a third party measured RDMA over it at fifty to sixty gigabits, about 7 GB/s. UltraFusion carries "over 2.5TB/s" between the M3 Ultra's two dies and "over 4.4TB/s" on the M5 Ultra. The fastest wire between two Macs is 250 times slower than the fabric inside one, and 440 times slower on the newest chip. NVLink, for the rival, is 1.8 TB/s between whole GPUs. That ratio is the whole answer to the question the big-models track asks next — can two Studios be one 1,024 GB machine? — and it is why RDMA over Thunderbolt, which Apple shipped in macOS 26.2 for exactly this purpose, is documentation in this quest rather than a run. For loading a model the wires are fine; a checkpoint crosses in seconds. For a token, which crosses once per layer, the wire is the memory.

What the Wires Are Actually For

Read against the fleet's patterns, the wires carry three things and none of them is a token. The hub pattern sends a request and gets 1,024 numbers or a short stream back — kilobytes, for which the tailnet's fifty megabytes a second is a hundred times more than enough. The control-plane pattern sends a lease and gets a result — a transcript, a file path — across the same wire. And model distribution moves checkpoints from the hub to the peers once, over the cable or the local network, in seconds to minutes, which is the one job the bandwidth column is for. A fleet designed this way never asks a wire to do a per-token job, and that is not an accident of the household's choices but the physics track's rule applied to a room: bytes per token must come from the pool, and the pool is inside one package.

Code

wires.py — every link the fleet uses, and how long a checkpoint takes to cross it·python

#!/usr/bin/env python3
"""Wires between Macs: every link the household uses, its vendor bandwidth, and how long
a 16 GB checkpoint takes to cross it. Vendor figures; the measured RDMA figure is a
public one (Geerling) and labelled so."""
links = [  # name, GB/s, source
    ("UltraFusion, M3 Ultra (inside one package)",  2500, "Apple: 'over 2.5TB/s' -- not a wire between Macs; the scale bar"),
    ("Thunderbolt 5 (the cabled pair; office <-> server)", 10, "Apple/Intel: 80 Gb/s bidirectional; 120 Gb/s 'Bandwidth Boost' for displays"),
    ("Thunderbolt 5, RDMA measured by a third party",   6.9, "Geerling 2025-12-18: 'something like 50-60 Gbps' -> ~6.9 GB/s at 55 Gb/s"),
    ("10 Gigabit Ethernet",                             1.25, "IEEE 802.3an: 10 Gb/s"),
    ("Wi-Fi 6E / 7, typical",                            0.15, "order of magnitude; varies"),
    ("the tailnet over the internet (a remote Mac)",   0.05, "order of magnitude; the household's WAN"),
    ("Apple's own scale bar: PCIe 5 x16",                63, "63 GB/s per direction (T2)"),
]
MODEL = 16.05  # GB, the 27B checkpoint on disk
print(f"{'link':56} {'GB/s':>7} {'16 GB model':>12}")
for name, gbs, src in links:
    print(f"{name:56} {gbs:7.2f} {MODEL/gbs:10.1f} s")
print("\nthe fastest wire between two Macs is 250x slower than the fabric inside one; the big-models track prices what that means for pooling")

# link                                                        GB/s  16 GB model
# UltraFusion, M3 Ultra (inside one package)               2500.00        0.0 s
# Thunderbolt 5 (the cabled pair; office <-> server)         10.00        1.6 s
# Thunderbolt 5, RDMA measured by a third party               6.90        2.3 s
# 10 Gigabit Ethernet                                         1.25       12.8 s
# Wi-Fi 6E / 7, typical                                       0.15      107.0 s
# the tailnet over the internet (a remote Mac)                0.05      321.0 s
# Apple's own scale bar: PCIe 5 x16                          63.00        0.3 s

Exercise

Time a copy of one model checkpoint between two of your machines over each link you have — cable, Ethernet, Wi-Fi, a mesh network — and add the measured GB/s to wires.py beside the vendor figure. Write the ratio between your fastest wire and your chip's UltraFusion or memory bandwidth on the card; it is the number the next track divides by.

Hint

Expect the measured figure to be well under the vendor's — protocol overhead, the disk on either end, and the file system all take a share. The ratio to the package fabric stays in the hundreds whatever you measure, and that is the point.