Skip to content

@yoshuawuyts yoshuawuyts released this Nov 12, 2019 · 88 commits to master since this release

API Documentation

We were seeing a regression in our fs performance, caused by too many
long-running tasks. This patch fixes that regression by being more proactive
about closing down idle threads.


  • Improved thread startup/shutdown algorithm in task::spawn_blocking.
  • Fixed a typo in the tutorial.
Assets 2

@yoshuawuyts yoshuawuyts released this Nov 11, 2019 · 95 commits to master since this release

API Documentation

This release marks the 1.0.0 release of async-std; a major milestone for our
development. This release itself mostly includes quality of life improvements
for all of modules, including more consistent API bounds for a lot of our

The biggest change is that we're now using the full semver range,
major.minor.patch, and any breaking changes to our "stable" APIs will require
an update of the major number.

We're excited we've hit this milestone together with you all. Thank you!


  • Added Future::join as "unstable", replacing future::join!.
  • Added Future::try_join as "unstable", replacing future::try_join!.
  • Enabled stable and beta channel testing on CI.
  • Implemented FromIterator and Extend for PathBuf.
  • Implemented FromStream for PathBuf.
  • Loosened the trait bounds of io::copy on "unstable".


  • Added a Sync bound to RwLock, resolving a memory safety issue.
  • Fixed a bug in Stream::take_while where it could continue after it should've
  • Fixed a bug where our attributes Cargo feature wasn't working as intended.
  • Improved documentation of Stream::merge, documenting ordering guarantees.
  • Update doc imports in examples to prefer async-std's types.
  • Various quality of life improvements to the future submodule.
  • Various quality of life improvements to the path submodule.
  • Various quality of life improvements to the stream submodule.


  • Removed future::join! in favor of Future::join.
  • Removed future::try_join! in favor of Future::try_join.
Assets 2

@stjepang stjepang released this Nov 8, 2019 · 125 commits to master since this release

API Documentation

This patch upgrades us to futures 0.3, support for async/await on Rust
Stable, performance improvements, and brand new module-level documentation.


  • Added Future::flatten as "unstable".
  • Added Future::race as "unstable" (replaces future::select!).
  • Added Future::try_race as "unstable" (replaces future::try_select!).
  • Added Stderr::lock as "unstable".
  • Added Stdin::lock as "unstable".
  • Added Stdout::lock as "unstable".
  • Added Stream::copied as "unstable".
  • Added Stream::eq as "unstable".
  • Added Stream::max_by_key as "unstable".
  • Added Stream::min as "unstable".
  • Added Stream::ne as "unstable".
  • Added Stream::position as "unstable".
  • Added StreamExt and FutureExt as enumerable in the prelude.
  • Added TcpListener and TcpStream integration tests.
  • Added stream::from_iter.
  • Added sync::WakerSet for internal use.
  • Added an example to handle both IP v4 and IP v6 connections.
  • Added the default Cargo feature.
  • Added the attributes Cargo feature.
  • Added the std Cargo feature.


  • Fixed a bug in the blocking threadpool where it didn't spawn more than one thread.
  • Fixed a bug with Stream::merge where sometimes it ended too soon.
  • Fixed a bug with our GitHub actions setup.
  • Fixed an issue where our channels could spuriously deadlock.
  • Refactored the task module.
  • Removed a deprecated GitHub action.
  • Replaced futures-preview with futures.
  • Replaced lazy_static with once_cell.
  • Replaced all uses of VecDequeue in the examples with stream::from_iter.
  • Simplified sync::RwLock using the internal sync::WakerSet type.
  • Updated the path submodule documentation to match std.
  • Updated the mod-level documentation to match std.


  • Removed future::select! (replaced by Future::race).
  • Removed future::try_select! (replaced by Future::try_race).
Assets 2

@yoshuawuyts yoshuawuyts released this Oct 29, 2019 · 247 commits to master since this release

API Documentation

This patch introduces async_std::sync::channel, a novel asynchronous port of
the ultra-fast Crossbeam channels. This has been one of the most anticipated
features for async-std, and we're excited to be providing a first version of

In addition to channels, this patch has the regular list of new methods, types,
and doc fixes.


Send and receive items from a channel

// Create a bounded channel with a max-size of 1
let (s, r) = channel(1);

// This call returns immediately because there is enough space in the channel.

