taskgraph-rs 0.1.2

NASA-grade, zero-dependency DAG task orchestrator for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

# taskgraph-rs ⚓

**A NASA-grade, zero-dependency, no_std DAG task orchestrator library for Rust.**

[![unsafe forbidden](https://img.shields.io/badge/unsafe-forbidden-success.svg)](https://github.com/rust-secure-code/safety-dance/)
[![License](https://img.shields.io/badge/License-MIT%20%2B%20Commercial-blue.svg)](#-license)

## 🚀 Vision

`taskgraph-rs` is a lightweight, high-performance engine designed 
to execute interdependent tasks (DAG - Directed Acyclic Graph) in 
parallel. Built for environments where reliability, safety, and 
performance are non-negotiable.

**Core Pillars:**
- **Zero-Unsafe** — `#![forbid(unsafe_code)]` strictly enforced
- **Zero-Deps** — No dependencies by default, `no_std` compatible
- **Dual Runtime** — Sync (`no_std`/IoT) and Async (Tokio) support
- **14.8M tasks/sec** — Lock-free atomic orchestration, benchmarked

## 🎯 Perfect for

✅ IoT & Embedded systems (ESP32, ARM — runs in < 1KB RAM)  
✅ Game engines in Rust (parallel asset loading pipelines)  
✅ Medical / Defense (offline, air-gapped, zero cloud)  
✅ CLI tools with complex step dependencies  
✅ Any Rust app needing a parallel task pipeline  

❌ Not a replacement for Apache Airflow (no UI, no cron)  
❌ Not for distributed multi-server workflows  

## 📦 Installation
```toml
[dependencies]
taskgraph-rs = "0.1"

# Async support (Tokio)
# taskgraph-rs = { version = "0.1", features = ["async"] }
```

## 🛠️ Usage

### Synchronous (no_std / IoT / CLI)
```rust
use taskgraph::{Task, TaskGraph, StaticStore};

fn main() -> taskgraph::Result<()> {
    let storage = StaticStore::<10>::new()?;
    let mut graph = TaskGraph::new(storage);

    let id_a = graph.task(Task::new_static("TaskA", || Ok(())), &[])?;
    let _id_b = graph.task(Task::new_static("TaskB", || Ok(())), &[id_a])?;

    graph.run_sync()?;
    Ok(())
}
```

### Asynchronous (Tokio)
```rust
#[tokio::main]
async fn main() -> taskgraph::Result<()> {
    let mut graph = TaskGraph::new(taskgraph::DynamicStore::new());

    let t = Task::new_async("Fetch", || Box::pin(async { Ok(()) }))
        .with_timeout(Duration::from_secs(30))
        .with_retries(3);

    graph.task(t, &[])?;
    graph.run_async().await?;
    Ok(())
}
```

## 🛡️ Security & Reliability

- **No Panics** — Zero `unwrap()` in the core library
- **Cycle Detection** — Kahn's Algorithm, deterministic
- **Panic Isolation** — One task panics, others continue
- **Timeout** — Async tasks cancelled cleanly on timeout

## ⚖️ License

Free for non-commercial use — see [LICENSE](LICENSE)

| Usage | Price | Link |
|---|---|---|
| Personal / Open Source | Free (MIT) | — |
| Startup (revenue < $1M/year) | €99 one-time | [Buy Startup License →](https://buy.polar.sh/polar_cl_MMxcQlmU0iWqiyS76y6L5jolRDgelacR6n4Xg0UfutX) |
| Business (revenue > $1M/year) | €499 one-time | [Buy Business License →](https://buy.polar.sh/polar_cl_rySzRQLoExTlLjtt2YnQAcPjpqg3XsjQoukqm1dU4Ra) |

---
*Built by [Ferrolab](https://github.com/ferrolab-rs) · ferrolab@tutamail.com*