Taskmill

A persistent, priority-aware task scheduler for Rust with IO-aware concurrency.

Taskmill is a task queue for desktop apps and background services where work needs to survive crashes, respect system resources, and stay visible to users. It persists tasks to SQLite, schedules by priority with preemption, and automatically defers work when disk or network throughput is saturated.

Read more about the motivation and use cases.

Quick example

use tokio_util::sync::CancellationToken;
use serde::{Serialize, Deserialize};
use taskmill::{
    Domain, DomainKey, DomainHandle, Scheduler, TypedExecutor,
    TypedTask, TaskTypeConfig, TaskContext, TaskError, IoBudget,
};

// 1. Define a domain and a typed task.
struct Media;
impl DomainKey for Media { const NAME: &'static str = "media"; }

#[derive(Serialize, Deserialize)]
struct Thumbnail { path: String, size: u32 }

impl TypedTask for Thumbnail {
    type Domain = Media;
    const TASK_TYPE: &'static str = "thumbnail";

    fn config() -> TaskTypeConfig {
        TaskTypeConfig::new().expected_io(IoBudget::disk(4096, 1024))
    }

    fn key(&self) -> Option<String> { Some(self.path.clone()) }
}

// 2. Implement a typed executor — no manual deserialization.
struct ThumbnailGenerator;

impl TypedExecutor<Thumbnail> for ThumbnailGenerator {
    async fn execute(&self, thumb: Thumbnail, ctx: &TaskContext) -> Result<(), TaskError> {
        ctx.progress().report(0.5, Some("resizing".into()));
        ctx.record_read_bytes(4096);
        ctx.record_write_bytes(1024);
        Ok(())
    }
}

#[tokio::main]
async fn main() {
    // 3. Build the scheduler with a typed domain.
    let scheduler = Scheduler::builder()
        .store_path("tasks.db")
        .domain(Domain::<Media>::new()
            .task::<Thumbnail>(ThumbnailGenerator))
        .max_concurrency(8)
        .with_resource_monitoring()
        .build()
        .await
        .unwrap();

    // 4. Submit via a typed domain handle — compile-time domain enforcement.
    let media: DomainHandle<Media> = scheduler.domain::<Media>();
    media.submit(Thumbnail { path: "/photos/img.jpg".into(), size: 256 }).await.unwrap();

    let token = CancellationToken::new();
    scheduler.run(token).await;
}

Key capabilities

• Survive crashes — tasks are persisted to SQLite and automatically recovered on restart
• Stay responsive — IO-aware scheduling defers work when disk or network throughput is saturated
• Prioritize what matters — 256-level priority queue with preemption lets urgent work interrupt background tasks
• Show progress — executor-reported and throughput-extrapolated progress for real-time UI updates
• Expire stale work — configurable TTL (per-task, per-type, or global) automatically expires tasks that haven't started in time
• Schedule work — delay tasks with run_after, create recurring schedules with automatic re-enqueueing and pile-up prevention
• Avoid duplicate work — key-based deduplication prevents the same task from being queued twice
• React to system load — composable backpressure from any signal (disk, network, memory, battery, API limits)
• Control concurrency — per-group limits (e.g., per S3 bucket), global limits, runtime-adjustable
• Build for Tauri — Clone, Serialize on all types; events bridge directly to frontends

Where to start

Documentation

License

MIT