bevy async compute broke by MSAA in 0.15, 0.16, and 0.17

[Saratii]

Bevy version

0.14.1 and 0.16.1

[Optional] Relevant system information

8 core processor

What you did

I copied the unofficial example from here. https://bevy-cheatbook.github.io/fundamentals/async-compute.html
I found that it didnt actually work. I minimized it to the provided file down below and it still didn't work. I then copied the official example and the only thing i had to change to break it was adding a camera

In every scenerio described the main thread hangs itself and the app crashes. I believe this is due to the weird programming going on in the bevy TaskPool or including the main thread in the compute thread pool which allows it no CPU time when I create expensive computations.

What went wrong

I expect bevy async compute to not block main and not hang the app.

Additional information

Here is minimal code that breaks the unoffical example

use bevy::prelude::*;
use bevy::tasks::{AsyncComputeTaskPool, Task, TaskPoolBuilder};
use std::collections::HashMap;

#[derive(Resource, Default)]
struct MyMapGenTasks {
    generating_chunks: HashMap<usize, Task<()>>,
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .insert_resource(MyMapGenTasks::default())
        .add_systems(Startup, setup)
        .add_systems(Update, begin_generating_map_chunks)
        .run();
}

fn setup(mut commands: Commands) {
    commands.spawn(Camera3d::default());
    AsyncComputeTaskPool::get_or_init(|| {
        TaskPoolBuilder::new()
            .num_threads(2)
            .stack_size(16 * 1024 * 1024)
            .build()
    });
}

fn generate_map_chunk() {
    let mut sum = 0.0;
    for j in 1..u32::MAX {
        sum += (j as f32).sin().cos().tan().sqrt() + j as f32 * 0.0001;
    }
    println!("sum: {}", sum);
}

