OMNI-MESH

Zero-allocation mesh networking middleware for autonomous robot fleets, edge-AI swarms, and multi-agent systems.

Written in Rust. Cryptographically signed. Production-ready.

What is OMNI-MESH?

OMNI-MESH is a decentralized peer-to-peer messaging layer designed for robotics and edge-AI deployments where latency, reliability, and security matter. Every node has a cryptographic identity (DID), every message is signed, and delivery is exactly-once with ordering guarantees.

Use cases:

• Multi-robot fleet coordination (warehouse, logistics, agriculture)
• Edge-AI inference mesh (distributed LLM, sensor fusion)
• Autonomous vehicle V2V communication
• Industrial IoT with real-time constraints
• Federated learning model distribution

Key Features

Quick Start

use omnimesh::client::{OmnimeshClient, ClientConfig};
use omnimesh::payload;

// Create two nodes
let robot = OmnimeshClient::builder()
    .with_config(ClientConfig::development())
    .build()
    .expect("Failed to build robot");

let controller = OmnimeshClient::builder()
    .with_config(ClientConfig::development())
    .build()
    .expect("Failed to build controller");

// Send a motion command
let cmd = payload::motion_command(1.0, 0.0, 0.0, 0.0, 0.0, 0.5, 100_000);
controller.send(robot.did, cmd).unwrap();

// Receive and process
if let Some(msg) = robot.receive_timeout(Duration::from_secs(1)) {
    println!("Received: {:?}", msg.payload);
}

// Health monitoring
let health = robot.health();
assert!(health.is_healthy());

Architecture

┌─────────────────────────────────────────────────────┐
│                  Developer SDK                        │
│  OmnimeshClient (send/receive/health/shutdown)       │
├─────────────────────────────────────────────────────┤
│                  Security Layer                       │
│  Ed25519 signing + verification (mode-dependent)     │
├─────────────────────────────────────────────────────┤
│                  Delivery Layer                       │
│  Exactly-once dedup + ordered delivery + DTN         │
├─────────────────────────────────────────────────────┤
│                  Transport Layer                      │
│  Mock | TCP | QUIC (TLS 1.3) + Compression           │
├─────────────────────────────────────────────────────┤
│                  Routing Layer                        │
│  DID→SocketAddr table + UDP gossip discovery         │
├─────────────────────────────────────────────────────┤
│                  Buffer Layer                         │
│  Zero-alloc: RingBuffer, FixedMap, PayloadStorage    │
└─────────────────────────────────────────────────────┘

Operational Modes

Running

# Build

cargo build --release


# Run daemon

cargo run --release -- --config omni-mesh.toml


# Run examples

cargo run --example ping_pong

cargo run --example warehouse_fleet


# Run tests (130 tests)

cargo test


# Run benchmarks

cargo bench

Python SDK

import omnimesh

# Create a client
client = omnimesh.Client(mode="development")
print(f"My DID: {client.did}")

# Send a command
client.send_agent_command(
    target_did_hex="<64-char-hex>",
    command_type="pick",
    target_id=b"robot-1",
    payload=b"shelf-A12"
)

# Receive messages
msg = client.receive(timeout_ms=5000)
if msg:
    print(f"Got {msg['type']} from {msg['sender_did']}")

Configuration

# omni-mesh.toml

[core]

mode = "production"



[node]

node_id = "node-1"



[node.transport]

type = "tcp"

tcp_listen_addr = "0.0.0.0:9000"

tcp_connect_addr = "127.0.0.1:9001"

quic_listen_addr = "0.0.0.0:9443"



[routing]

max_routes = 1024

gossip_interval_ms = 1000

gossip_bind_addr = "0.0.0.0:9999"

Production Deployment Checklist

• Graceful shutdown via Ctrl+C / SIGTERM
• Health check API (client.health())
• Back-pressure with configurable inbox capacity
• Metrics: messages sent/received/dropped
• Condvar-based efficient waiting (no busy-polling)
• Named threads for debugging
• Structured JSON logging
• Ed25519 signature enforcement in production mode
• Exactly-once delivery with persistent deduplication
• 130 tests including concurrency, crash recovery, and edge cases
• Multi-OS CI (Linux, Windows, macOS)
• Security audit in CI pipeline
• Code coverage reporting

Test Coverage

Contributing

PRs welcome. Run cargo test and cargo clippy before submitting.