Hi everyone,

I’ve been working on an open-source project called ZettaTransport (ZT), and I would love to get some architectural feedback from the experienced Rustaceans here.

It is a custom transport layer protocol built on top of UDP, specifically designed for robotics, industrial automation, and edge IoT networks operating in highly unstable RF environments.

The Motivation: TCP's head-of-line blocking makes it unusable for real-time telemetry over lossy links. Raw UDP offers zero reliability. I evaluated QUIC, but it carries too much HTTP/3 legacy baggage for lightweight edge devices, and I needed native Forward Error Correction (FEC) at Layer 4 so I could compile it directly into my application binaries.

Architecture & Rust Highlights:

• Lock-less I/O Path: This was my biggest focus. I wanted to ensure the server doesn't suffer from thread starvation. The critical paths (ChaCha20 cryptography and UDP send_to operations) are completely decoupled from the main state map locks.
• Active FEC & Congestion Control: Implemented a dual-engine FEC (XOR Parity and Reed-Solomon Erasure Coding) to recover dropped packets mathematically. It also features a TCP-like AIMD congestion control to prevent buffer bloat.
• Connection IDs (CID): Connections use a 64-bit CID instead of IP:Port binding. This allows seamless network handovers (e.g., an AGV jumping from factory Wi-Fi to a 5G network) without dropping the session.
• Async Integration: The core state machine is wrapped in a tokio-compatible ZtStream that natively handles flow backpressure.

What I am looking for: I have written up a full RFC-001 specification for the protocol. I would really appreciate it if anyone could take a look at the codebase or the spec and point out any flaws.

• Are there any hidden await blocking issues in my async tasks?

• Is my approach to decoupling the Mutex state from the crypto operations sound?

• Are there more idiomatic ways to handle the packet serialization/deserialization?
  Links:

• GitHub Repository: GitHub - demirburakk/zetta-transport: An industrial-grade, ultra-resilient UDP transport protocol in Rust for autonomous swarms, robotics, and edge IoT. · GitHub

Thanks in advance for your time and feedback!

3 posts - 2 participants

Read full topic