Crate ascii_dag 

ascii-dag

Modular ASCII DAG (Directed Acyclic Graph) renderer for error chains, build systems, and dependency visualization.

Features

• Tiny: ~77KB WASM (minimal), ~41KB without generic features
• Fast: Cached adjacency lists, O(1) lookups, zero-copy rendering
• no_std: Works in embedded/WASM environments
• Modular: Each component can be used independently
• Safe: Cycle detection built-in

Performance

• Cached Adjacency Lists: O(1) child/parent lookups (not O(E))
• Zero Allocations: Direct buffer writes with write_node()
• HashMap Indexing: O(1) ID→index instead of O(N) scans

Feature Flags

• std (default): Standard library support
• generic (default): Generic algorithms (cycle detection, topological sort, impact analysis, metrics)
• warnings: Debug warnings for auto-created nodes

To minimize bundle size, disable generic:

ascii-dag = { version = "0.1", default-features = false, features = ["std"] }

Quick Start

use ascii_dag::graph::{DAG, RenderMode};

// Batch construction (fast!)
let dag = DAG::from_edges(
    &[(1, "Error1"), (2, "Error2"), (3, "Error3")],
    &[(1, 2), (2, 3)]
);

println!("{}", dag.render());

Modular Design

The library is organized into separate, independently-usable modules:

graph - Core DAG Structure

use ascii_dag::graph::DAG;

let mut dag = DAG::new();
dag.add_node(1, "A");
dag.add_node(2, "B");
dag.add_edge(1, 2, None);

cycles - Cycle Detection

use ascii_dag::graph::DAG;

let mut dag = DAG::new();
dag.add_edge(1, 2, None);
dag.add_edge(2, 1, None);
assert!(dag.has_cycle());

cycles::generic - Generic Cycle Detection

Works with any data structure via higher-order functions:

use ascii_dag::cycles::generic::detect_cycle_fn;

let get_deps = |id: &usize| match id {
    1 => vec![2],
    2 => vec![3],
    _ => vec![],
};

let cycle = detect_cycle_fn(&[1, 2, 3], get_deps);
assert!(cycle.is_none());

layout::generic - Generic Topological Sorting

Sort any dependency graph into execution order:

use ascii_dag::layout::generic::topological_sort_fn;

let get_deps = |task: &&str| match *task {
    "deploy" => vec!["build"],
    "build" => vec!["compile"],
    "compile" => vec![],
    _ => vec![],
};

let sorted = topological_sort_fn(&["deploy", "compile", "build"], get_deps).unwrap();
// Result: ["compile", "build", "deploy"]
assert_eq!(sorted[0], "compile");

layout - Graph Layout Algorithms

Sugiyama hierarchical layout for positioning nodes.

render - ASCII Rendering

Vertical, horizontal, and cycle visualization modes.

Re-exports

pub use csr::CsrGraph;

pub use ir::EdgePath;

pub use ir::LayoutEdge;

pub use ir::LayoutIR;

pub use ir::LayoutIRBuilder;

pub use ir::LayoutNode;

pub use graph::DAG;

pub use graph::RenderMode;

Modules

arena

Bump/arena allocator for no_std and embedded environments.

csr

Compressed Sparse Row (CSR) graph format for arena/embedded mode.

cycles

Cycle detection algorithms for directed graphs.

graph

Core DAG (Directed Acyclic Graph) data structure.

ir

Intermediate Representation for graph layout.

layout

Graph layout algorithms for hierarchical rendering.

render

ASCII rendering for DAG visualization.