Async Task for WASM

[samcarey]

How would I call an async function from Bevy on WASM? I tried using the async_task example:

fn test(mut commands: Commands, thread_pool: Res<AsyncComputeTaskPool>) {
    commands.spawn().insert(thread_pool.spawn(async move {
        // web request
    }));
}

but it throws

error[E0277]: the trait bound `bevy_tasks::single_threaded_task_pool::FakeTask: bevy::prelude::Component` is not satisfied
  --> client\src\main.rs:50:33
   |
50 |         commands.spawn().insert(thread_pool.spawn(async move {}));
   |                          ------ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `bevy::prelude::Component` is not implemented for `bevy_tasks::single_threaded_task_pool::FakeTask`        
   |                          |
   |                          required by a bound introduced by this call

For more information about this error, try `rustc --explain E0277`.

EDIT: OK I was able to get something working based on the code linked by @mvlabat.
I set up a worker with input and output channels using Tokio.
Here's a working example: https://gist.github.com/samcarey/0899bc8688a31c22028497088e4b17f9

[DJMcNab]

So first of all, it's no longer good style to add tasks directly as a component on an entity - you should instead create a wrapper component (that is because it would break if multiple libraries used the same kind of task)

Additionally, it's possible that this just isn't supported yet; for example, the type being returned is FakeTask, which doesn't seem usable to me

Maybe you should check what bevy_assets does on wasm?

[vladbat00]

I wasn't able to use tasks like this in WASM as well. I had to detach FakeTask, and then use channels to communicate between the task and my game systems.

For example, here's how I use AsyncComputeTaskPool in my project:
https://github.com/mvlabat/muddle-run/blob/b02374bf90f29a246c39d89ebf35ba49f53865b4/libs/shared_lib/src/game/level.rs#L161

The task isn't async itself, but I just needed to send a compute-heavy task to a task pool (it's a bad idea, I know, one shouldn't use the async task pool for this purpose), and I found it to be an easy hack that works for now.

This compiles for WASM as well.

But for web requests, I found that having a separate executor is a bit more convenient to use. It might not be in your case, but if you need more complex logic like listening to a websocket, periodic polling, it doesn't probably fit into a concept of a short-lived task. I picked tokio, so I could also utilize its channels, timers, etc. It was a bit of a headache to get the executor working for WASM though...

My game systems also communicate with it with channels.

For example, here's my UI system sending an auth request on a button click:
https://github.com/mvlabat/muddle-run/blob/507a95a9e728be2723536ee84031f05e490fcb4b/libs/client_lib/src/ui/main_menu_ui.rs#L357

And here it's reading another channel for responses:
https://github.com/mvlabat/muddle-run/blob/507a95a9e728be2723536ee84031f05e490fcb4b/libs/client_lib/src/ui/main_menu_ui.rs#L170

While serving requests is happening in a long-living future that reads the messages in an endless loop:
https://github.com/mvlabat/muddle-run/blob/507a95a9e728be2723536ee84031f05e490fcb4b/libs/client_lib/src/net/auth.rs#L205

I don't claim it's 100% a good pattern, but it's something I've found working well enough for me. If folks here have opinions about this approach, I'm also curious and will be happy to learn different methods of doing asynchronous work in Bevy.

[samcarey]

Thanks so much for this info! It took me a while to get around to looking through your code, but I eventually learned enough to solve my problem. I edited my question with my final solution.

[vladbat00]

Glad it helped!
You can also try using this library for async channels (instead of tokio): https://crates.io/crates/async-channel/1.6.1
If you don't use anything else from tokio, you might want to avoid bringing such a heavy dependency.

[davidlampach]

Are there any updates to this functionality? I don't understand what this FakeTask strict that is being returned is. I am trying to get async working with wasm and bevy.

[alexmadeathing]

Bit of an old thread, but I recently ran into a similar issue (needed to await a blocking call in non-async context). Shopped around a bit and found this new library: https://crates.io/crates/bevy-async-task

Could be useful some. For me, it shrinks my code to:

AsyncTask::new(async { blow_out_butt_cork().await }).blocking_recv()

[simbleau]

Hey, author of that library here. Indeed, the reason I created bevy-async-task was to create a very simple abstraction to compute and retrieve the results for wasm and native. It works great, I've been maintaining it for some time now, and I'll continue ensuring its place in bevy.

That being said, while I support blocking as you mentioned, there is great support for actually running and polling async tasks in the background through bevy_async_task::AsyncTaskRunner, which of course works on WASM. Check out the examples.