· via Hacker News – Front Page (native)
Experiment runs 15 million web servers on one VM with smoltcp, DPDK and AF_XDP
A kapteko.com write-up explains how to run 15 million isolated web servers on a single VM with 10GB of RAM, using IPv6 AnyIP addressing, a custom userland runtime and kernel-bypass networking.

A write-up published on kapteko.com on November 18, now on the Hacker News front page, sets out to run 15 million web servers on a single virtual machine with 10GB of RAM and one CPU core. The framing is tongue-in-cheek: the author argues that servers get hacked because there are too few of them, proposes one web server per person for all 8 billion humans, and predicts that hacking demand will collapse once everyone has their own. The engineering underneath the joke is real, and it touches nearly every layer of the stack: addressing, the process model, scheduling and networking.
The port ceiling
The author starts with a minimal C server built on the classic syscalls — listen, accept, recv, send, close — which serves roughly 65,000 requests per second. Launching 15 million copies fails almost immediately, and not for the obvious reason: the machine runs out of ports. Asking for port 0 makes the kernel pick a free port from net.ipv4.ip_local_port_range, 32768 to 60999 by default. The write-up explains the gaps: ports 1–1024 require root, 1024–32768 are skipped so dynamically allocated ports don't collide with services such as MySQL on 3306, and 60999–65535 are excluded for reasons dating back to IP masquerading. The cap is structural regardless — a TCP port is a 16-bit field, so even kernel modifications cannot push past 65,535, and normal clients would not understand exotic ports anyway.
AnyIP and a /64 on loopback
Because a listener is identified by the tuple of protocol, IP address and port — and a UDP and a TCP server can share a port number — the author first doubles the ceiling to roughly 128k, still far short of the target. Attaching around 450 network cards, each adding its own IP address, is considered and rejected as a hardware fix. The software answer is AnyIP: a single ip -6 route add local command pointing an entire IPv6 /64 at the loopback device gives the machine about 18 quintillion local addresses to listen on. The IPv4 equivalent, a subnet holding 15 million addresses, would cost around $250 million according to the author.
Twenty terabytes of processes
With addressing solved, the next wall is memory. One server process consumes about 1.5MB of RAM, so 15 million of them would need roughly 20TB. Drawing on earlier projects — running 10 million Codex CLIs on one server and building a userland Linux scheduler in Rust — the author instead loads every guest into a single process. A sandboxing technique the author calls LFI provides memory isolation and replaces each guest's syscalls with calls into a host handler, so the runtime controls all I/O while the CPU switches between guests. The process effectively becomes its own miniature operating system.
Sixteen bytes per server
The key insight is that the minimal server loop carries almost no state: a resume address plus two file descriptors fit into a 16-byte context, so suspending and resuming all 15 million guests costs about 220MB, and bit packing could bring that down to 8 bytes per guest. Assuming one million concurrently active TCP connections at roughly 5KB each adds about 5GB, while idle connections are treated as free — landing at around half of the 10GB budget. According to the project's title, the networking layer is completed with smoltcp, DPDK and AF_XDP: a userspace TCP/IP stack paired with kernel-bypass packet I/O, sidestepping the per-syscall path that capped the baseline server at 65k requests per second.
Why it matters
The experiment is a vivid demonstration that density limits come from per-process overhead and kernel code paths, not from hardware. A conventional deployment spends megabytes and full syscalls per server; a specialised runtime spends bytes and a userspace network stack. The individual techniques — AnyIP for effectively unlimited local addresses, fault-isolation sandboxing of many guests inside one process, and kernel-bypass networking — are directly relevant to hyper-dense hosting, large-scale honeypots, per-tenant isolation and sandboxing research. The satire also makes a half-serious point: the cost of putting a network endpoint online is an engineering choice rather than a law of nature.
- #linux
- #networking
- #rust
- #kernel-bypass
- #web-servers