#async #wormhole


Async calls across non-async functions

14 releases

0.3.7 May 7, 2021
0.3.6 Apr 8, 2021
0.3.3 Feb 4, 2021
0.3.1 Jan 30, 2021
0.1.1 Sep 4, 2020

#2196 in Rust patterns

Download history 19/week @ 2023-10-25 9/week @ 2023-11-01 1/week @ 2023-11-08 17/week @ 2023-11-15 15/week @ 2023-11-22 58/week @ 2023-11-29 15/week @ 2023-12-13 14/week @ 2023-12-20 28/week @ 2023-12-27 3/week @ 2024-01-17 40/week @ 2024-01-24 28/week @ 2024-01-31 2/week @ 2024-02-07

73 downloads per month


848 lines



This library is experimental, I use it to prototype the foundation for Lunatic .

Currently only works in Rust nightly, as it depends on switcheroo.

async-wormhole allows you to .await async calls in non-async functions, like extern "C" or JIT generated code. It runs on Windows, MacOs and Linux (x64 & AArch64).


Sometimes, when running inside an async environment you need to call into JIT generated code (e.g. wasm) and .await from there. Because the JIT code is not available at compile time, the Rust compiler can't do their "create a state machine" magic. In the end you can't have .await statements in non-async functions.

This library creates a special stack for executing the JIT code, so it's possible to suspend it at any point of the execution. Once you pass it a closure inside AsyncWormhole::new you will get back a future that you can .await on. The passed in closure is going to be executed on a new stack.


use async_wormhole::{AsyncWormhole, AsyncYielder};
use switcheroo::stack::*;

// non-async function
extern "C" fn non_async(mut yielder: AsyncYielder<u32>) -> u32 {
	// Suspend the runtime until async value is ready.
	// Can contain .await calls.
    yielder.async_suspend(async { 42 })

fn main() {
    let stack = EightMbStack::new().unwrap();
    let task = AsyncWormhole::<_, _, fn()>::new(stack, |yielder| {
        let result = non_async(yielder);
        assert_eq!(result, 42);

    let outside = futures::executor::block_on(task);
    assert_eq!(outside, 64);


There should be almost no performance overhead to .await calls inside the closure passed to AsyncWormhole::new and caught by async_suspend. But instantiating a new AsyncWormhole will require one memory allocation. And of course you are not going to get perfectly sized stacks.


Licensed under either of

at your option.


Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.