NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
crates.io
crates.io, #2782 most downloaded on crates.io
Structured concurrency operations for async Rust
Latest stable
7.7.1
Last release 10 months ago
18 Jan 2026
Release timing varies
gaps range from 2 weeks to 12 months
Some releases are documented
notes for 17 of 31 stable releases
Nothing withdrawn
no release was ever pulled
5 years old
31 releases · first in 2021
Drag across the ruler to compare, or tap a release to open it.
fix(indexer): use a static divisor when possible by @Ddystopia in https://github.com/yoshuawuyts/futures-concurrency/pull/217
Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.7.0...v7.7.1
fix unused-mut error by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/212
futures-buffered optional dependency in respect to alloc by @Ddystopia in https://github.com/yoshuawuyts/futures-concurrency/pull/207FutureGroup for concurrent streams by @matheus-consoli in https://github.com/yoshuawuyts/futures-concurrency/pull/219Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.6.3...v7.7.0
Your coding agent can read these notes before it upgrades. Set up the MCP server →
fix: nightly clippy::needless_lifetimes warnings by @crepererum in https://github.com/yoshuawuyts/futures-concurrency/pull/200
clippy::needless_lifetimes warnings by @crepererum in https://github.com/yoshuawuyts/futures-concurrency/pull/200Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.6.2...v7.6.3
fix: clippy::doc_lazy_continuation by @crepererum in https://github.com/yoshuawuyts/futures-concurrency/pull/192
clippy::doc_lazy_continuation by @crepererum in https://github.com/yoshuawuyts/futures-concurrency/pull/192bitvec with fixedbitset by @crepererum in https://github.com/yoshuawuyts/futures-concurrency/pull/191FromConcurrentStream for Result<Vec<T>, E> by @tyilo in https://github.com/yoshuawuyts/futures-concurrency/pull/193ConsumerState::Break doc by @tyilo in https://github.com/yoshuawuyts/futures-concurrency/pull/194no_std by @Easyoakland in https://github.com/yoshuawuyts/futures-concurrency/pull/196Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.6.1...v7.6.2
Add checks for msrv and semver by @matheus-consoli in https://github.com/yoshuawuyts/futures-concurrency/pull/181
FutureGroup by @soooch in https://github.com/yoshuawuyts/futures-concurrency/pull/179Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.6.0...v7.6.1
This release introduces the ConcurrentStream API: a concurrent async/.await adaptation of Rayon's ParallelStream API. We've been trying to implement t
This release introduces the ConcurrentStream API: a concurrent async/.await adaptation of Rayon's ParallelStream API. We've been trying to implement this API for the past six or so years, and we've happy to announce we finally have a working implementation!
The main feature that sets this implementation apart from other, similar attempts is that it works for any existing Stream impl. All you need to do is call the .co() method to obtain a ConcurrentStream, and from that point all Stream combinators should just work as expected:
use futures_concurrency::prelude::*;
let v: Vec<_> = stream::repeat("chashu")
.co() // ← call this to convert any `Stream` into a `ConcurrentStream`
.take(2)
.map(|msg| async move { format!("hello {msg}") })
.collect()
.await;
assert_eq!(v, &["hello chashu", "hello chashu"]);
See the call to collect at the end there? That's right: that's concurrent async iteration, collecting back into a single structure. This makes writing fan-out/fan-in pipelines trivial to author. But that's not all: in addition to converting into collections, we can also directly convert collections into ConcurrentStream implementations too:
use futures_concurrency::prelude::*;
let v: Vec<_> = vec!["chashu", "nori"]
.into_co_stream() // ← call this to convert collections into concurrent async iterators
.map(|msg| async move { format!("hello {msg}") })
.collect()
.await;
The amount of concurrency by default is unbounded, but can be bounded by calling the limit method. This will apply backpressure should the stream produce items faster than the concurrent iterator can process them.
This API also resolves the buffered streams problem. ConcurrentStream removes the need for the dreaded combination of mapping to futures and then calling the futures-rs buffered method. Instead it ensures that the processing of items in a loop always happens in concert with the execution of the concurrent futures [^queuing-theory].
[^queuing-theory]: There is a more elaborate version of this problem we don't have a user story for yet. Rust's futures model couples "liveness" to "backpressure". In theory we might fail to send keepalive messages if we apply backpressure for too long; this is a direct artifact of queueing theory, and would be a reason to add some form of async Future::pending / Future::poll_pending method for. This is a more subtle / niche issue than "barbara battles buffered streams". But it's worth explicitly calling out the limits of our solutions.
Notably this API will work with any async runtime or async framework, because it makes no assumptions about the underlying runtime. The only assumption is makes is that an allocator is available. This means that at this time, unlike most other APIs in futures-concurrency this will not work on #[no_std] environments. This, however, is not an inherent restriction but merely an artifact of the implementation. In the future we may explore porting this to a #[no_std] compatible version - this will require some minor API changes, but should, as a system, likely work.
In order to make this system work with parallel execution it should be possible to write a custom adapter. We encourage async runtimes to wrap the ConcurrentStream trait exposed in this crate to create their own ParallelStream system. This can depend on the runtime, and ensure that all execution not only happens concurrently, but can also be scheduled on multiple cores.
We're excited for people to give this a try. We certainly hope this lowers the bar for correctly applying structured, asynchronous, concurrent streaming processing in Rust!
todo! by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/176{Future,Stream}::wait_until by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/167Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.5.0...v7.6.0
This release adds support for no_std and alloc environments to futures-concurrency. Starting this release (v7.5.0) you can pass feature flags to your
This release adds support for no_std and alloc environments to futures-concurrency. Starting this release (v7.5.0) you can pass feature flags to your Cargo.toml to select the right feature set for your environment:
[dependencies]
# std
futures-concurrency = "7.5.0"
# alloc
futures-concurrency = { version = "7.5.0", default-features = false, features = ["alloc"] }
# no_std
futures-concurrency = { version = "7.5.0", default-features = false }
Waker::clone_from internally by @miguelraz in https://github.com/yoshuawuyts/futures-concurrency/pull/161no_std tests by @jmintb in https://github.com/yoshuawuyts/futures-concurrency/pull/159no_std support by @alexmoon in https://github.com/yoshuawuyts/futures-concurrency/pull/163Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.4.3...v7.5.0
This release fixes a bug introduced in v7.3.0 related to the try_join family of operations. Please consider upgrading to this release if you're runnin
This release fixes a bug introduced in v7.3.0 related to the try_join family of operations. Please consider upgrading to this release if you're running v7.3.0 or later.
Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.4.2...v7.4.3
handle empty lists for {try,}join by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/154
{try,}join by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/154Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.4.1...v7.4.2
Add lending stream examples for Group types @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/151
Group types @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/151Group types @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/151Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.4.0...v7.4.1
use futures_concurrency::stream::StreamGroup;
use lending_stream::prelude::*;
use futures_lite::stream;
// Setup the stream group and populate it with one stream
let mut group = StreamGroup::new();
group.insert(stream::once(4));
let mut index = 3;
let mut out = 0;
let mut group = group.lend_mut();
while let Some((group, num)) = group.next().await {
if index != 0 {
// Update the group while iterating over the group's contents
group.insert(stream::once(index));
index -= 1;
}
out += num;
}
assert_eq!(out, 10);
Add stream::StreamGroup by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/149
stream::StreamGroup by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/149future::FutureGroup by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/150Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.3.0...v7.4.0
This release makes progress towards resolving https://github.com/yoshuawuyts/futures-concurrency/issues/137 for the join and try_join operations. Rath
This release makes progress towards resolving https://github.com/yoshuawuyts/futures-concurrency/issues/137 for the join and try_join operations. Rather than dropping futures when the enclosing future is dropped, futures are instead now dropped as soon as they're done yielding data. This has the immediate benefit that tracing the execution duration of the contained futures will generally more accurate. But in the longer term this also sets us up to support concurrent asynchronous destructor behavior, where async destructors can begin executing as soon as individual futures are ready, rather then once the future is dropped.
This change is considered semver minor since we've intentionally never guaranteed drop ordering of futures, knowing we wanted to enable concurrent execution of asynchronous destructors once those become available in the language.
array::join by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/138vec::join by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/141{array, vec}::try_join by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/142tuple::join by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/143tuple::try_join by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/145Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.2.1...v7.3.0
Update Join documentation by @matheus-consoli in https://github.com/yoshuawuyts/futures-concurrency/pull/132
Join documentation by @matheus-consoli in https://github.com/yoshuawuyts/futures-concurrency/pull/132Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.2.0...v7.2.1
feat: Implement Zip for tuples up to 12 elements by @poliorcetics in https://github.com/yoshuawuyts/futures-concurrency/pull/125
Zip for tuples up to 12 elements by @poliorcetics in https://github.com/yoshuawuyts/futures-concurrency/pull/125Chain for tuples up to 12 elements by @poliorcetics in https://github.com/yoshuawuyts/futures-concurrency/pull/124TryJoin for tuples up to 12 elements by @poliorcetics in https://github.com/yoshuawuyts/futures-concurrency/pull/122core::fmt::Debug requirements by @poliorcetics in https://github.com/yoshuawuyts/futures-concurrency/pull/123Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.1.1...v7.2.0
shuffle vec/array/tuple futures/streams for benchmark by @wishawa in https://github.com/yoshuawuyts/futures-concurrency/pull/117
Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.1.0...v7.1.1
Add happy eyeballs example by @eholk in https://github.com/yoshuawuyts/futures-concurrency/pull/93
RaceOk for tuples by @matheus-consoli in https://github.com/yoshuawuyts/futures-concurrency/pull/109tuple_for_each!, tuple_len! and simplify gen_conditions! a lot by @poliorcetics in https://github.com/yoshuawuyts/futures-concurrency/pull/99MaybeDone from tuple::join by @matheus-consoli in https://github.com/yoshuawuyts/futures-concurrency/pull/103MaybeDone from array::race_ok by @matheus-consoli in https://github.com/yoshuawuyts/futures-concurrency/pull/107tuple::merge by @matheus-consoli in https://github.com/yoshuawuyts/futures-concurrency/pull/96RaceOk impls on tuples by @matheus-consoli in https://github.com/yoshuawuyts/futures-concurrency/pull/112Join for tuples by @matheus-consoli in https://github.com/yoshuawuyts/futures-concurrency/pull/113Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v7.0.0...v7.1.0
*Futures-concurrency is a library prototyping async/.await-based concurrency operations intended for inclusion in the stdlib. This effort is lead by Y
Futures-concurrency is a library prototyping async/.await-based concurrency operations intended for inclusion in the stdlib. This effort is lead by Yosh, as part of the Rust Async WG.
As part of the Rust Async WG we're working towards a proposal for a base set of "futures concurrency" operations we can add to the stdlib. This library serves as a testing ground for those APIs, enabling us to experiment separately from the stdlib. And for users of stable Rust to use the futures concurrency operators without relying on nightly.
What's change in this release over v6.0.0 is that we recognize that this library isn't just a prototype for the stdlib. It needs to be usable standalone as well. This means rather than using core::async_iter::AsyncIterator, we opt to use the ecosystem-standard futures_core::Stream instead. This enables this library to be used in production, enabling testing and benchmarking to take place, all while still working towards inclusion in the stdlib.
Another focus in this release has been on performance. We've added a modest suite of benchmarks to the repository, and used that to track our performance optimizations. The main performance optimization we've found is the implementation of "perfect waking". When a futures-concurrency future is woken, it now only wakes the futures which were scheduled to be woken - and no more. Together with some other optimizations this has lead to drastic performance improvements across the APIs where we've implemented it:
group v6.0.1 (prev release) v7.0.0 (curr release)
array::merge 10 1.46 4.2±0.28µs 1.00 2.9±0.05µs
array::merge 100 7.60 365.5±13.01µs 1.00 48.1±1.44µs
array::merge 1000 20.88 39.2±1.49ms 1.00 1877.5±57.35µs
vec::merge 10 1.73 4.9±0.31µs 1.00 2.9±0.05µs
vec::merge 100 8.33 360.6±3.84µs 1.00 43.3±0.80µs
vec::merge 1000 17.67 38.0±0.41ms 1.00 2.2±0.06ms
We've only implemented it for two APIs so far - but that already has shown a 30%-95% performance improvement. They're synthetic benchmarks, and probably not entirely represenative. But the fact that we're making headway in removing unnecessary wakes has knock-on effects as well. If for whatever reason there are futures in a codebase where spurious waking may be expensive (not ideal, but we've seen it happen), this will ensure that doesn't end up negatively affecting performance. Meaning depending on the scenario, the benefits here may actually show up in application performance.
We've started work on two new traits: stream::Zip and stream::Chain. These now exist in addition to stream::Merge, providing control over order of execution. Unlike their stdlib Iterator counterparts, we've chosen to expose this functionality as separate traits. Not only does that enable seamless switching between merge, zip, and chain semantics. It als prevents tuple-nesting when combining more than two streams together:
let s1 = stream::repeat(0).take(5);
let s2 = stream::repeat(1).take(5);
let s3 = stream::repeat(2).take(5);
// With the `StreamExt::zip` method
let s = (s1).zip(s2).zip(s3);
while let Some(((n1, n2), n3))) = s.next().await {
assert_eq!((n1, n2, n3), (0, 1, 2));
}
// With the `Zip` trait
let s = (s1, s2, s3).zip();
while let Some((n1, n2, n3)) = s.next().await {
assert_eq!((n1, n2, n3), (0, 1, 2));
}
Support for arrays and vectors has landed, with support for tuples expected soon. This requires generating some macros like we have for merge already, and we just haven't quite gotten around to that yet. Soon!
stream::Merge for tuples up to length 12 by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/19Stream definition by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/35Race for tuple fair by @matheus-consoli in https://github.com/yoshuawuyts/futures-concurrency/pull/58MaybeDone from impl Join for Vec by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/29impl Merge for Vec (1/2) by @eholk in https://github.com/yoshuawuyts/futures-concurrency/pull/50gen_conditions by @matheus-consoli in https://github.com/yoshuawuyts/futures-concurrency/pull/59array::from_fn to safely create output array of MaybeUninit by @matheus-consoli in https://github.com/yoshuawuyts/futures-concurrency/pull/60impl Merge for Vec (2/2) by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/57Fuse from impl Merge for array by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/70{array,vec}::race fair by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/71MaybeDone from impl Join for array by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/72poll_states and remove Fuse for vec::merge by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/79array::Merge by @yoshuawuyts in https://github.com/yoshuawuyts/futures-concurrency/pull/75Full Changelog: https://github.com/yoshuawuyts/futures-concurrency/compare/v6.0.1...v7.0.0 Read the Documentation: https://docs.rs/futures-concurrency/7.0.0/
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
One column per quarter.