104 Tiny Routers Walk Into a Lab
A GoatOS network simulation grows from three home pods into 104 subscriber-specific routers, each with its own LAN and a shared WAN.
How a home network simulation grew from three little neighborhoods into one router per subscriber—and why that turns out to be useful.
A home network is easy to draw on a napkin. There’s a router, a few devices, and a line out to the internet. The drawing gets less napkin-sized when you want to simulate what happens across a whole subscriber base.
In the GoatOS archive, the first home-pod design starts sensibly: three simulated homes, each with a router container and a handful of device containers. Give each home its own LAN, connect those LANs to a shared WAN, and you’ve got a small laboratory for home network behavior.
Then the design changes. The current pod-local configuration describes 104 router services, each with its own subscriber LAN and a connection to that shared WAN.
One hundred and four. Somewhere along the way, “let’s simulate a few homes” appears to have been taken as a suggestion.
Why give every subscriber a router?
Because a shared network is very good at hiding which subscriber is having a bad day.
If all the simulated devices sit behind one common router, it’s harder to model the differences between homes. One household’s DHCP lease, DNS trouble, traffic patterns, or device behavior can blur into the aggregate. You can still make packets move, but you learn less about what is happening at each subscriber’s edge.
A router per subscriber gives every simulated home its own small boundary. Inside is a private LAN with its own address range and DHCP service. The router also connects to the shared WAN, so traffic has somewhere to go after it leaves the home network.
Conceptually, it looks like this:
subscriber devices
│
private LAN
│
subscriber router ───── shared WAN ───── rest of the lab
Repeat that pattern for each subscriber, and you can watch each little network behave on its own while still sharing the wider simulated environment.
These routers do actual router things
The pod runtime script is not just putting a router-shaped label on an ordinary container. It configures a LAN interface and a WAN interface, enables IPv4 forwarding, and adds firewall rules that allow outbound traffic and its established return traffic. Network address translation lets devices on the private LAN share the router’s WAN-side connection.
The same runtime starts dnsmasq to provide DHCP leases and DNS settings to devices on the LAN. The router can acquire its WAN-side address through DHCP as well. That gives each pod the familiar jobs a household router performs: hand out local addresses, point devices toward a gateway, forward packets, and keep the replies on the right path.
It’s a small design, but it preserves the important boundary: home traffic enters through that home’s router before heading into the shared part of the simulation. If something goes wrong, there’s a specific edge to inspect. No need to interrogate the entire lab because one imaginary television can’t resolve a name.
From three homes to 104 edges
The early phase note describes three homes with two to four devices each. It also calls out the separate LANs and shared WAN, and lays out a telemetry collector for the simulation. The planned streams include device state, flow records, DNS activity, quality-of-experience measurements, and incidents.
The later configuration scales the same basic shape outward: a distinct router service and LAN for each subscriber. The current Compose definition contains 104 of those router services. That is a meaningful change in the unit of simulation. Instead of modeling “a home” as a group attached to a shared router, the lab can represent each subscriber as an independently routed edge.
That matters when you want to ask questions at more than one level. Is one device struggling? Is one home’s local network behaving oddly? Is the shared WAN the common problem? Separate boundaries give the simulator somewhere to attach the evidence.
And evidence is the whole point. The earlier telemetry design planned to record device state, network flows, DNS behavior, quality-of-experience data, and incidents. Those streams become much more useful when they can be associated with the right simulated home rather than stirred into one very large pot of “something happened.”
The unglamorous part is the good part
A hundred-plus routers sounds like a stunt until you look at the repetition. Each router follows the same pattern, receives subscriber-specific settings, connects to one shared side and one private side, and runs the same basic network services. The topology is large because the test needs many independent edges, not because every home requires a bespoke snowflake.
That’s the useful trick in simulation: repeat the small, meaningful unit. Give each subscriber a boundary. Keep the common network common. Collect enough telemetry to tell the difference between a local problem and a shared one.
The result is not a hundred physical routers humming away in a closet. It is a containerized lab that can model a lot of subscriber edges on one machine. This is a rather better use of containers than making a development environment depend on a pile of consumer hardware and a prayer.
There’s a philosophical point hiding in the topology, though I promise not to make it wear a robe. You can’t understand a system’s behavior if you erase the boundaries where that behavior happens. The router is not only a way out to the internet; it is the place where one home’s story meets the shared network.
Three simulated homes were enough to establish the pattern. One hundred and four subscriber routers make it possible to study what happens when that pattern is repeated. Somewhere between the first little LAN and the 104th, a home network stopped being a diagram and became a laboratory.
Based on GoatOS’s archived home-pod phase notes, pod-local Compose topology, and router runtime script. The 104 count refers to router services defined in the indexed Compose configuration, not a claim that 104 physical routers exist.