NodeHub
Build logic visually. Connect blocks. Watch it run.
🚧 Status: In Active Development
First target application: LLM Agent Flows — design, visualise, and orchestrate AI agent pipelines as interactive node graphs.
What Is NodeHub?
NodeHub is a visual programming environment — instead of writing lines of code, you place blocks on a canvas, wire them together, and build working programs by drawing connections.
If you've ever used Virtools, Unreal Blueprints, or Scratch, you already know the idea. NodeHub takes that concept and makes it fast, lightweight, and focused on one thing: separating what happens from what data flows.
The Two Types of Connections
This is the key idea behind NodeHub — and what makes it different from simpler node editors:
⬛ Flow (the grey wires)
Flow connections control when things happen. They're the "do this, then do that" part of your program.
Start → Add → Log
This means: first run Add, then run Log.
🟠 Data (the coloured wires)
Data connections control what values get passed around. Numbers, text, colours — any information that blocks need to do their job.
Parameter "28" → Add (input A)
This means: feed the number 28 into the Add block's first input.
Flow decides the order. Data decides the values. They live on the same canvas but follow different rules — just like how a recipe has both steps (flow) and ingredients (data).
Building Blocks
NodeHub has four construct types, each with a distinct role:
Blocks
The main workhorses. Each block does something — call an API, transform data, log a result. Blocks have:
- Flow pins on the left and right edges (square) — connect these to set execution order
- Data pins on the top and bottom (round, coloured) — connect these to pass values in and out
Parameters
Typed value holders. A Parameter stores a single value — an integer, a float, a string, an object reference — and exposes it to the graph. Parameters have no flow pins; they exist purely in the data layer. Think of them as named variables you can wire into any block that accepts that type.
Parameter Operations
Pure data transforms — no flow needed. A Parameter Operation (shown as "ParamOp" on the canvas) takes input values, applies an operation (addition, multiplication, string concatenation, …), and produces an output — all without participating in the execution flow. They're registered from a global operation registry, so new operations can be added without modifying the engine.
Why separate from Blocks? Blocks need flow connections to run — someone has to say "execute this now." Parameter Operations run on demand whenever a downstream block reads their output. This keeps pure data transformations out of the flow graph, reducing clutter and making data pipelines easier to follow.
Groups
Select a set of blocks and collapse them into a group — a single block on the outside, a full sub-graph on the inside. Double-click to open the group and see what's inside. Groups can be nested as deep as you need.
Why NodeHub?
| See your logic | The graph is the program — no hidden state, no hunting through files |
| Flow + Data separation | Understand execution order and data flow independently |
| Nestable groups | Manage complexity by collapsing sub-graphs into reusable blocks |
| Real-time | See results immediately as you build — no compile-and-wait cycle |
| Lightweight | Native desktop app, runs at 60 fps, no browser or runtime overhead |
| Multi-document | Work on multiple graphs side by side, each saved as its own file |
Why Native, Not Web-Based?
Most visual node editors today run inside a browser — React Flow, LiteGraph, Rete.js. They work, but they come with real trade-offs:
- Startup time — Web-based editors need a browser, a bundler, and a runtime. NodeHub loads in under one second.
- Speed at scale — Hundreds of nodes with live connections push browser rendering to its limits. NodeHub runs at native GPU speed (ImGui / DirectX / OpenGL), keeping 60 fps even on large graphs.
- Integration — Browser tools are sandboxed. Calling local APIs, running shell commands, or reading files requires workarounds. NodeHub runs natively on your machine — it can talk to local services, invoke CLIs, and read the filesystem directly.
- Headless execution — NodeHub graphs can run without the GUI. Load a graph, execute it from the command line, pipe results to stdout. This makes it practical for automation, CI pipelines, and server-side agent orchestration — not just a design canvas.
For LLM agent flows specifically, this matters: you design the flow visually, then deploy the same graph headless as a production pipeline — no rewrite needed.
Who Is It For?
- Technical artists who want to prototype behaviour without writing C++
- Designers who need to express game logic, automation flows, or interactive sequences visually
- Engineers who prefer to see the big picture before diving into code
- Anyone who has used Virtools, Blueprints, or similar tools and wants that workflow in a standalone, open environment
Heritage
NodeHub's design traces back to Virtools Dev by Dassault Systèmes — one of the pioneering visual programming environments for real-time 3D and interactive media. The same flow-and-data paradigm later appeared in Unreal Engine Blueprints, Unity Visual Scripting, and Houdini networks.
NodeHub carries that philosophy forward as a modern, standalone tool — fast, focused, and built from scratch in C++.