DPdpc_pw·May 26, 2016
For fibers (AKA Coroutines) in Rust, see mioco https://github.com/dpc/mioco
In Parallelizing the Naughty Dog Engine Using Fibers [video]dpc
mioco
Rust2015–2016
dpc / mioco
mioco
[no longer maintained] Scalable, coroutine-based, fibers/green-threads for Rust. (aka MIO COroutines).
5Distinct people
6Mentions
0Explicit recommenders
149GitHub stars
What to know before exploring
What it is
[no longer maintained] Scalable, coroutine-based, fibers/green-threads for Rust. (aka MIO COroutines).
GitHub
Where it is used
No documented product use has been verified yet.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 12:54:37 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by month6 dated mentions
Observed mentions: 2015-07-18 04:10:03 UTC to 2016-05-26 22:41:01 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| Jul 2015 | 2015-07-01 00:00:00 UTC | 2015-08-01 00:00:00 UTC | 1 | 0 | 1 |
| Aug 2015 | 2015-08-01 00:00:00 UTC | 2015-09-01 00:00:00 UTC | 0 | 0 | 0 |
| Sep 2015 | 2015-09-01 00:00:00 UTC | 2015-10-01 00:00:00 UTC | 0 | 0 | 0 |
| Oct 2015 | 2015-10-01 00:00:00 UTC | 2015-11-01 00:00:00 UTC | 0 | 0 | 0 |
| Nov 2015 | 2015-11-01 00:00:00 UTC | 2015-12-01 00:00:00 UTC | 0 | 0 | 0 |
| Dec 2015 | 2015-12-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 0 | 0 | 0 |
| Jan 2016 | 2016-01-01 00:00:00 UTC | 2016-02-01 00:00:00 UTC | 0 | 0 | 0 |
| Feb 2016 | 2016-02-01 00:00:00 UTC | 2016-03-01 00:00:00 UTC | 1 | 0 | 1 |
| Mar 2016 | 2016-03-01 00:00:00 UTC | 2016-04-01 00:00:00 UTC | 1 | 0 | 1 |
| Apr 2016 | 2016-04-01 00:00:00 UTC | 2016-05-01 00:00:00 UTC | 1 | 0 | 1 |
| May 2016 | 2016-05-01 00:00:00 UTC | 2016-06-01 00:00:00 UTC | 2 | 0 | 2 |
What Hacker News says
6 sourcesHave you tried mioco [1]? It looks fine enough to avoid the callback hell.
[1] https://github.com/dpc/mioco
In The Path to Rust1 million per hour is nothing...
Here, mioco handling 10M http request per second(1) on my desktop:
https://github.com/dpc/mioco/blob/master/BENCHMARKS.md
1) with a bit of cheating http server.
With actual proper http parsing it goes down to 368K req/s, but that's still a lot.
In Making 1M requests with Python-aiohttpAh, async I/O with event loops is a different thing. I thought you were talking about the event loop based model of concurrent programming.
I haven't used mio/mioco (the current async I/O solution for Rust: https://github.com/carllerche/mio/, https://github.com/dpc/mioco), but I've heard good things about it. They seem to interact with safety pretty cleanly.
Rust in 2014 was a very different language. It looked the same at the surface, but a lot of the innards (including the fact that it shipped its own async I/O solution!) have changed since then.
> might have changed
It has. Though the explicitness of Rc<RefCell<T>> is still there, since Rust prefers ownership and mutability implications to be explicit. Not much extra typing, and you can always typedef it.
> a need asynchronous communication inside a thread
Agreed. There are some corout
Read the rest
ine libraries in Rust which are pretty nice. There is active effort towards having coroutines inside the language itself (see https://github.com/erickt/stateful for a POC plugin, which should get RfCd at some point when it's complete).
See also: https://dwrensha.github.io/capnproto-rust/2015/05/25/asynchr... (uses mio)
> How does the eventloop design in Servo look like? Wasn't that some integration with Spidermonkey?
Like I mentioned, I meant the event loop model of communication. We have a lot of message passing between threads, many of which are event loops.
The script thread does feed events into its own event loop (after all, JS is event looped, we need to mirror that), and it works pretty well. We do some gymnastics for thread safety (especially because the Javascript GC is involved) but the interface is safe and clean.
> but this applies also for a lot of other statically typed languages which bring in a better ecosystem for that task.
Sure, but these languages don't have quick prototyping either. Except perhaps Go.
Rust doesn't really end up with an additional burden on prototyping over any other similar statically typed language; the borrow checker is something you rarely tussle with once you get used to it.
> I don't know Scala or Erlang, but based on the results I would assume both are allocating a posix thread for each thread in the software and so it is using the kernel scheduler to switch between them with all the overhead that entails.
Incorrect.
> I have been considering threading in Rust vs Go and that is the biggest difference I see between the approaches. However it should be possible to implement Go style goroutines in Rust using custom dispatch code like old C coroutines. I think I have already seen libraries like that, but I haven't dug in the details to know for sure.
There is https://github.com/dpc/mioco for I/O-based coroutines. For CPU bound tasks you want something like https://github.com/nikomatsakis/rayon.
In Akka, Haskell, Erlang, Go and .NET Core compared on 1M threadsWe're still pretty confident that Rust will be able to support a high quality green threading library and other M:N concurrency libraries without needing to be integrated into the language itself. All the type magic that we do to pass data between threads should work quite well for a green threading library. We already have a couple projects experimenting with this [1], [2], [3]. Servo also has a pretty nifty work-stealing queue [4] that is yet another abstraction for easily sharing data between threads.
1: https://github.com/rustcc/coroutine-rs
2: https://github.com/zonyitoo/simplesched
3: https://github.com/dpc/mioco
4: https://github.com/servo/servo/blob/c76720d67c0d04f6d77c138c...
In Must Be This Tall to Write Multi-Threaded Code