Pushing past ports and process overhead
An engineering experiment is attempting to fit 15 million independently addressable web servers into a virtual machine with 10GB of memory and one CPU core. The project is less a proposal for normal hosting than a practical exploration of where operating-system abstractions consume memory and how kernel-bypass networking can change the calculation.
A conventional server quickly encounters several limits. TCP and UDP ports are 16-bit values, restricting the number available on one address. Assigning many IPv6 addresses can expand the set of address-and-port combinations, but creating a process and kernel socket for every server is far more expensive than the target budget allows. The author measured a simple server process at roughly 1.5MB and estimated that 15 million such instances would require about 20TB.
The experiment instead puts many guests inside one specialized runtime. Each minimal guest needs only enough saved state to resume its simple accept, read, reply and close loop. The author estimates 16 bytes of scheduler state per guest, or about 220MB for all 15 million, before accounting for networking and active connections. That calculation shows that the application logic itself is not the main memory problem.
Moving the network stack to user space
Linux socket structures still impose substantial per-socket overhead, even when most listeners are idle. The project therefore explores bypassing ordinary kernel sockets and handling packets in user space. Its design discussion covers smoltcp, DPDK and AF_XDP, technologies that offer different tradeoffs between portability, direct hardware access and integration with Linux networking.
A user-space TCP/IP stack can represent listeners more compactly because the runtime controls the data structures and only implements features its workload needs. It can also share buffers and scheduling machinery across millions of logical servers. The cost is complexity: the program becomes responsible for work normally performed and extensively tested in the kernel, including packet handling, connection state and resource management.
The target should not be read as 15 million busy production websites. The memory model assumes that only a fraction of connections are active at once, and a single CPU core necessarily limits useful throughput. Nor does the exercise prove that isolated tenants could safely share the runtime. It is a density experiment built around extremely small servers and deliberately constrained behavior.
Even with those qualifications, the work provides a concrete lesson about scale. When an application needs millions of nearly identical endpoints, optimizing the response code is not enough. The decisive gains come from removing duplicated processes, sockets and general-purpose state, then replacing them with a runtime designed around the exact workload.



