dagron

High-performance DAG execution engine for Python, powered by Rust.

Up to 12× faster than NetworkX on 10k-node DAG validation, with sub-microsecond reachability queries after index build. Build pipelines, schedulers, build systems — anything that runs as a graph.

import dagrondag = (    dagron.DAG.builder()    .add_node("extract")    .add_node("transform")    .add_node("load")    .add_edge("extract", "transform")    .add_edge("transform", "load")    .build())result = dagron.DAGExecutor(dag).execute({    "extract":   lambda: fetch_data(),    "transform": lambda: clean(result),    "load":      lambda: write_to_db(result),})

Everything you need to ship a DAG

Build it, run it, cache it, replay it. dagron covers the lifecycle from prototype to production.

Typed Node Handles

NodeRef carries an Arc<str>+epoch handle returned by add_node — every API accepts str | NodeRef, stale handles error fast.

@dagron.flow

Tawazi-style: write a Python function, let the call structure become the DAG. Pythonic, no string IDs.

Reactive Engine

Signal/Computed/Watcher with auto-tracked deps. ~10 µs to recompute one branch out of 10k after upstream mutation.

Content-Addressed Cache

Nix-flake-style cross-process cache backed by the filesystem. Two CI workers share intermediates without coordination.

Time-Travel Replay

Append-only JSONL traces + payload-deduped CAS. replay(at=t) reconstructs any past run state.

Effect-Typed Tasks

PURE / READ / WRITE / NETWORK / NONDETERMINISTIC tags drive cache opt-in, replay safety, and executor isolation.

DAG Builder

Fluent builder, from_records, and Pipeline / @task decorator for defining DAGs.

Parallel Execution

Thread-pool and async executors with topological scheduling and cost-aware planning.

Incremental Execution

Early-cutoff recomputation — only re-execute what changed.

Checkpointing

Save progress to disk and resume after failures.

Conditional & Dynamic DAGs

Predicate-gated edges, runtime expansion based on node results.

Resource & Approval Gates

GPU/CPU/memory-aware scheduling; human-in-the-loop pauses until approved.

Distributed Execution

Pluggable backends: threads, multiprocessing, Ray, Celery.

Tracing & Profiling

Chrome-compatible execution traces and critical-path analysis.

Graph Analysis

Explain, what-if, lineage tracking, linting, and a query DSL.

Contracts & DataFrames

Type contracts across edges, validated at build time. Schema validation for pandas/polars pipelines.

Templates & Versioning

Parameterised templates with placeholder expansion; append-only mutation log with diffing and forking.

Plugins & Hooks

Event-driven plugin system with hook registry and auto-discovery.

Visualization

ASCII, SVG, Mermaid, and a live web dashboard (Axum + SSE).