YANET

Note: This project is currently in active development.

YANET is a high-performance modular software router built on DPDK (Data Plane Development Kit) that provides exceptional packet processing capabilities. It's designed to be a versatile network solution that functions as a router, decapsulator, firewall, L3 load balancer, and NAT device, all in one platform.

🌐 Key Features

🚀 High Performance

• DPDK-accelerated packet processing bypasses the kernel networking stack for maximum throughput.
• Achieves near-hardware performance with the flexibility of software.
• NUMA-aware resource management for optimal multi-socket performance.
• Optimized memory management with huge pages support.

🧩 Modular Architecture

• Module system allows enabling only required networking functions.
• Clean separation between control plane and data plane components.
• Flexible pipeline configuration for customized packet processing flows.
• Add or remove functionality without affecting the entire system.

🛡️ Safe Initialization Process

• Controlled system initialization with failsafe mechanisms.
• BGP route announcement control based on system health.

🏗️ Architecture

YANET follows a modular architecture with clear separation between control and data planes:

Data Plane (C & DPDK)

• Implements fast-path packet processing.
• Uses DPDK for direct hardware access and kernel bypass.
• Applies routing decisions, filtering, and packet transformations.
• Achieves high packet throughput with minimal latency.

Control Plane (Go)

• Exposes management API.
• Handles configuration and management functions.
• Manages routing tables and policy.
• ACL compilation (TDB).

🛠️ Technologies

YANET employs a multi-language approach to leverage the strengths of different programming languages:

• C - Data plane and performance-critical components.
• Go - Control plane and orchestration components.
• Rust - CLI tools.
• DPDK - Kernel-bypass networking for high-performance packet processing.
• gRPC - Communication framework for inter-component messaging.
• Protocol Buffers - Efficient binary serialization format. Protobuf API compatibility policy: see docs/proto-compatibility.md.
• Meson - Build system for core components.

🔧 Building & Requirements

System Requirements

• Linux-based operating system (Ubuntu 22.04+ or equivalent recommended).
• Hardware supporting DPDK (Mellanox NICs recommended).
• At least 64GB RAM recommended for production.

Dependencies

• Go 1.21+.
• Rust 1.88+.
• Protobuf compiler 3.0+.
• Meson 0.61+.
• Ninja build system.
• CMake 3.5+.
• GCC/Clang.

Build Instructions

1. Clone the repository:

   git clone https://github.com/yanet-platform/yanet2.git
   cd yanet2
   git submodule update --init

2. Configure and build with Meson:

   meson setup build
   meson compile -C build

3. Build CLI tools:

   cargo build --release

4. Install:

   meson install -C build

Testing

meson test -C build

Running in a Virtual Environment

For repeatable local experiments, use the reusable QEMU lab:

make -C tests/functional prepare-vm
just lab doctor
just lab up
just lab scenario run forward-route
just lab down

Run make all in a Linux build environment before just lab doctor; the Linux guest requires x86_64 ELF dataplane, control-plane, operator, and CLI artifacts. Prepare the functional-test image with make -C tests/functional prepare-vm. On macOS, native Mach-O outputs are not usable lab artifacts. The doctor command also checks the QEMU image and all artifacts required by the lab baseline. Running just lab without a subcommand only prints help.

See the YANET2 Lab guide for manifests, packet probes, troubleshooting, and the built-in forward/route, decap, and NAT64 scenarios.

📄 License

YANET2 is licensed under the Apache License, Version 2.0.

🔗 Additional Resources

• Documentation
• Contributing Guidelines