rust-lang/futures-rs

This system is the \futures-rs\ library, a comprehensive toolkit for asynchronous programming in Rust. It provides core abstractions for concurrent execution, including futures, streams, and sinks, along with primitives for inter-task communication via channels and synchronization. The library also includes utilities for asynchronous I/O, task spawning, and testing, alongside procedural macros to simplify async-await patterns.

37 changes.

The project underwent a major architectural shift by decomposing into a Cargo workspace of specialized sub-crates, aligning core traits with the Rust standard library, and introducing comprehensive asynchronous primitives for I/O, channels, and synchronization. This period focused on stabilizing the async-await macro ecosystem, enhancing executor capabilities, and establishing robust testing and benchmarking infrastructure to support the new modular design.

14 changes.

This period focused on expanding the crate's core infrastructure by introducing the futures-task crate for task spawning and waker utilities, alongside new procedural macros for concurrent operations and testing. Significant refactoring replaced the heavy pin-project dependency with pin-project-lite to reduce overhead, while comprehensive new combinators were added for streams and I/O testing.

Users can now wrap futures and streams with \Abortable\ to allow remote cancellation via an \AbortHandle\. When the handle's \abort\ method is called, the wrapped task completes immediately with an \Aborted\ error (for futures) or terminates (for streams), enabling clean shutdown of long-running or blocking asynchronous operations.

futures-util/src · high confidence

The futures-task crate now includes explicit LICENSE-APACHE and LICENSE-MIT symlink files and a README.md. This clarifies the dual licensing (Apache-2.0 or MIT) for users and documents the usage instructions and the minimum supported Rust version (1.71).

futures-task · high confidence

New example files have been added to demonstrate asynchronous programming patterns using the \futures\ crate. The \examples/functional\ example shows a functional approach using \collect()\ to gather stream values into a vector, while the \examples/imperative\ example demonstrates an imperative loop-based approach using \next().await\ to process stream items one by one. Both examples utilize a \ThreadPool\ executor and \mpsc\ channels to handle concurrent message passing.

examples/functional, examples/imperative · high confidence

The \FuturesUnordered\ stream now exposes several new public APIs: \into\_iter()\ for consuming the set, \iter()\ and \iter\_mut()\ for borrowing futures (with \iter\_mut\ restricted to \Unpin\ futures), \iter\_pin\_ref()\ and \iter\_pin\_mut()\ for pinning-aware iteration, and \clear()\ to remove all futures without draining. Internally, the implementation has been split into separate modules (\abort.rs\, \iter.rs\, \task.rs\, \ready\_to\_run\_queue.rs\) and renamed internal structures (e.g., \Inner\ to \ReadyToRunQueue\) to improve clarity and maintainability. The type also implements \Extend\ and has fixed several soundness issues related to iteration and task dropping.

_futures-util/src/stream/futures\unordered · high confidence

A new \futures-test\ crate has been added to provide common utilities for testing components built on futures-rs. Users can now include \futures-test = "0.3"\ in their \Cargo.toml\ to access these testing helpers. The crate requires Rust 1.71 or later and is dual-licensed under Apache-2.0 and MIT.

futures-test · high confidence

The \futures-executor\ crate now includes an \enter\ API that marks the current thread as being within an executor's dynamic extent, preventing accidental nested execution by returning an error if an executor is already active. Additionally, a new \UnparkMutex\ synchronization primitive is introduced to ensure that concurrent unpark invocations result in exactly one poll invocation per wakeup, handling race conditions between polling and waiting states in the thread pool implementation.

futures-executor/src · high confidence

The \futures-io\ crate now provides \AsyncRead\, \AsyncWrite\, \AsyncSeek\, and \AsyncBufRead\ traits, which serve as asynchronous analogs to the standard library's \std::io\ types. These traits integrate with the asynchronous task system, allowing operations like \poll\_read\ and \poll\_write\ to return \Poll::Pending\ and wake the current task when data is not yet available, rather than blocking the thread. The implementation includes default behaviors for vectored I/O operations, delegating to single-buffer methods when specific optimizations are not provided.

futures-io/src · high confidence

The \futures-util\ crate now includes a new \lock\ module providing asynchronous synchronization primitives. This adds a \Mutex\ type that supports non-blocking \try\_lock\, asynchronous \lock\ (returning a future), and ownership-aware variants (\lock\_owned\, \try\_lock\_owned\) for use in async contexts, alongside a \BiLock\ for managing two-owner split resources (such as reader/writer halves of a stream) with \poll\_lock\ and \reunite\ capabilities. These types are available when the \std\ or \alloc\ features are enabled and require atomic pointer support.