task::spawn(async move {
    // This call blocks the current task because the channel is full.
    // It will be able to complete only after the first message is received.

// Receive items from the channel
assert_eq!(r.recv().await, Some(1));
assert_eq!(r.recv().await, Some(2));


  • Added Future::delay as "unstable"
  • Added Stream::flat_map as "unstable"
  • Added Stream::flatten as "unstable"
  • Added Stream::max_by
  • Added Stream::min_by_key
  • Added Stream::product as "unstable"
  • Added Stream::sum as "unstable"
  • Added Stream::timeout as "unstable"
  • Added sync::channel as "unstable".
  • Added doc links from instantiated structs to the methods that create them.
  • Implemented Extend + FromStream for PathBuf.


  • Fixed an issue with block_on so it works even when nested.
  • Fixed issues with our Clippy check on CI.
  • Replaced our uses of cfg_if with our own macros, simplifying the codebase.
  • Updated the homepage link in Cargo.toml to point to
  • Updated the module-level documentation for stream and sync.
  • Various typos and grammar fixes.
  • Removed redundant file flushes, improving the performance of File operations


Nothing was removed in this release.

Assets 2

@yoshuawuyts yoshuawuyts released this Oct 16, 2019 · 355 commits to master since this release

This patch stabilizes several core concurrency macros, introduces async versions
of Path and PathBuf, and adds almost 100 other commits.

API Documentation


Asynchronously read directories from the filesystem

use async_std::fs;
use async_std::path::Path;
use async_std::prelude::*;

let path = Path::new("/laputa");
let mut dir = fs::read_dir(&path).await.unwrap();
while let Some(entry) = {
    if let Ok(entry) = entry {
        println!("{:?}", entry.path());

Cooperatively reschedule the current task on the executor

use async_std::prelude::*;
use async_std::task;

task::spawn(async {
    let x = fibonnacci(1000); // Do expensive work
    task::yield_now().await;  // Allow other tasks to run
    x + fibonnacci(100)       // Do more work

Create an interval stream

use async_std::prelude::*;
use async_std::stream;
use std::time::Duration;

let mut interval = stream::interval(Duration::from_secs(4));
while let Some(_) = {
    println!("prints every four seconds");


  • Added FutureExt to the prelude, allowing us to extend Future
  • Added Stream::cmp
  • Added Stream::ge
  • Added Stream::last
  • Added Stream::le
  • Added Stream::lt
  • Added Stream::merge as "unstable", replacing stream::join!
  • Added Stream::partial_cmp
  • Added Stream::take_while
  • Added Stream::try_fold
  • Added future::IntoFuture as "unstable"
  • Added io::BufRead::split
  • Added io::Write::write_fmt
  • Added print!, println!, eprint!, eprintln! macros as "unstable"
  • Added process as "unstable", re-exporting std types only for now
  • Added std::net re-exports to the net submodule
  • Added std::path::PathBuf with all associated methods
  • Added std::path::Path with all associated methods
  • Added stream::ExactSizeStream as "unstable"
  • Added stream::FusedStream as "unstable"
  • Added stream::Product
  • Added stream::Sum
  • Added stream::from_fn
  • Added stream::interval as "unstable"
  • Added stream::repeat_with
  • Added task::spawn_blocking as "unstable", replacing task::blocking
  • Added task::yield_now
  • Added write! and writeln! macros as "unstable"
  • Stabilized future::join! and future::try_join!
  • Stabilized future::timeout
  • Stabilized path
  • Stabilized task::ready!


  • Fixed BufWriter::into_inner so it calls flush before yielding
  • Refactored io::BufWriter internals
  • Refactored net::ToSocketAddrs internals
  • Removed Travis CI entirely
  • Rewrote the
  • Stabilized io::Cursor
  • Switched bors over to use GitHub actions
  • Updated the io documentation to match std's io docs
  • Updated the task documentation to match std's thread docs


  • Removed the "unstable" stream::join! in favor of Stream::merge
  • Removed the "unstable" task::blocking in favor of task::spawn_blocking
Assets 2

@yoshuawuyts yoshuawuyts released this Oct 9, 2019 · 482 commits to master since this release

This patch upgrades our futures-rs version, allowing us to build on the 1.39
beta. Additionally we've introduced map and for_each to Stream. And we've
added about a dozen new FromStream implementations for std types, bringing
us up to par with std's FromIterator implementations.

And finally we've added a new "unstable" task::blocking function which can be
used to convert blocking code into async code using a threadpool. We've been
using this internally for a while now to async-std to power our fs and
net::SocketAddr implementations. With this patch userland code now finally has
access to this too.


Create a stream of tuples, and collect into a hashmap

let a = stream::once(1u8);
let b = stream::once(0u8);

let s =;

let map: HashMap<u8, u8> = s.collect().await;
assert_eq!(map.get(&1), Some(&0u8));

Spawn a blocking task on a dedicated threadpool

task::blocking(async {
    println!("long-running task here");


  • Added stream::Stream::map
  • Added stream::Stream::for_each
  • Added stream::Stream::try_for_each
  • Added task::blocking as "unstable"
  • Added FromStream for all std::{option, collections, result, string, sync} types.
  • Added the path submodule as "unstable".


  • Updated futures-preview to 0.3.0-alpha.19, allowing us to build on rustc 1.39.0-beta.
  • As a consequence of this upgrade, all of our concrete stream implementations
    now make use of Stream::size_hint to optimize internal allocations.
  • We now use GitHub Actions through actions-rs,
    in addition to Travis CI. We intend to fully switch in the near future.
  • Fixed a bug introduced in 0.99.6 where Unix Domain Listeners would sometimes become unresponsive.
  • Updated our sync::Barrier docs to match std.
  • Updated our stream::FromStream docs to match std's FromIterator.
Assets 2

@yoshuawuyts yoshuawuyts released this Sep 28, 2019 · 560 commits to master since this release

This release came slightly ahead of schedule in order to fix compatibility issues with the newly released futures-preview@0.3.0-alpha.19 and Rust 1.39 beta release. Additionally we've introduced documentation for futures concurrency, and several new io::Read methods!


  • Added README to examples directory.
  • Added concurrency documentation to the futures submodule.
  • Added io::Read::take method.
  • Added io::Read::by_ref method.
  • Added io::Read::chain method.


  • Pin futures-preview to 0.3.0-alpha.18, to avoid rustc upgrade problems.
  • Simplified extension traits using a macro.
  • Use the broadcast module with std::sync::Mutex, reducing dependencies.
Assets 2

@yoshuawuyts yoshuawuyts released this Sep 26, 2019 · 588 commits to master since this release

This release includes 16 new APIs, including new streams combinators, Futures concurrency macros, and extensions to the sync and io submodules.

example using future::join

use async_std::future;

let a = future::ready(1);
let b = future::ready(2);
let c = future::ready(3);

let f = future::join!(a, b, c);
assert_eq!(f.await, (1, 2, 3));


  • Added future::join macro as "unstable"
  • Added future::select macro as "unstable"
  • Added future::try_join macro as "unstable"
  • Added future::try_select macro as "unstable"
  • Added io::BufWriter struct
  • Added stream::Extend trait
  • Added stream::Stream::chain method
  • Added stream::Stream::filter method
  • Added stream::Stream::inspect method
  • Added stream::Stream::skip_while method
  • Added stream::Stream::skip method
  • Added stream::Stream::step_by method
  • Added sync::Arc struct from stdlib
  • Added sync::Barrier struct as "unstable"
  • Added sync::Weak struct from stdlib
  • Added task::ready macro as "unstable"


  • Correctly marked the pin submodule as "unstable" in the docs
  • Updated tutorial to have certain functions suffixed with _loop
  • io traits are now re-exports of futures-rs types, allowing them to be
  • stream traits are now re-exports of futures-rs types, allowing them to be
  • prelude::* now needs to be in scope for functions io and stream traits
    to work
Assets 2

@yoshuawuyts yoshuawuyts released this Sep 19, 2019 · 657 commits to master since this release

This release adds several new combinators, a work-stealing executor, and the ability to collect streams using IntoStream and FromStream.

Additionally async-attributes 1.0 has been released which adds support for async fn main, #[test] async fn, and #[bench] async fn.


let a = stream::once(1u8);
let b = stream::once(2u8);
let c = stream::once(3u8);

let s = stream::join!(a, b, c);

assert_eq!(s.collect().await, vec![1u8, 2u8, 3u8]));


  • Added stream::Stream::collect as "unstable"
  • Added stream::Stream::enumerate
  • Added stream::Stream::fuse
  • Added stream::Stream::fold
  • Added stream::Stream::scan
  • Added stream::Stream::zip
  • Added stream::join macro as "unstable"
  • Added stream::DoubleEndedStream as "unstable"
  • Added stream::FromStream trait as "unstable"
  • Added stream::IntoStream trait as "unstable"
  • Added io::Cursor as "unstable"
  • Added io::BufRead::consume method
  • Added io::repeat
  • Added io::Slice and io::SliceMut
  • Added documentation for feature flags
  • Added pin submodule as "unstable"
  • Added the ability to collect a stream of Result<T, E>s into a
    Result<impl FromStream<T>, E>


  • Refactored the scheduling algorithm of our executor to use work stealing
  • Refactored the network driver, removing 400 lines of code
  • Removed the Send bound from task::block_on
  • Removed Unpin bound from impl<T: futures::stream::Stream> Stream for T
Assets 2

@yoshuawuyts yoshuawuyts released this Sep 12, 2019 · 760 commits to master since this release


  • Added tests for io::timeout
  • Added io::BufRead::fill_buf, an async fn counterpart to poll_fill_buf
  • Added fs::create_dir_all
  • Added future::timeout, a free function to time out futures after a threshold
  • Added io::prelude
  • Added net::ToSocketAddrs, a non-blocking version of std's ToSocketAddrs
  • Added stream::Stream::all
  • Added stream::Stream::filter_map
  • Added stream::Stream::find_map
  • Added stream::Stream::find
  • Added stream::Stream::min_by
  • Added stream::Stream::nth


  • Polished the text and examples of the tutorial
  • cargo fmt on all examples
  • Simplified internals of TcpStream::connect_to
  • Modularized our CI setup, enabled a rustfmt fallback, and improved caching
  • Reduced our dependency on the futures-rs crate, improving compilation times
  • Split io::Read, io::Write, io::BufRead, and stream::Stream into
    multiple files
  • fs::File now flushes more often to prevent flushes during seek
  • Updated all dependencies
  • Fixed a bug in the conversion of File into raw handle
  • Fixed compilation errors on the latest nightly
Assets 2
You can’t perform that action at this time.