// the find
quinn-rs/quinn
Async-friendly QUIC implementation in Rust
Quinn is a pure-Rust async QUIC implementation that splits cleanly into three layers: a sans-IO protocol state machine (quinn-proto), tuned UDP socket handling (quinn-udp), and a tokio-based high-level API (quinn). It's for Rust developers who need to speak QUIC directly — whether building custom protocols, HTTP/3 stacks, or anything that benefits from multiplexed streams without TCP's head-of-line blocking.
The sans-IO core in quinn-proto is a genuinely good architectural decision: the protocol logic is fully deterministic and testable without network I/O, and it opens the door to non-tokio runtimes (smol support is already there). Pluggable crypto via rustls means you can swap in post-quantum key exchange without touching the protocol layer — the post_quantum test file shows this is a real, tested path. The congestion control options (New Reno, CUBIC, BBR) are all present and the BBR implementation includes min-max filtering, not just a sketch. MTUD (Maximum Transmission Unit Discovery) is implemented, which most QUIC libraries skip entirely and which matters for performance on real networks.
Documentation is thin for anything beyond the happy path — the book covers basic connection setup and data transfer, but there's nothing on connection migration, 0-RTT, or the datagrams API, all of which require reading source code. The single UDP socket per endpoint design is correct for QUIC but the README buries the buffer-sizing warning in a collapsed details section; this will bite anyone running under any real load who doesn't read carefully. HTTP/3 is not included — Quinn is a transport, and you need a separate crate (h3) on top, which adds integration surface area that isn't mentioned at all. The pluggable runtime abstraction is real but the smol runtime has effectively no documentation and it's unclear how well-exercised it is compared to the tokio path.