futures-util/src/lock · high confidence

The \futures-sink\ crate has been introduced as a standalone workspace component, providing the \Sink\ trait for asynchronous value transmission. This trait defines a two-phase send protocol involving \poll\_ready\, \start\_send\, \poll\_flush\, and \poll\_close\, allowing users to manage buffered asynchronous I/O operations. The crate is designed to be \no\_std\ compatible by default, with optional \alloc\ and \std\ features, and includes implementations of \Sink\ for \Vec\ and \VecDeque\ when the \alloc\ feature is enabled.

futures-sink/src · high confidence

A new \futures\ crate has been added to the workspace, acting as a unified facade that re-exports core types, extension traits, and macros from the underlying \futures-core\, \futures-io\, \futures-sink\, \futures-util\, and \futures-channel\ crates. This allows users to depend on a single crate to access the full asynchronous programming toolkit, including futures, streams, sinks, and executors, with feature flags controlling the availability of optional components like async-await macros and thread-pool executors.

futures/src · high confidence

The \futures-channel\ crate is introduced, providing asynchronous communication primitives for concurrent tasks. It includes a single-producer, single-consumer \oneshot\ channel for sending a single value between tasks, and a multi-producer, single-consumer (\mpsc\) channel. The implementation supports both \std\ and \no\_std\ environments (via the \alloc\ feature), utilizing a custom user-space lock for synchronization and ensuring thread safety through \Arc\-based internal state.

futures-channel/src · high confidence

This change introduces the \futures-channel\ crate's multi-producer, single-consumer (mpsc) channel implementation, providing \Sender\ and \Receiver\ types for asynchronous message passing. The module includes a lock-free atomic FIFO queue for core coordination, implements the \Sink\ trait for senders to support backpressure-aware sending, and defines specific error types (\SendError\, \TrySendError\, \TryRecvError\, \RecvError\) to handle channel disconnection, capacity limits, and empty states. Users can now create bounded or unbounded channels to communicate between async tasks, with the receiver implementing \Stream\ for consuming messages.

futures-channel/src/mpsc · high confidence

The \futures-test\ crate now exposes an \AsyncReadTestExt\ trait in the \futures\_test::io::read\ module, providing three combinators to help test asynchronous readers: \assert\_unmoved\ verifies that a reader is not moved after being polled, \interleave\_pending\ injects \Poll::Pending\ results between successful reads to test resilience, and \limited\ restricts the number of bytes returned per \poll\_read\ call. These utilities are re-exported from the new \futures\_test::io::read\ submodule, which consolidates async read testing helpers.

futures-test/src/io/read · high confidence

The \futures-test\ crate now includes a \Limited\ adaptor and corresponding extension traits (\AsyncReadTestExt\ and \AsyncWriteTestExt\) to help test async I/O implementations. The \Limited\ wrapper restricts the number of bytes read or written in a single call, allowing tests to verify how code handles partial reads/writes and backpressure scenarios.

futures-test/src/io · high confidence

The \futures-util\ stream module now provides a comprehensive set of new adapters for streams returning \Result\ types, including \try\_chunks\, \try\_ready\_chunks\, \try\_buffered\, \try\_buffer\_unordered\, \try\_flatten\_unordered\, \try\_forward\, \try\_all\, \try\_any\, \try\_take\_while\, \try\_skip\_while\, \try\_unfold\, \into\_async\_read\, and \into\_stream\. These additions enable users to chunk, buffer, flatten, and forward try-streams with fine-grained control over concurrency and error propagation, while the new \into\_async\_read\ adapter allows seamless conversion of try-streams into standard async I/O readers.

_futures-util/src/stream/try\stream · high confidence

The \futures-util\ library introduces several new future primitives and combinators to \futures-util/src/future\. Users can now abort running futures using the new \abortable\ function and \AbortHandle\. A new \always\_ready\ combinator provides a zero-allocation, immediately-ready future for use cases like boxed trait objects. The \Either\ type now implements \Future\, \Stream\, and \Sink\, allowing conditional selection between different future/stream/sink types. \join\_all\ and \try\_join\_all\ have been optimized to dynamically switch to \FuturesOrdered\ for large numbers of futures. Additionally, \poll\_immediate\ allows polling a future once and returning immediately, and \select\_ok\ provides a way to select the first successful future from a list.

futures-util/src/future · high confidence

