Rust Async Patterns in Tauri — Keeping the UI Responsive While Rust Does Heavy Work

#rust #tauri #programming

If this is useful, a ❤️ helps others find it.

All tests run on an 8-year-old MacBook Air.

A Tauri app has two threads that matter: the main thread (UI) and whatever tokio spawns. Block the main thread and the UI freezes. Block for too long in a command and the frontend times out.

Here's how I keep things responsive in practice.

The basic rule

Never do blocking work in a #[tauri::command] without async.

// Bad — blocks the thread pool
#[tauri::command]
pub fn compress_pdf(path: String) -> Result<(), String> {
    heavy_compression_work(&path)?;  // takes 3 seconds, blocks
    Ok(())
}

// Good — async, non-blocking
#[tauri::command]
pub async fn compress_pdf(path: String) -> Result<(), String> {
    tokio::task::spawn_blocking(move || {
        heavy_compression_work(&path)
    })
    .await
    .map_err(|e| e.to_string())?
    .map_err(|e| e.to_string())
}

spawn_blocking moves CPU-heavy work to a dedicated thread pool, freeing the async executor for other tasks.

Progress reporting during long operations

For operations that take more than a second, report progress via events:

#[tauri::command]
pub async fn batch_process(
    paths: Vec,
    window: tauri::Window,
) -> Result<(), String> {
    let total = paths.len();

    for (i, path) in paths.iter().enumerate() {
        process_single(&path).await?;

        window.emit("batch-progress", serde_json::json!({
            "current": i + 1,
            "total": total,
            "percent": ((i + 1) as f64 / total as f64 * 100.0) as u32,
        })).ok();
    }

    Ok(())
}

// Frontend shows live progress
await listen('batch-progress', (event) => {
  setProgress(event.payload.percent);
});

await invoke('batch_process', { paths });

Cancellation

Users cancel long operations. Support it with a shared flag:

use std::sync::{Arc, atomic::{AtomicBool, Ordering}};

pub struct CancelToken(Arc);

impl CancelToken {
    pub fn new() -> Self { Self(Arc::new(AtomicBool::new(false))) }
    pub fn cancel(&self) { self.0.store(true, Ordering::Relaxed); }
    pub fn is_cancelled(&self) -> bool { self.0.load(Ordering::Relaxed) }
}

#[tauri::command]
pub async fn batch_process(
    paths: Vec,
    cancel_token: tauri::State<'_, CancelToken>,
    window: tauri::Window,
) -> Result<(), String> {
    for (i, path) in paths.iter().enumerate() {
        if cancel_token.is_cancelled() {
            return Err("cancelled".to_string());
        }
        process_single(&path).await?;
        window.emit("batch-progress", i + 1).ok();
    }
    Ok(())
}

// Cancel button
await invoke('cancel_batch');

Parallel processing with Semaphore

Process multiple files concurrently, but not all at once:

use tokio::sync::Semaphore;
use std::sync::Arc;

pub async fn process_parallel(paths: Vec) -> Vec> {
    let semaphore = Arc::new(Semaphore::new(4)); // max 4 concurrent
    let mut handles = Vec::new();

    for path in paths {
        let sem = semaphore.clone();
        let handle = tokio::spawn(async move {
            let _permit = sem.acquire().await.unwrap();
            process_single(&path).await.map_err(|e| e.to_string())
        });
        handles.push(handle);
    }

    futures::future::join_all(handles)
        .await
        .into_iter()
        .map(|r| r.unwrap_or_else(|e| Err(e.to_string())))
        .collect()
}