🚀 Announcing taskflow-rs: A Task Graph Runtime for Rust

#rust #showdev #dag

🚀 Announcing taskflow-rs: A Task Graph Runtime for Rust

Today I’m excited to share the first public release of taskflow-rs, a Rust library for building and executing task dependency graphs.

GitHub: https://github.com/ZigRazor/taskflow-rs

The Problem

Many parallel workloads can be expressed as a Directed Acyclic Graph (DAG) of tasks.

Examples include:

• data processing pipelines
• build systems
• simulation workflows
• parallel algorithms

However, orchestrating these dependencies efficiently often requires writing complex scheduling logic or relying on abstractions that don’t model task dependencies explicitly.

The Idea

taskflow-rs allows you to define tasks and dependencies directly as a graph, and then execute them using a parallel scheduler.

Instead of thinking in terms of threads or async calls, you describe what depends on what.

The runtime handles the rest.

Example

use taskflow::*;

fn main() {
    let mut tf = Taskflow::new();

    let a = tf.add_task(|| println!("Task A"));
    let b = tf.add_task(|| println!("Task B"));
    let c = tf.add_task(|| println!("Task C"));

    tf.add_dependency(a, c);
    tf.add_dependency(b, c);

    tf.execute();
}

This produces the following execution graph:

A ─┐
   ├──► C
B ─┘

Tasks A and B run in parallel, and C runs when both complete.

Features

Current features include:

• Task DAG execution
• Parallel task scheduling
• Lightweight task creation
• Deterministic dependency ordering

Future plans include:

• async task nodes
• distributed task graphs
• advanced scheduling strategies

Why I Built This

I’ve always liked the task graph execution model because it expresses parallelism naturally and explicitly.

While Rust has excellent tools like Rayon and Tokio, they solve different problems.

taskflow-rs explores a DAG-driven execution model where the focus is on dependency graphs rather than threads or futures.

Status

The project is currently in an early stage (v0.x) and the API may evolve, but the goal is to grow it into a high-performance task graph runtime for Rust.

Feedback, ideas, and contributions are very welcome.