async-std has officially been discontinued. We recommend that all users and libraries migrate to the excellent smol project.

We created async-std to demonstrate the value of making a library as close to std as possible, but async. We think that demonstration was successful, and we hope it will influence future design and development directions of async in std. However, in the meantime, the smol project came about and provided a great executor and libraries for asynchronous use in the Rust ecosystem. We think that resources would be better spent consolidating around smol, rather than continuing to provide occasional maintenance of async-std. As such, we recommend that all users of async-std, and all libraries built on async-std, switch to smol instead.

In addition to the smol project as a direct replacement, you may find other parts of the futures ecosystem useful, including futures-concurrency, async-io, futures-lite, and async-compat.

• IO Safety traits implementations

• Various dependencies updates
• Export BufReadExt and SeekExt from async_std::io

This release stabilizes some long-awaited APIs that help people build async interfaces and interoperate with other APIs.

• task::spawn_blocking is now stabilized. We consider it a fundamental API for bridging between blocking code and async code, and we widely use it within async-std's own implementation.
• Add TryFrom implementations to convert TcpListener, TcpStream, UdpSocket, UnixDatagram, UnixListener, and UnixStream to their synchronous equivalents, including putting them back into blocking mode.

• async-std no longer depends on num_cpus; it uses functionality in the standard library instead (via async-global-executor).
• Miscellaneous documentation fixes and cleanups.

This release improves compile times by up to 55% on initial builds, and up to 75% on recompilation. Additionally we've added a few new APIs and made some tweaks.

• TcpListener::into_incoming to convert a TcpListener into a stream of incoming TCP connections

• The internal extension_trait macro had been removed. This drastically improves compile times for async-std, but changes the way our documentation is rendered. This is a cosmetic change only, and all existing code should continue to work as it did be fore.

• Some internal code has been de-macro-ified, making for quicker compile times.
• We now use the default recursion limit.

• Several docs improvements / fixes.

Happy New Year everyone! This patch stabilizes the async_std::channel submodule, removes the deprecated sync::channel types, and introduces the tokio1 feature.

As part of our 1.8.0 release last month we introduced the new async_std::channel submodule and deprecated the unstable async_std::sync::channel types. You can read our full motiviation for this change in the last patch notes. But the short version is that the old channels had some fundamental problems, and the sync submodule is a bit of a mess.

This release of async-std promotes async_std::channel to stable, and fully removes the async_std::sync::channel types. In practice many libraries have already been upgraded to the new channels in the past month, and this will enable much of the ecosystem to switch off "unstable" versions of async-std.

use async_std::channel;

let (sender, receiver) = channel::unbounded();

assert_eq!(sender.send("Hello").await, Ok(()));
assert_eq!(receiver.recv().await, Ok("Hello"));

The Tokio project recently released version 1.0 of their runtime, and the async-std team would like to congratulate the Tokio team on achieving this milestone.

This release of async-std adds the tokio1 feature flag, enabling Tokio's TLS constructors to be initialized within the async-std runtime. This is in addition to the tokio02 and tokio03 feature flags which we were already exposing.

In terms of stability it's worth noting that we will continue to provide support for the tokio02, tokio03, and tokio1 on the current major release line of async-std. These flags are part of our public API, and removing compat support for older Tokio versions is considered a breaking change.

• Added the tokio1 feature (#924)
• Stabilized the async_std::channel submodule (#934)

• Removed deprecated sync::channel (#933)

• Fixed a typo for [sic] FuturesExt trait (#930)
• Update the link to cargo-edit in the installation section of the docs (#932)
• Fixed a small typo for stream (#926)

• Updated rand to 0.8 (#923)
• Migrated RwLock and Barrier to use the async-lock crate internally (#925)
• Replaced uses of deprecated the compare_and_swap method with compare_exchange (#927)

This patch introduces async_std::channel, a new submodule for our async channels implementation. channels have been one of async-std's most requested features, and have existed as "unstable" for the past year. We've been cautious about stabilizing channels, and this caution turned out to be warranted: we realized our channels could hang indefinitely under certain circumstances, and people ended up expressing a need for unbounded channels.

So today we're introducing the new async_std::channel submodule which exports the async-channel crate, and we're marking the older unstable async_std::sync::channel API as "deprecated". This release includes both APIs, but we intend to stabilize async_std::channel and remove the older API in January. This should give dependent projects a month to upgrade, though we can extend that if it proves to be too short.

The rationale for adding a new top-level channel submodule, rather than extending sync is that the std::sync and async_std::sync submodule are a bit of a mess, and the libs team has been talking about splitting std::sync up into separate modules. The stdlib has to guarantee it'll forever be backwards compatible, but async-std does not (we fully expect a 2.0 once we have async closures & traits). So we're experimenting with this change before std does, with the expectation that this change can serve as a data point when the libs team decides how to proceed in std.

• async_std::channel as "unstable" #915
• async_std::process as "unstable" #916

• Fixed mentions of the tokio03 flags in the docs #909
• Fixed a double drop issue in StreamExt::cycle #903

• updated pin-project to v0.2.0

docs.rs documentation

This patch adds a feature to enable compatibility with the new tokio 0.3.0 release, and updates internal dependencies.

Since earlier this year async-std has shipped with a tokio-02 feature flag that enables libraries written for the tokio runtime to work on async-std as well. When this flag is enabled async-std ensures that whenever it spawns a thread on its executor, the right tokio-specific thread state is initialized for it. That means no more thread 'main' panicked at 'not currently running on the Tokio runtime.' errors when running async-std and tokio in the same application.

This patch introduces a new feature flag: tokio-03 which enables the same mechanism for the latest version of the tokio runtime. As applications migrate from tokio 0.2.x to 0.3.x, mixing dependencies that use both async-std and tokio will continue to work.

• Add tokio03 feature flag (#895)

• chore: update dependencies (#897)

• Fix TcpListener::incoming. (#889)
• Fix tokio compatability flag. (#882)

• Added UdpSocket::peek and UdpSocket::peek_from (#853)

• Extracted the executor into async-global-executor (#867)

• Updated various dependencies

• Ensure UnixStream::into_raw_fd doesn't close the file descriptor (#855)
• Fixed wasm builds and ensured better dependency management depending on the compile target (#863)

• Switched from smol to individual executor parts. (#836)
• Replaced internal Mutex implementation with async-mutex. (#822)

• Added missing Send guards to Stream::collect. (#665)