This change introduces a comprehensive set of new asynchronous I/O utilities in \futures-util/src/io\. Users can now wrap synchronous \std::io\ types with \AllowStdIo\ to use them in async contexts, and leverage new buffered types like \BufReader\, \BufWriter\, and \LineWriter\ for efficient I/O operations. The module also adds combinators such as \Chain\ for linking readers, \copy\ and \copy\_buf\ for transferring data, and \copy\_buf\_abortable\ for cancellable copies. Additionally, new extension methods and types like \Empty\, \Repeat\, \Cursor\, \Take\, and \Window\ are provided to enhance async stream and reader manipulation.

futures-util/src/io · high confidence

The \futures-task\ crate is introduced to provide core primitives for task management, including the \Spawn\ and \LocalSpawn\ traits for pushing futures onto executors, and the \ArcWake\ trait for converting \Arc\-wrapped types into \Waker\ objects. It also includes \FutureObj\ and \LocalFutureObj\ for custom trait object representations (useful in \no\_std\ contexts), \WakerRef\ for lifetime-bound waker references, and \noop\_waker\ utilities. This module consolidates task-related functionality previously scattered in \futures-core\, making it available as a standalone dependency for executors and runtime implementations.

futures-task/src · high confidence

The \futures-macro\ crate now provides procedural macros that enable new async capabilities for users. The \\#\[futures::test\]\ attribute allows marking async functions as tests, automatically handling the executor setup. New \join!\ and \try\_join!\ macros allow awaiting multiple futures concurrently, while \select!\ and \select\_biased!\ macros enable selecting the first completed future from a set of branches. Additionally, the \stream\_select!\ macro provides a way to select the next item from multiple streams concurrently.

futures-macro · high confidence

The \futures-util\ sink module now includes several new combinators to enhance sink composition and control. Users can now buffer items with \SinkExt::buffer\, discard items with \sink::drain\, and fan out items to multiple sinks with \SinkExt::fanout\. Additionally, \SinkExt::feed\ allows sending items without blocking on flush, \SinkExt::unfold\ creates a sink from a stateful function, and \SinkExt::with\_flat\_map\ transforms items into streams before sending. Error handling is also improved with \SinkExt::sink\_err\_into\ for automatic error conversion via the \Into\ trait.

futures-util/src/sink · high confidence

The \StreamExt\ trait now includes \all\, \any\, \count\, and \cycle\ methods. \all\ and \any\ provide short-circuiting checks against a predicate that returns a \Future\<Output=bool\>\, terminating immediately upon finding a \false\ or \true\ result respectively. \count\ returns a future that resolves to the total number of items in the stream. \cycle\ creates an infinite stream that restarts from the beginning once the original stream is exhausted.

futures-util/src/stream/stream · high confidence

The \futures-util\ stream module now includes several new primitives and combinators: \abortable\ for stopping a stream via an \AbortHandle\, \poll\_immediate\ for polling a stream without blocking, and \select\_with\_strategy\ for custom polling strategies between two streams. Additionally, \FuturesOrdered\ has been re-implemented to use \FuturesUnordered\ internally with a binary heap for ordering, and \SelectAll\ now exposes iterators for inspecting and modifying its contained streams.

futures-util/src/stream · high confidence

The \futures-util\ crate now exposes \SpawnExt\ and \LocalSpawnExt\ traits in the \futures\_util::task\ module, providing convenient \spawn\, \spawn\_with\_handle\, \spawn\_local\, and \spawn\_local\_with\_handle\ methods for \Spawn\ and \LocalSpawn\ implementations. These extensions allow users to easily spawn asynchronous tasks on executors like \ThreadPool\ or \LocalPool\, with \spawn\_with\_handle\ variants returning a \RemoteHandle\ to await the result of the spawned future.

futures-util/src/task · high confidence

The \futures-test\ crate now includes a \task\ module providing utilities to assist in testing asynchronous code. This adds \noop\_context\ and \panic\_context\ for creating \Context\ objects that either ignore or panic on waker calls, alongside \noop\_waker\ and \panic\_waker\ for similar waker behaviors. It also introduces \NoopSpawner\, \PanicSpawner\, and \RecordSpawner\ to implement the \Spawn\ trait for discarding, panicking on, or recording spawned futures respectively. Additionally, \new\_count\_waker\ allows users to create wakers that track wake counts via \AwokenCount\, facilitating assertions on task scheduling behavior.

futures-test/src/task · high confidence

The \futures-test\ crate now provides an \AsyncWriteTestExt\ trait with combinators to help verify \AsyncWrite\ implementations during testing. Users can wrap writers with \assert\_unmoved\_write\ to detect invalid pinning/movement, \interleave\_pending\_write\ to simulate intermittent pending states, \limited\_write\ to restrict bytes written per poll, and \track\_closed\ to ensure writers are not used after being closed.