fn begin_generating_map_chunks(mut my_tasks: ResMut<MyMapGenTasks>) {
    let task_pool: &'static AsyncComputeTaskPool = AsyncComputeTaskPool::get();
    for chunk_coord in 0..1000 {
        if my_tasks.generating_chunks.contains_key(&chunk_coord) {
            continue;
        }
        let task = task_pool.spawn(async move { generate_map_chunk() });
        my_tasks.generating_chunks.insert(chunk_coord, task);
    }
}```



And there is code replacement that breaks the official example
```rs
// Pretend this is a time-intensive function. :)
                    async fn generate_map_chunk() {
                        let mut sum = 0.0;
                        for j in 1..u32::MAX {
                            sum += (j as f32).sin().cos().tan().sqrt() + j as f32 * 0.0001;
                        }
                        println!("sum: {}", sum);
                    }
                    generate_map_chunk().await;``` 
(i also tried a non async generate_map_chunk function. 

[Arrekin]

I confirm the same happens to me. Bevy's main thread seems to hang until most of the AsyncCompute works is done.
(Windows, 0.16.1)

[hymm]

are you using default features?

[onkoe]

I had to write my own example, but it does seem to be working in some form:

use std::time::Duration;

use bevy::{
    prelude::*,
    tasks::{AsyncComputeTaskPool, Task, TaskPoolBuilder, block_on},
};

type ChunkCoord = u32;

#[derive(Resource, Default)]
struct ChunksResource {
    /// Running generation tasks.
    ///
    /// Make sure to manually drop when they're complete!
    generator_tasks: Vec<Task<Chunk>>,

    /// Finished chunks.
    chunks: Vec<Chunk>,
}

fn main() -> AppExit {
    let mut app: App = App::new();

    app.add_plugins(DefaultPlugins);

    // tell bevy about the res
    app.init_resource::<ChunksResource>();

    // on startup...
    //
    // - create the task pool
    // - start generating chunks
    app.add_systems(Startup, (setup, start_chunk_generation).chain());

    // check if we're done each frame
    app.add_systems(Update, poll_chunk_generation);

    app.run()
}

pub struct Chunk(pub ChunkCoord);

impl Chunk {
    /// "Generates" a chunk.
    ///
    /// Note that this is blocking, which kinda sucks. A just world would
    /// have an `async fn sleep` somewhere in here...
    async fn generate(id: u32) -> Self {
        // wow, it's surprisingly annoying to not have an async sleep here lol
        std::thread::sleep(Duration::from_millis(500));
        Self(id)
    }
}

/// Creates the camera + backing task pool.
fn setup(mut commands: Commands) {
    commands.spawn(Camera3d::default());

    // init the backing static
    _ = AsyncComputeTaskPool::get_or_init(|| {
        TaskPoolBuilder::new()
            .num_threads(2)
            .stack_size(16 * 1024 * 1024)
            .build()
    });
}

/// Spawns all the chunk generation tasks.
///
/// Called at `Startup`.
fn start_chunk_generation(mut r: ResMut<ChunksResource>) {
    let task_pool: &'static AsyncComputeTaskPool = AsyncComputeTaskPool::get();

    // make 1k chunks
    for id in 0_u32..1000_u32 {
        let task: Task<Chunk> = task_pool.spawn(Chunk::generate(id));
        r.generator_tasks.push(task);
    }
}

/// Checks each chunk generation task to see if its done.
///
/// Called once per frame on `Update`.
fn poll_chunk_generation(mut r: ResMut<ChunksResource>) {
    // sooo... for each task that's done, we'll push it to the other list.
    //
    // `Task::is_finished` is vital here! otherwise, you'll block the main
    // thread by using `block_on`.
    let mut completed = Vec::with_capacity(2);
    r.generator_tasks.retain_mut(|task| {
        if task.is_finished() {
            completed.push(block_on(task));
            false // do not keep
        } else {
            true // keep
        }
    });

    // push all those onto the other list
    completed.into_iter().for_each(|chunk| {
        r.chunks.push(chunk);
    });
}

My guess is that you've accidentally called a blocking function on the main thread. I saw that you used AsyncComputeTaskPool::scoped in the Discord help channel. Please make sure you're not using that, as it's one such blocking function! 🥹

[Saratii]

I had to write my own example, but it does seem to be working in some form:

use std::time::Duration;

use bevy::{
prelude::*,
tasks::{AsyncComputeTaskPool, Task, TaskPoolBuilder, block_on},
};

type ChunkCoord = u32;

#[derive(Resource, Default)]
struct ChunksResource {
/// Running generation tasks.
///
/// Make sure to manually drop when they're complete!
generator_tasks: Vec<Task>,

/// Finished chunks.
chunks: Vec<Chunk>,

}

fn main() -> AppExit {
let mut app: App = App::new();

app.add_plugins(DefaultPlugins);

// tell bevy about the res
app.init_resource::<ChunksResource>();

// on startup...
//
// - create the task pool
// - start generating chunks
app.add_systems(Startup, (setup, start_chunk_generation).chain());

// check if we're done each frame
app.add_systems(Update, poll_chunk_generation);

app.run()

}

pub struct Chunk(pub ChunkCoord);

impl Chunk {
/// "Generates" a chunk.
///
/// Note that this is blocking, which kinda sucks. A just world would
/// have an async fn sleep somewhere in here...
async fn generate(id: u32) -> Self {
// wow, it's surprisingly annoying to not have an async sleep here lol
std::thread::sleep(Duration::from_millis(500));
Self(id)
}
}

/// Creates the camera + backing task pool.
fn setup(mut commands: Commands) {
commands.spawn(Camera3d::default());

// init the backing static
_ = AsyncComputeTaskPool::get_or_init(|| {
    TaskPoolBuilder::new()
        .num_threads(2)
        .stack_size(16 * 1024 * 1024)
        .build()
});

}

/// Spawns all the chunk generation tasks.
///
/// Called at Startup.
fn start_chunk_generation(mut r: ResMut) {
let task_pool: &'static AsyncComputeTaskPool = AsyncComputeTaskPool::get();

// make 1k chunks
for id in 0_u32..1000_u32 {
    let task: Task<Chunk> = task_pool.spawn(Chunk::generate(id));
    r.generator_tasks.push(task);
}

}

/// Checks each chunk generation task to see if its done.
///
/// Called once per frame on Update.
fn poll_chunk_generation(mut r: ResMut) {
// sooo... for each task that's done, we'll push it to the other list.
//
// Task::is_finished is vital here! otherwise, you'll block the main
// thread by using block_on.
let mut completed = Vec::with_capacity(2);
r.generator_tasks.retain_mut(|task| {
if task.is_finished() {
completed.push(block_on(task));
false // do not keep
} else {
true // keep
}
});

// push all those onto the other list
completed.into_iter().for_each(|chunk| {
    r.chunks.push(chunk);
});

}
My guess is that you've accidentally called a blocking function on the main thread. I saw that you used AsyncComputeTaskPool::scoped in the Discord help channel. Please make sure you're not using that, as it's one such blocking function! 🥹

hey so i messed around with your code a bit and discovered your code does the same crash on 0.16.1 but works on 0.14.1. I also discovered my crashing code does the same thing, it works on 0.14.1. I also do not know what you are refering to with AsyncComputeTaskPool::scoped its not mentioned in any of my test files or discord.

[onkoe]

Thanks for letting me know!

This could be a Windows regression. I'll do a quick test on Windows 10 sometime tonight :)

Oh, and I'm sorry for the wrong advice! I swear I saw one of those scoped methods somewhere, but looks like I made it up 😅

[onkoe]

oh dang, I was so confident posting that 😭

As it turns out, my example only works on macOS:

• macOS (uhhh like 14 or something): working ✓
• Windows 10 LTSC 21H2: white screen, "not responding" when I click it
• Linux (Fedora Workstaion 41; GNOME 47)
  • X11: "not responding"
  • Wayland (with cargo run --features bevy/wayland): never actually showed a window; it got locked up in my terminal until I spammed SIGQUIT... 2025-08-01T00:05:48.191293Z INFO bevy_winit::system: Creating new window App (0v1) ^C^\^\^\^\fish: Job 1, 'cargo run --features bevy/wayla…' terminated by signal SIGQUIT (Quit request from job control with core dump (^\))

[Saratii]

Any ideas on how this can be fixed? Id like to use task parallelism in my project. If someone has a direction to go in id be happy to try to fix it myself.