xtranodly.ai

A Rust-native node graph framework with FPGA-style deterministic execution — wgpu-rendered, tick-synchronized, with arbitrarily deep nested graphs and time travel debugging.

A Rust-native node graph framework — context nodes nest arbitrarily deep, open as floating panels or detached windows, and bridge nodes wire data across contexts without direct edges.

Main Components

Graph

The container — holds nodes and edges. The root graph is the workspace; each context node contains its own graph. Graphs nest without limit.

Node

Processing units with typed input/output ports. Each type defines how data flows through the graph.

Compute— pure stateless transforms, evaluated every tick

Context— contains a nested graph, opens as floating panel or detached window. Nests arbitrarily deep.

Boundary— defines a context's input/output interface

Bridge / Relay— cross-context wiring; split across sender and receiver

Fanout— one-to-many signal distribution

Edge

Connections between ports. Direct edges propagate immediately within a tick. Registered edges introduce a 1-tick delay — the only source of temporal sequencing.

Tick Execution

Borrowed from FPGA design — a global tick clock drives the entire graph. Each tick, the engine topologically sorts every node and evaluates them in order. Direct edges propagate instantly within the tick (combinational). Registered edges latch their value and deliver it next tick (sequential) — the only way state persists. No race conditions, fully deterministic — execution order is defined by the graph topology, not by timing or chance. Suited for signal processing, visual programming, simulation, or any domain where reproducible dataflow matters.

Why xtranodly

Most node graph tools are either visual scripting wrappers that compile down to imperative code, or pipeline runners that shuffle data between stages. Neither gives you a real execution model — contexts can't depend on each other's live output, nesting is shallow or nonexistent, and debugging means print statements.

◈

Contexts as first-class sub-systems. Each context is its own graph with its own boundary — and bridge nodes let them exchange data across any depth, without coupling their internals.

◈

Dependent outputs, guaranteed order. When context A feeds context B, the tick engine resolves the full dependency chain every cycle. No callbacks, no async races — just topology.

◈

Time travel built in. Every tick is a snapshot. Rewind, branch, compare — debug by replaying state, not by guessing.

Built in Rust, rendered with wgpu. A graph framework that runs like hardware.