Wabrix, yet another data plane?

Wabrix, yet another data plane?

I’ve been working on Wabrix, a new high-performance network data plane.

Whenever a new data plane pops up, the immediate and fair question is: "Why not use DPDK (first released in 2010), VPP (developed in 2002 and open-sourced in 2016) or Click (first published in 1999)?"

Right, there are many options available, but each has its own set of trade-offs and limitations.

While DPDK, VPP, and Click pioneered high-performance packet processing, they carry the architectural baggage of the eras in which they were designed. Building a new data plane today isn't about reinventing the wheel—it is about addressing the fundamental friction points these legacy giants introduced regarding memory safety, extensibility, and kernel integration.

Here is a breakdown of the specific trade-offs that leave room for a modern alternative:

The Legacy Giants and Their Trade-offs

DPDK (The Brute-Force Hardware Takeover)

FD.io VPP (The Graph-Node Powerhouse)

Click Modular Router (The Pioneer of Modularity)

The Modern Paradigm Shift

The argument for building a new data plane today centers on leveraging technologies that simply did not exist when the legacy frameworks were architected. A modern data plane can solve the historical trade-offs by focusing on:

  1. Kernel Synergy via AF_XDP: Instead of stealing the NIC from Linux (like traditional DPDK), modern kernel-bypass uses AF_XDP. This allows for zero-copy packet mapping directly into user space at hardware speeds, while still letting the Linux kernel handle the management plane, standard traffic, and traditional network observability tools.
  2. Memory Safety by Default: Writing the core data plane in a memory-safe systems language (like Rust) eliminates entire classes of vulnerabilities—such as dangling pointers or data races—without sacrificing C-level performance.
  3. Sandboxed Extensibility: Historically, extending a data plane meant linking unsafe C code. By integrating a WebAssembly runtime, a modern data plane can execute highly optimized, custom packet-processing plugins in an isolated sandbox. If a WebAssembly module panics, the main data plane pipeline catches it and replaces the module with a proven fallback version.
  4. Hot reloading: Modern data planes can dynamically update their packet-processing plugins without requiring a restart. This allows for rapid iteration and deployment of new features and bug fixes without downtime.
  5. Open Platform & Ergonomic Plugin APIs: Legacy data planes often force third-party developers to navigate obscure C macros, private graph APIs, and host-coupled build systems just to inspect a header. An open, modern platform exposes a stable, language-agnostic API contract (e.g., via WebAssembly Interface Types). Third-party vendors can build, test, and ship custom processing modules in Rust, C/C++, Go, or Zig using standard toolchains—democratizing data plane development without exposing core internal state.

When you look at the landscape through this lens, the question isn't why someone would build another data plane. The question is how long the industry can continue accepting memory-unsafe, monolithic architectures when the primitives for secure, zero-copy, sandboxed packet processing are finally available.