Running 15 Million Web Servers on a Single VM: The Extreme Experiment with smoltcp, DPDK, and AF_XDP

A single VM runs 15M web server listeners via smoltcp, DPDK, and AF_XDP, showing userspace networking's limits.
The article covers an experiment running 15 million web servers on one VM by using the Rust-based smoltcp userspace TCP/IP stack with DPDK or AF_XDP to bypass the kernel, eliminating interrupt and context-switch overhead. The 15 million refers to simultaneously listening sockets with minimal memory per connection, making it closer to a stress test. It compares DPDK and AF_XDP, notes virtualization challenges, and highlights community concerns about TCP feature coverage, memory control, and scheduling fairness.
Running 15 million web servers on a single VM sounds like fantasy, but a technical article on kapteko.com lays out a path to achieve it: combining smoltcp, DPDK, and AF_XDP to bypass the bottlenecks of the traditional kernel network stack. The article earned 300 points and 32 comments on Hacker News, sparking discussion in the networking and systems programming community.

Core Idea: Move the Kernel Off the Data Path
When the traditional Linux network stack handles massive numbers of connections, every packet must go through interrupts, protocol stack processing, system calls, and context switches—overhead that is dramatically amplified under high concurrency. The key to this experiment is using the userspace protocol stack smoltcp to take over TCP/IP processing, and DPDK or AF_XDP to implement data plane bypass, letting packets enter userspace programs directly—thereby supporting a connection scale on a single VM far beyond the norm.
The so-called 15 million "web servers" essentially refers to the number of sockets simultaneously listening and responding. Each connection consumes very little memory, and the server logic is extremely lightweight—this extreme scenario is closer to a stress test than a production deployment, but it clearly demonstrates the potential boundaries of userspace network stacks.
Why smoltcp
smoltcp is a lightweight userspace TCP/IP protocol stack written in Rust, designed for predictability and low overhead. It does not depend on the operating system kernel's networking features, and developers can precisely control buffers, timeouts, and connection state. For scenarios requiring millions of concurrent connections, this controllability offers advantages over a general-purpose kernel stack.
Rust's memory safety features also reduce the risk of implementing complex networking logic in userspace—although some unsafe code blocks are still hard to avoid when pursuing extreme performance.
Userspace network stack refers to an architecture that moves the TCP/IP protocol processing logic traditionally handled by the operating system kernel into userspace processes. In standard Linux, applications interact with the kernel protocol stack through the socket API, and every packet goes through NIC interrupts, kernel network layer processing, system calls, and other steps. A userspace network stack lets the application directly take over packet parsing, connection state maintenance, and protocol processing, thereby eliminating context switches and memory copies between kernel and userspace. The cost is that the application must implement the complete protocol logic, connection scheduling, and resource management itself. Common userspace network stacks besides smoltcp include lwIP and mTCP, which are typically used in conjunction with data plane technologies like DPDK and AF_XDP to achieve lower latency and higher throughput in high-concurrency scenarios.
DPDK and AF_XDP: Two Data Plane Bypass Paths
The article title mentions both DPDK and AF_XDP. Both are used to send network packets directly to userspace bypassing the kernel protocol stack, but they serve different purposes.
DPDK is a mature high-performance data plane development kit that requires exclusive access to a NIC or the use of specific drivers, making it suitable for dedicated server environments. AF_XDP is a mechanism provided by the Linux kernel that allows packets from specific queues to be passed to userspace programs with zero copy while retaining kernel management capabilities—more flexible to deploy, but dependent on newer kernel versions.
In virtualized environments, both face additional challenges: virtual NICs have different performance characteristics from physical NICs, and interrupt coalescing, queue counts, and multi-tenant isolation all affect final throughput. The author's choice to experiment in a VM may have been precisely to validate the feasibility of this approach in cloud environments.
Zero copy in this context means that after a packet is received by the NIC, it is not memory-copied through the kernel protocol stack but is directly mapped to a buffer accessible by the userspace program. In the traditional path, after the NIC DMA writes to the kernel buffer, the data must be copied to the socket receive buffer, then copied to the application buffer—multiple copies become significant overhead under high concurrency. AF_XDP uses the UMEM (userspace memory region) and XSK (AF_XDP socket) mechanisms to let the NIC write packets directly into memory pages pre-registered by userspace, which the userspace program reads via polling, achieving zero-copy reception. DPDK, on the other hand, uses poll-mode drivers and huge pages to completely bypass the kernel, with userspace directly managing NIC queues. Zero copy is a key means of reducing latency and improving throughput, but it also requires applications to handle memory lifecycle and concurrency safety themselves.
Engineering Challenges and Real-World Boundaries
According to the Hacker News discussion, the community's attitude toward such extreme experiments is a mix of admiration and skepticism. The 32 comments focused on several aspects: first, whether the rate of connection establishment matches the number of listeners; second, whether memory usage is controllable in realistic simulations; and third, the compatibility of this architecture with application-layer protocols.
Although smoltcp supports TCP, coverage of certain advanced features (such as complex congestion control and TCP options) is limited. This means that the viability of 15 million connections does not equal the ability of 15 million connections to efficiently carry real web traffic.
Another point discussed is scheduling and fairness: a userspace protocol stack bypasses the kernel scheduler, so how to fairly allocate CPU time among massive numbers of connections requires application-layer mechanisms to be designed. This illustrates that userspace network stacks are not a "free lunch"—they shift complexity from the kernel to the developer.
Congestion control is the core mechanism in the TCP protocol for avoiding network overload, including algorithms such as slow start, congestion avoidance, fast retransmit, and fast recovery. The Linux kernel implements multiple congestion control algorithms (such as CUBIC and BBR), validated over long-term production use. As a lightweight userspace stack, smoltcp's implementation of congestion control is relatively simplified or has limited configurability, meaning that in real WAN or high-packet-loss environments, connections based on smoltcp may not adaptively adjust send rates as well as the kernel stack. For scenarios that only listen and maintain large numbers of idle connections, the impact of congestion control is minor; but if these connections need to carry actual web traffic, the absence or simplification of congestion control capabilities becomes a performance bottleneck. This is one reason why userspace protocol stacks struggle to fully replace kernel stacks in general-purpose scenarios.
Implications for the Industry
The value of this experiment lies not in the numbers themselves but in the architectural direction it validates. As cloud-native and edge computing demand higher connection density, userspace networking technologies are spreading from specialized domains like high-frequency trading and CDNs to broader scenarios.
According to the article and community discussion, the applicable scenarios for such approaches lean toward specific workloads: push services requiring massive long connections, lightweight protocol gateways, and network function virtualization testbeds. For conventional web applications, the maturity and maintainability of the kernel network stack remain hard to replace.
The number 15 million is more like a ruler, measuring the boundary that can be reached by combining userspace protocol stacks with data plane bypass technologies. What kinds of applications can be built within that boundary is the question worth exploring next.
One-line Summary
A single VM achieves 15 million web server listeners through a combination of smoltcp, DPDK, and AF_XDP, demonstrating the limits and boundaries of userspace network stacks.
Paragraph Summary
This article describes an experiment running 15 million web servers on a single VM. The core is using the Rust-written userspace TCP/IP stack smoltcp to handle protocol processing, with DPDK or AF_XDP sending packets past the kernel directly into userspace, eliminating interrupt, system call, and context switch overhead. The 15 million refers to the number of simultaneously listening and responding sockets, with extremely low per-connection memory usage—closer to a stress test. The article compares the positioning of DPDK versus AF_XDP and notes the additional challenges of virtualized environments. Community discussion focuses on connection establishment rate, memory controllability, insufficient coverage of advanced TCP features, and userspace scheduling fairness, concluding that the experiment validates an architectural direction but that applicable scenarios remain oriented toward specific workloads.
Related articles

Gemini 4 Neon Released: Tops Coding Benchmarks, Gemini 4 World Model Opens Up
Google releases Gemini 4 Neon, topping the coding agent index with million-token context; Gemini 4 world model opens Project Genie; DeepSeek web search goes free; Microsoft unveils an on-device Windows small model; the White House discusses requiring US companies to disclose whether they use Chinese open-source models.

Google Gemini 4 Neon Released: Just $3 per Million Tokens as the AI Price War Escalates
Google releases Gemini 4 Neon at just $3 per million input tokens; Tencent open-sources Hy4 Flash; DeepSeek scraps search-crawling fees; Microsoft unveils new image and voice models; NVIDIA halts H200 shipments to China; Citi says no reimbursement for AI-agent fraud losses. Today's hardcore AI news in one read.

DeepSeek Quota Wall Pre-embedded in Code: The 48 Hours of Open-Source Migration Tools and Chat Restrictions
DeepSeek pre-embedded quota limits in frontend code two days early; old chats expire after 72 hours of inactivity on Nov 15, while APIs and client code go open-source the same week. This analysis examines the VRAM pressure and three-way resource contention behind rapid quota depletion, and the user dilemma of "not unwilling to pay, but unable to find where to pay."