Skip to content

Release Notes — v1.4

Release date: March 2026

This release adds plan display, DAG visualization, and rich result rendering — bringing notebook-native display, structured plan inspection, and exportable SVG DAGs to the engine.

Plan Mode Enhancements

explain() — Detailed Plan Breakdown

Plan mode results now include an explain() method that produces a section-by-section breakdown of the execution plan:

result = ctx.run("nightly.loom", mode="plan")
print(result.explain())

The output includes:

  • Dependencies with provenance (inferred vs explicit)
  • Cache targets and their downstream consumers
  • Lookup schedule with materialization points
  • Per-thread detail — sources, targets, write modes, and step counts

For loom-scoped results, the output opens with a loom summary line showing the loom name and weave count.

summary() — Compact Plan View

The summary() method provides a compact execution group view with cache markers (asterisk suffix) and footer counts for threads, cached targets, and lookups:

print(result.summary())

Group 0: dim_product*
Group 1: fact_orders, fact_returns

3 threads, 1 cached, 1 lookup

DAG Visualization

result.dag() — Exportable SVG DAGs

Plan mode results expose a dag() method that returns a DAGDiagram object:

result = ctx.run("nightly.loom", mode="plan")
dag = result.dag()
dag.save("plan.svg")    # export to file
dag                      # renders inline in a notebook

For multi-weave looms, dag() returns a loom-level swimlane diagram with weave containers stacked vertically. Single-weave results get a standard DAG.

Lookup Nodes in DAGs

Lookups are rendered as distinct pill-shaped nodes in the DAG with directed edges showing producer-to-lookup and lookup-to-consumer relationships. Internal lookups (produced by a thread in the weave) show the producer edge; external lookups appear as standalone nodes feeding into their consumers.

ExecutionPlan.dag()

Individual execution plans also expose a dag() method for per-weave access:

plan = result.execution_plan[0]
dag = plan.dag()
dag.save("weave.svg")

Rich Notebook Rendering

All result modes now render automatically as styled HTML when evaluated in a notebook cell:

  • Execute — thread results table with status badges, row counts, write modes, and target paths
  • Validate — check/error report with color-coded status
  • Plan — summary table with embedded DAG diagram
  • Preview — output shape table (columns x rows per thread)

The HTML rendering uses inline styles for compatibility with both light and dark Fabric notebook themes.

Resolved Thread Context

Plan mode results now carry resolved thread metadata (sources, targets, step counts) through to display rendering. This enables the explain() output and the enriched DAG nodes.

Planner: Lookup Producer/Consumer Tracking

The ExecutionPlan model now includes lookup_producers and lookup_consumers mappings that track which threads produce and consume each lookup. These fields power the lookup node rendering in DAGs and the lookup section in explain() output.

Compatibility

No breaking changes. All existing configurations and API usage continue to work without modification.

Component Version
Python 3.11
PySpark 3.5.x
Delta Lake 3.2.x
Microsoft Fabric Runtime 1.3