quinn VS laminar

Since it lives on top of UDP, I believe all you need is SOCK_DGRAM, right? The rest of QUIC can be in a userspace library ergonomically designed for your programming language e.g. https://github.com/quinn-rs/quinn - and can interoperate with others who have made different choices.

Alternately, if you need even higher performance, DPDK gives the abstractions you'd need; see e.g. https://dl.acm.org/doi/abs/10.1145/3565477.3569154 on performance characteristics.

> Making things thread safe for runtime-agnostic utilities like WebSocket is yet another price we pay for making everything multi-threaded by default. The standard way of doing what I'm doing in my code above would be to spawn one of the loops on a separate background task, which could land on a separate thread, meaning we must do all that synchronization to manage reading and writing to a socket from different threads for no good reason.

Why so? Libraries like quinn[1] define "no IO" crate to define runtime-agnostic protocol implementation. In this way we won't suffer by forcing ourselves using synchronization primitives.

Also, IMO it's relatively easy to use Send-bounded future in non-Send(i.o.w. single-threaded) runtime environment, but it's almost impossible to do opposite. Ecosystem users can freely use single threaded async runtime, but ecosystem providers should not. If you want every users to only use single threaded runtime, it's a major loss for the Rust ecosystem.

Typechecked Send/Sync bounds are one of the holy grails that Rust provides. Albeit it's overkill to use multithreaded async runtimes for most users, we should not abandon them because it opens an opportunity for high-end users who might seek Rust for their high-performance backends.

[1]: https://github.com/quinn-rs/quinn

quicssh-rs is quicssh rust implementation. It is based on quinn and tokio

Regarding Quinn, I had a blast this week resurrecting an old PR. Looking forward to the next!

By studying u/djcu/hachyderm.io (and others!) excellent work in Quinn, doing a sans I/O implementation of QUIC https://github.com/quinn-rs/quinn we have a way forward.

QUIC isn't web/wasm-compatible because of https://github.com/quinn-rs/quinn/issues/1388, so durian wouldn't either since it's built on top of it.

Quinn, as in the implementation of QUIC? https://github.com/quinn-rs/quinn

You are right, I am planning to switch the transport to UDP + quic using the awesome QUINN library, https://github.com/quinn-rs/quinn .

Hi, I am new to the community, I just started learning rust and created a secure UDP tunnel based on the Quinn library, thanks to Quinn, I didn't need to go into the detail of the QUIC protocol and quickly created a UDP tunnel, and thanks to the BBR congestion control algorithm it uses, the tunnel performs quite well with lousy and long fat network, I didn't do any benchmark, but it performs a lot better (higher throughput with LFN) than most of other TCP tunnel implementations I used before.

enet - Golden standard, tested and reliable - Not native rust - Does not seem to be popular in rust turbulence - Readme says it is not stable, but last meaningful commit was 1 year ago - Lacking documentation and examples - Not very popular laminar - Last meaningful release was 3 years ago (ignoring changes that fix typos etc.) - Despite this, everywhere (book, readme) there are mentions that it is under "active development" - Created for Amethyst, which is dead. I am kinda fearful that the same thing will happen to this lib. Tachyon - New and not tested in the battle - Many features that other libraries have planned, Tachyon actually has implemented - Lacking documentation (except for one big readme file), tests, examples Quinn - Big, under active development (daily commits), very popular because web development. - Modular, ability to just use core implemetation: quinn-proto - Do i really need TLS certificates and cryptography for my playing with friends game server? - Stream based, I would need to implement recv/send messages on top of it (not that hard tbh) - Only reliable stream and "unreliable" messages.

laminar: networking library used with the amethyst game engine.

Maybe check out laminar and quinn, which implement custom protocols on top of UDP (quinn implements QUIC), to get an idea on how to do things.

For the game packets I would suggest https://github.com/amethyst/laminar.

I think that you are referring to something like laminar or turbulence do.