Need help with coio-rs?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

446 Stars 30 Forks Other 237 Commits 10 Opened issues


Coroutine I/O for Rust

Services available


Need anything else?

Contributors list

Coroutine I/O

Build Status Build status License

Coroutine scheduling with work-stealing algorithm.

WARN: Possibly crash because of TLS inline, check for more detail!


  • Non-blocking I/O
  • Work-stealing coroutine scheduling
  • Asynchronous computing APIs


Note: You must use Nightly Rust to build this Project.

git = ""

Basic Coroutines

extern crate coio;

use coio::Scheduler;

fn main() { Scheduler::new() .run(|| { for _ in 0..10 { println!("Heil Hydra"); Scheduler::sched(); // Yields the current coroutine } }) .unwrap(); }

TCP Echo Server

extern crate coio;

use std::io::{Read, Write};

use coio::net::TcpListener; use coio::{spawn, Scheduler};

fn main() { // Spawn a coroutine for accepting new connections Scheduler::new().with_workers(4).run(move|| { let acceptor = TcpListener::bind("").unwrap(); println!("Waiting for connection ...");

    for stream in acceptor.incoming() {
        let (mut stream, addr) = stream.unwrap();

        println!("Got connection from {:?}", addr);

        // Spawn a new coroutine to handle the connection
        spawn(move|| {
            let mut buf = [0; 1024];

            loop {
                match buf) {
                    Ok(0) => {
                    Ok(len) => {
                        println!("Read {} bytes, echo back", len);
                    Err(err) => {
                        println!("Error occurs: {:?}", err);

            println!("Client closed");


Exit the main function

Will cause all pending coroutines to be killed.

extern crate coio;

use std::sync::Arc; use std::sync::atomic::{AtomicUsize, Ordering}; use std::time::Duration;

use coio::Scheduler;

fn main() { let counter = Arc::new(AtomicUsize::new(0)); let cloned_counter = counter.clone();

let result = Scheduler::new().run(move|| {
    // Spawn a new coroutine
    Scheduler::spawn(move|| {
        struct Guard(Arc<atomicusize>);

        impl Drop for Guard {
            fn drop(&amp;mut self) {
      , Ordering::SeqCst);

        // If the _guard is dropped, it will store 1 to the counter
        let _guard = Guard(cloned_counter);

        println!("Not going to run this line");

    // Exit right now, which will cause the coroutine to be destroyed.
    panic!("Exit right now!!");

// The coroutine's stack is unwound properly
assert!(result.is_err() &amp;&amp; counter.load(Ordering::SeqCst) == 1);


Basic Benchmarks

See benchmarks for more details.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.