quinn

https://github.com/quinn-rs/quinn/issues/224#issuecomment-38... It's lovely to see the polite and respectful back and forth in this comment thread where the Iroh folks are talking about deciding to fork. :)

At Obscura we just tunnel WireGuard over QUIC's unreliable datagram mechanism to make it look like HTTP/3 (for DPI): https://github.com/Sovereign-Engineering/obscuravpn-client/b... We just upstreamed our patch to quinn-rs that pads Datagrams to MTU: https://github.com/quinn-rs/quinn/pull/2274

ah very sorry, I can see how this isn't all that clear. In the comment you've mentioned when I say "custom protocol" I mean a custom QUIC ALPNs: https://datatracker.ietf.org/doc/html/rfc7301 When we talk to mainline it's for discovery, which is separate from iroh connections, which always uses QUIC. Specifically: our fork of quinn, an implementation of QUIC in rust. Iroh is tightly coupled to quinn, and isn't swappable. Getting no_std support for us basically boils down to "can we get quinn to support no_std?". For that, see: https://github.com/quinn-rs/quinn/issues/579

No problem, here are some examples of it: * Quinn(A QUIC implementation, in particular `quinn-proto` is sans-IO, whereas the outer crate, `quinn`, is Tokio-based)[0) * str0m(A WebRTC implementation that I work on, it's an alternative to `webrtc-rs`. We don't have any IO-aware wrappers, the user is expected to provide that themselves atm)[1] 0: https://github.com/quinn-rs/quinn 1: https://github.com/algesten/str0m/

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,

Anecdotal evidence, but many large rust async code bases perform significantly better if you are using a single threaded runtime vs. a multithreaded runtime. Here is an issue for the quinn crate that implements QUIC: https://github.com/quinn-rs/quinn/issues/1433 We have had very similar experiences when developing https://github.com/n0-computer/iroh And this is with quinn still carrying around the synchronization primitives to make everything Send. Another piece of anecdotal evidence: the functional collection library https://github.com/bodil/im-rs comes in two flavours: one using Arc and one using Rc. The reason for this is that you get a significant performance increase by using Rc (where manipulating the refcount is just an integer inc/dec) vs Arc where manipulating the refcount needs to be an atomic op. Last but not least - often maki

Is it possible to compile quicly cli (referenced in the blog post) with musl instead of glibc. I had to add signal.h and it then compiled successfully (using openssl-1.1k) but I got illegal instruction core dumped when executing cli. https://github.com/h2o/quicly There are a few Rust alternatives for QUIC. Anyone tried them and have comments. https://github.com/cloudflare/quiche https://github.com/quinn-rs/quinn https://github.com/mozilla/neqo

Btw, the QUIC library that Firefox relies on is written in Rust: https://github.com/mozilla/neqo A bit weird though that they didn't cooperate with existing Rust quic stacks like quinn. https://github.com/quinn-rs/quinn

You can use `Futures::StreamExt::buffer_unordered` for this. [1] is an example where I used it for benchmark which creates a certain amount of QUIC connections at a time. But you can also spawn all tasks upfront via `tokio::spawn`, and let them wait on a `tokio::sync::Semaphore` before making the request. The drawback of this is that you might allocate more memory for tasks upfront - but if you don't have an extremely high number it might not matter. [1] https://github.com/quinn-rs/quinn/blob/de627437bc7d836564c36...

I'm unifying Rust's async HTTP implementations H1, H2, H3 and Google's tarpc in Rust~Actix~Torchbear. I just don't have a lot of time now sice my house got broken and I don't have enough money to rent anywhere. It also needs a lot of work on the parsing layer, and the laptops with my notes on them are hard to keep with me as I move around. https://github.com/google/tarpc https://github.com/actix/actix-web/tree/master/actix-http/sr... https://github.com/hyperium/h2 https://github.com/djc/quinn/tree/main/quinn-h3 https://github.com/speakeasy-engine/torchbear/blob/master/sr... ~ There's beauty in this with the fluency in which complex applications like the coming secure social network, Radiojade, are built. See this example: !# https://github.com/foundpatternscellar/ping-pong/blob/master... Curl users, do you really want to stick with Bash'

There are like, three different QUIC implementations in Rust. And one of them is by (and being used by) Cloudflare, so it's going to have pretty significant production use. (The others may be as well but I am less familiar with where they're used) * https://github.com/cloudflare/quiche * https://github.com/djc/quinn * https://github.com/mozilla/neqo/

Thank you for openly discussing this. Ralith has mostly responded in terms of the API our quinn-proto offers; it seems like you and/or ghedo may have missed that? I just also wanted to respond to this: > nor would they likely be able to add the interfaces we need in a reasonable timescale, nor would they likely tolerate our requests to do so. I have a pretty different perspective on this: I've offered opportunities for collaboration from the moment ghedo started quiche in his free time, and explicitly offered to make changes to quinn{,-proto} to be able to do the kind of things that you might need when it was clear Cloudflare would be adopting quiche as well. As an example, I mentioned making our TLS implementation pluggable, something we started doing anyway over the past week (see https://github.com/djc/quinn/pull/211 and https://github

I still don't quite understand why Cloudflare is going their own way rather than joining our Rust implementation (https://github.com/djc/quinn). So far the primary maintainer told me "I quite like how quiche has turned out, and we already started integrating into internal stuff", which I haven't found very satisfying. Perhaps they just want to strategically own their own stack, but it seems to me aligning with the broader Rust ecosystem and getting features for free from the community would also bring some value. Initially I thought it was mainly about integrating with BoringSSL rather than ring and rustls, but even the promise of pluggable crypto didn't seem to affect their decision. Would be nice to have more clarity on this. (Previously they were happy enough to use Quinn for their Noise experiment, although without crediting our proje