Command lifecycle behavior when closing the Tauri window during async execution

Default behavior: the command keeps running

Tauri does not cancel an asynchronous command when its originating window is closed. The frontend promise is dropped, but the Rust future continues executing on the Tokio runtime until it completes, panics, or the process exits. Closing the WebView does not send an abort signal to the command handler.

Confirmed facts versus likely explanation

Item	Status
Command invocation is one-way IPC	Confirmed
Window close drops the frontend listener	Confirmed
Tauri sends a native cancellation signal to Rust	Not provided by default
Backend task is bound to window lifetime	Not by default

The likely explanation is that Tauri treats the command as an independent unit of work. The window lifetime and the command lifetime are not coupled unless the developer explicitly couples them.

Steps to add cooperative cancellation

1. Create a tokio::watch channel in your command setup or state.
2. Pass the Receiver into the async command and poll it with select! or check changed() at safe yield points.
3. Listen for window close or tauri::Event::Destroyed in your setup hook.
4. Send the cancel signal when the window closes.
5. Release files, locks, or database connections in a cleanup block or Drop implementation.

use tauri::{Manager, State};
use tokio::sync::watch;

#[tauri::command]
async fn heavy_work(cancel: watch::Receiver<()>) -> Result<(), String> {
  let mut cancel = cancel;
  for _ in 0..100 {
    tokio::select! {
      _ = cancel.changed() => return Err("cancelled".into()),
      _ = tokio::time::sleep(tokio::time::Duration::from_millis(100)) => {}
    }
    // do work
  }
  Ok(())
}

Verification

Run a command that loops for several seconds while checking the receiver. Invoke it from the frontend, then close the window immediately. With the token, backend logs should stop promptly. Without it, the command should run to completion.

Assumptions and uncertainty

This assumes Tauri v1 or v2 with the default Tokio runtime and async commands. Blocking commands on the thread pool cannot be safely interrupted without redesigning the work to be cooperative. External process kills are not covered by window-close handlers.

Do you need to release external resources such as database connections or file locks when the window closes?