quinn 0.5.1

quinn 0.5.1 is a quick maintenance release to solve a single bug:

• Wake up the connection after a datagram send completes (#553, backported in #554)

This is only relevant if you're using the datagram extension (new in 0.5).

0.5.0

We are happy to announce the release of 0.5.0 of Quinn, our pure-Rust implementation of the QUIC protocol, the next generation TCP replacement protocol currently being standardized at the IETF.

After 3 months of development since the release of 0.4.0, Quinn has been upgraded to the latest draft (draft 24) protocols and has been migrated to std::future::Futures and tokio 0.2. Quinn 0.5.0 is a highly conformant implementation of the latest QUIC draft, according to the interoperability testing data maintained by implementers participating in the QUIC working group.

• Implemented preliminary support for the (draft) datagram extension
• Migrated from slog to tracing
• Improved documentation
• Many smaller bug fixes and refactoring to improve Quinn's internals

Thanks to @jean-airoldie, @NULLx76, @TimonPost, @demimarie-parity and @daxpedda for their contributions.

Quinn has been proven to function well in real-world scenarios, so if you're interested in QUIC, now would be a good time to start testing. The QUIC v1 spec is stabilizing and we expect it will be published as an RFC in the next 6 months.

While we don't always have large amounts of pre-defined good first issues setup due to the fast moving development, we're also always happy to mentor new contributors, independent of their prior level of Rust experience! We tend to respond to issues and PRs pretty quickly, and we have an active Gitter channel.

0.4.0

We are happy to announce the release of 0.4.0 of Quinn, our pure-Rust implementation of the QUIC protocol, the next generation TCP replacement protocol currently being standardized at the IETF.

After 5 months of development since the release of 0.3.0, Quinn has been upgraded to the latest draft (draft 22) protocols. We have created a trait-based abstraction over our use of rustls and ring, so that it will be possible to use Quinn with any TLS implementation implementing these traits, or even alternative non-standard cryptographic protocols. Quinn 0.4.0 is a highly conformant implementation of the latest QUIC draft, according to the interoperability testing data maintained by implementers participating in the QUIC working group.

• A number of improvements to the high-level API to improve usability
• Make it possible to build lower-level quinn-proto crate without rustls/ring
• Moved CI to Azure, which means we now test Windows in addition to Linux and macOS
• Implement coalescing of outgoing packets, reducing handshake overhead
• Allow connection migration to be disabled
• Improved documentation
• Many smaller bug fixes and refactoring to improve Quinn's internals

Note that we plan to merge our branch using std::future::Future and async/await oriented interfaces soon after this release is published, since support for this syntax is stabilizing soon. Therefore, the next release will be designed for use with async and await; we will consider pushing out maintenance releases for 0.4 using "old" futures if there is demand.

Quinn has been proven to function well in real-world scenarios, so if you're interested in QUIC, now would be a good time to start testing. The QUIC v1 spec is stabilizing and we expect it will be published as an RFC in the next 6 months.

While we don't always have large amounts of pre-defined good first issues setup due to the fast moving development, we're also always happy to mentor new contributors, independent of their prior level of Rust experience! We tend to respond to issues and PRs pretty quickly, and we have an active Gitter channel.

0.3.0

We are happy to announce the release of 0.3.0 of Quinn, our pure-Rust implementation of the QUIC protocol, the next generation TCP replacement protocol currently being standardized at the IETF.

After 3 months of development since the release of 0.2.0, 0.3.0 is starting to see some real-world use. Quinn 0.3.0 is a highly conformant implementations of the latest QUIC draft (draft 19), according to the interoperability testing data maintained by implementers participating in the QUIC working group.

• High-level API types are now Send and Sync for use on multi-threaded runtimes
• Extensive refactoring to make the code more maintainable and approachable
• Improved documentation for low-level quinn-proto crate
• Updated protocol support to draft 19
• 0-RTT data exchange is now supported
• Fixed some QUIC-specific issues in rustls (thanks to @ctz for reviewing)
• QPACK and partial HTTP 3 support has been implemented, but is unreleased for now
• Work started to abstract the use of rustls to enable use of other TLS implementations
• Initial benchmarks show 1+ Gbps, with lots of low-hanging optimization fruit still left
• Example code for different use cases (thanks to @povilasb)
• Worked around a networking regression (login only) in macOS 10.14

At this point, we expect the high-level API to only change in minor ways and Quinn has been proven to function well in real-world scenarios (see below), so if you're interested in QUIC, now would be a good time to start testing. The QUIC v1 spec is scheduled to be published as an RFC some time this summer.

We're grateful for the work @ustulation, @nbaksalyar and @povilasb from @maidsafe have contributed to this release. @maidsafe has replaced their internally developed UDP-based protocol with QUIC and Quinn, and in the process contributed a number of bugfixes, added examples and tests. Thanks also to @newpavlov for their contributions. We're happy that @stammw joined the Quinn team as main author of our unreleased quinn-h3 crate.

While we don't always have large amounts of pre-defined good first issues setup due to the fast moving development, we're also always happy to mentor new contributors, independent of their prior level of Rust experience! We tend to respond to issues and PRs pretty quickly, and we have an active Gitter channel.

0.2.0

We (@djc and @Ralith) are happy to announce the release of 0.2.0 of Quinn, our pure-Rust implementation of the QUIC protocol, the next generation TCP replacement protocol currently being standardized at the IETF.

After 3 months of development since the release of 0.1.0, 0.2.0 is much more complete. First and foremost, Quinn 0.2.0 is among the most conformant implementations of the latest QUIC draft (draft 17), according to the interoperability testing data maintained by implementers participating in the QUIC working group. It now supports:

• Stateless retries
• Explicit congestion notification (only Linux support so far -- contributions welcome!)
• Connection migration

These features are currently being worked on:

• 0-RTT data has largely been implemented but still needs tweaking of the API
• HTTP 3 support has been started and is being worked on by our awesome contributor @stammw

We've worked to make Quinn even more modular. It consists of the quinn-proto crate, which contains deterministic protocol logic without touching any I/O APIs, and a quinn crate which leverages tokio to deliver a high-level asynchronous API. (Additionally, we maintain an experimental branch with async/await support.)

We're also grateful for the work @imp, @est31, @psiphi75, and @kryptan have contributed to this release. While we don't always have large amounts of pre-defined good first issues setup due to the fast moving development, we're always happy to mentor new contributors, independent of their prior level of Rust experience!

Finally, we would like to thank the community for their support. To support this release, we've contributed work to libc, tokio, rustls and ring. We'd also like to call out @est31's new rcgen crate, which makes self-signed certificate support easier to use. Quinn would not be possible without the support of the Rust ecosystem.

We're excited to see what's coming for QUIC and Quinn in 2019.