futures-test/src/io/write · high confidence

The futures-test crate now exposes a FutureTestExt trait with combinators designed to help verify future behavior during testing. Users can wrap a future with pending\_once to force an initial Pending state before the inner future is polled, or use interleave\_pending to insert a Pending state between every poll. Additionally, assert\_unmoved allows checking that a future is not moved after being polled, and run\_in\_background executes a future on a dedicated background thread.

futures-test/src/future · high confidence

The \futures-test\ crate now provides a suite of combinators and assertion macros to help verify async behavior. Users can wrap futures, streams, sinks, and async I/O types with \AssertUnmoved\ to ensure they are not moved between polls, or with \InterleavePending\ to force a \Pending\ result between actual operations for more thorough testing. Additionally, \TrackClosed\ allows tracking whether a sink or async write has been closed, panicking or returning errors if used afterwards. Stream assertions (\assert\_stream\_pending\, \assert\_stream\_next\, \assert\_stream\_done\) and an \async\ test macro are also included to simplify test writing.

futures-test/src · high confidence

The repository has been initialized with core project files, including a comprehensive CHANGELOG.md documenting releases up to 0.3.34, dual Apache-2.0/MIT licensing, and a README.md specifying a Rust 1.71 minimum version requirement. Development tooling is established via .editorconfig, .rustfmt.toml (configuring Rustfmt 2024 style), .taplo.toml, and .gitignore. Additionally, triagebot.toml is added to automate issue/PR labeling based on file paths, and .git-blame-ignore-revs is configured to ignore formatting commits.

(repo-wide) · high confidence

The \async\_await\ module in \futures-util\ is now stabilized, providing the \join!\, \try\_join!\, \select!\, \select\_biased!\, \stream\_select!\, \poll!\, and \pending!\ macros for working with asynchronous code. These macros are implemented as procedural macros (relying on \futures\_macro\) and are gated behind the \async-await-macro\ feature, which is enabled by default. The \select!\ macro now supports nested invocations and allows non-\Unpin\ futures when passed as expressions, while \select\_biased!\ offers deterministic branch selection. Additionally, \try\_join!\ provides early termination on error, and \stream\_select!\ combines multiple streams without requiring \Box\<dyn Stream\>\ allocation.

_futures-util/src/async\await · high confidence

The \src/lib.rs\ file, which previously defined the core \Future\ trait and its associated combinators (such as \map\, \and\_then\, \select\, and \join\), has been deleted. This change removes the legacy asynchronous execution model from the public API, indicating a migration to a new task system or executor architecture that no longer relies on this specific trait definition.

src · high confidence

The \ready!\ macro in \futures-core\ is now soft-deprecated, directing users to use the equivalent \ready!\ macro from the Rust standard library (\core::task::ready\) instead, which has been available since Rust 1.64. This change aligns the library with standard library practices and reduces duplication, while the macro itself remains functional to maintain backward compatibility.

futures-core/src/task · high confidence

The \futures-channel\, \futures-executor\, and \futures-util\ crates now include their respective Apache-2.0 and MIT license files directly within their package directories (as symlinks to the root licenses), ensuring proper distribution. Additionally, the minimum supported Rust version (MSRV) for these utility crates has been raised to Rust 1.71, as reflected in their updated README documentation.

futures-channel, futures-executor, futures-util · high confidence

The \futures-core\ and \futures-sink\ crates now include their own \LICENSE-APACHE\, \LICENSE-MIT\, and \README.md\ files (as symlinks or direct content) to ensure license compliance and documentation are distributed with the subcrates. This change addresses packaging requirements by making license information explicitly available in each crate's directory, rather than relying solely on the root repository's license files.

futures-core, futures-sink · high confidence

The internal task module now includes an AtomicWaker synchronization primitive, implemented in a new atomic\_waker.rs file and exposed via the internal module. This component coordinates concurrent notifications with consumers potentially updating the underlying task to wake up, using atomic operations and memory ordering to ensure safe access to the waker cell. The implementation supports both standard atomic operations and portable-atomic for targets without native atomic CAS support.

futures-core/src/task/\\internal · high confidence

The \futures-util\ crate has migrated from \pin-project\ to \pin-project-lite\, reducing the dependency footprint and unsafe code usage. This change introduces new implementations for \catch\_unwind\, \flatten\, \fuse\, and \map\ combinators, which now leverage the lighter pinning macro. Additionally, the \Shared\ future type has been enhanced with \WeakShared\ support, pointer equality checks (\ptr\_eq\), and pointer hashing (\ptr\_hash\), while \RemoteHandle\ no longer requires the \Send\ bound on its output type.

