Crate tokio_core [] [src]

Future-powered I/O at the core of Tokio

This crate uses the futures crate to provide an event loop ("reactor core") which can be used to drive I/O like TCP and UDP, spawned future tasks, and other events like channels/timeouts. All asynchronous I/O is powered by the mio crate.

The concrete types provided in this crate are relatively bare bones but are intended to be the essential foundation for further projects needing an event loop. In this crate you'll find:

More functionality is likely to be added over time, but otherwise the crate is intended to be flexible, with the PollEvented type accepting any type that implements mio::Evented. For example, the tokio-uds crate uses PollEvented to provide support for Unix domain sockets.

Some other important tasks covered by this crate are:

You can find more extensive documentation in terms of tutorials at


A simple TCP echo server:

extern crate futures;
extern crate tokio_core;

use futures::{Future, Stream};
use tokio_core::io::{copy, Io};
use tokio_core::net::TcpListener;
use tokio_core::reactor::Core;

fn main() {
    // Create the event loop that will drive this server
    let mut core = Core::new().unwrap();
    let handle = core.handle();

    // Bind the server's socket
    let addr = "".parse().unwrap();
    let listener = TcpListener::bind(&addr, &handle).unwrap();

    // Pull out a stream of sockets for incoming connections
    let server = listener.incoming().for_each(|(sock, _)| {
        // Split up the reading and writing parts of the
        // socket
        let (reader, writer) = sock.split();

        // A future that echos the data and returns how
        // many bytes were copied...
        let bytes_copied = copy(reader, writer);

        // ... after which we'll print what happened
        let handle_conn =|amt| {
            println!("wrote {} bytes", amt)
        }).map_err(|err| {
            println!("IO error {:?}", err)

        // Spawn the future as a concurrent task


    // Spin up the server on the event loop;


io [

I/O conveniences when working with primitives in tokio-core


TCP/UDP bindings for tokio-core


The core reactor driving all I/O



A convenience macro for working with io::Result<T> from the Read and Write traits.