futures-util/src/future/future · high confidence

The implementation of TryFuture combinators (such as map\_ok, and\_then, try\_flatten) has been refactored to replace the heavy pin-project crate with pin\_project-lite, reducing binary size and compilation time. Additionally, the internal structure now wraps futures in a new IntoFuture adapter before applying transformations, which unifies the handling of TryFuture and Future traits and reduces code duplication across the combinator implementations.

_futures-util/src/future/try\future · high confidence

The \futures-core\ crate now re-exports \Future\ and \Stream\ directly from the Rust standard library (\core::future::Future\ and \core::future::Stream\) instead of defining its own versions. This change aligns the crate with the Rust 2021 edition, where these traits are stabilized in \std\/\core\. Consequently, users should rely on the standard library traits for type definitions, while \futures-core\ continues to provide the \TryFuture\, \TryStream\, \FusedFuture\, and \FusedStream\ traits, along with \BoxFuture\/\BoxStream\ types, which remain specific to the futures ecosystem.

futures-core/src · high confidence

Add thread notification benchmarks; Added benchmarks for BiLock, flatten\_unordered, futures\_unordered, and select; Added benchmarks for MPSC channel operations; Added comprehensive test suite for futures-channel; Added comprehensive tests for LocalPool executor behavior; Added no-std test suite for futures crate; Added tests for macro re-exports in futures 0.4; Added tests for macro reexports in futures 0.4; Comprehensive test suite for futures-rs library; Reintroduces disabled integration tests for futures and streams; Removed legacy test suite for futures combinators.

The repository has been reorganized into a Cargo workspace containing the main \futures\ crate (version 0.4.0-alpha.0) alongside its sub-crates (\futures-core\, \futures-util\, \futures-channel\, \futures-executor\, \futures-io\, \futures-sink\, \futures-task\, \futures-macro\, and \futures-test\). This change introduces several dependency updates: \syn\ is upgraded to version 3.0 in \futures-macro\, \portable-atomic\ is updated to version 1.3 in \futures-core\ and 1.13.1 in \futures-util\, \spin\ is updated to 0.12.0 in \futures-util\, and \pin-project\ is set to 1.0.11 in test and dev dependencies. The workspace also adds example crates (\examples/functional\, \examples/imperative\) and test crates (\macro-tests\, \macro-reexport\, \no-std\), while establishing workspace-wide lint configurations.

(dependencies) · high confidence

Add license files and README to futures-io crate; License files distributed to futures subcrate.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 79 → 78 (-1.1)
• Rubric changed (rubric-2026.09.10 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 95 → 95 (+0.0)
• Architecture 100 → 98 (-1.1)
• Maturity 61 → 61 (+0.1)
• Readiness 93 → 93 (+0.4)
• Security 95 → 95 (+0.0)
• Performance 90 (new)

• Hotspot: futures-util/src/stream/stream/flatten_unordered.rs (futures-util/src/stream/stream/flatten_unordered.rs)
• Off-boarding risk: anonymized user #1

• Confusingly similar methods: is_connected_to checks if a specific receiver is still connected, while same_receiver checks if two senders are connected to the same receiver. The names are semantically distinct but structurally similar, potentially leading to misuse. Additionally, is_connected_to takes a receiver argument, while same_receiver takes another sender.
• Dependency hygiene PARTLY measured — Cargo dependencies read, no committed lock to grade for currency
• Documentation: no project overview (README.md)
• Duplicate intent in Receiver methods: Both try_next and try_recv are exposed on Receiver and UnboundedReceiver. These methods perform the same non-blocking receive operation. This creates confusion for users about which method to use.
• Inverted test pyramid
• Low cohesion: SplitSink (LCOM4 4) (futures-util/src/stream/stream/split.rs)
• Low cohesion: With (LCOM4 4) (futures-util/src/sink/with.rs)
• Off-boarding risk: anonymized user #1
• Redundant method in UnboundedSender: start_send is present on UnboundedSender but is semantically identical to unbounded_send (non-blocking). In the futures crate, start_send is typically part of the async Sink protocol for buffered sends, but for UnboundedSender, it duplicates the immediate send capability.
• Semantic overlap in naming: try_send on Sender and unbounded_send on UnboundedSender both perform non-blocking, immediate send operations. The naming convention differs (try_ vs unbounded_) despite identical operational semantics (returning immediately with a Result indicating success or failure without waiting).
• Split futures-util

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

rust-lang/futures-rs was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.