About Vibrante-Node
Vibrante-Node is an open-source, node-based visual workflow framework written in Python. It provides a graphical canvas for building modular automation pipelines by connecting nodes that process and route data — with native integrations for Houdini, Maya, Blender, Prism Pipeline, and Deadline.
A Canvas for Python Pipelines
Vibrante-Node presents a QGraphicsScene-based canvas where node widgets, port items, and connecting edges represent computational units and the data flowing between them. Execution is driven by an asyncio-based engine that resolves topological order and drives each node's async execute() coroutine.
The UI stays responsive during pipeline execution through a zero-interval QTimer-stepped event loop on the Qt main thread — no third-party async/Qt bridge required.
Nodes are Python classes paired with JSON definition files. The framework ships 177 bundled nodes. Users can author and distribute custom nodes without modifying the core application; a built-in Node Builder GUI generates Python class stubs from a port table and keeps code and port definitions in bidirectional sync.
Developed by Mahmoud Kamal (KamalTD). First released in 2024.
Technical Stack
Runtime
Python 3.10+
UI Framework
PyQt5
Async Engine
asyncio + QTimer-stepped loop
Schema Validation
Pydantic v2
Houdini Protocol
TCP JSON-RPC (local socket)
Headless Execution
subprocess (mayapy / blender --background)
Node Format
JSON + embedded Python source
Workflow Format
JSON (WorkflowModel)
Code Editor
QScintilla (fallback: QPlainTextEdit)
Prism Compatibility
Prism Pipeline v2.x API
USD Support
Via Prism USD integration nodes
License
AGPLv3 core · MIT SDK · CC BY 4.0 docs
Version Milestones
Vibrante-Node follows semantic versioning. Every release is documented in the release notes.
200+ Houdini AI nodes across 18 intelligence tiers: semantic scene intent (55 environments), asset catalog & vector search, suitability ranking, spatial layout engine, environment shell construction, lighting & lookdev intelligence, reality validation (geometry-wins), 14 MCP tools, 1,700+ unit tests
26 new workflow nodes, runtime extensions layer (Tiers 1–6): MCP server, AI planning, transactions, distributed execution, analytics
HTTP Request node, Authenticode signing, Node Builder correctness fixes, canvas drag-trail fix
Settings dialog, EnvManager singleton, reactive propagation thread-safety fix
Unsaved-changes detection, port type-mismatch warnings, F5 / Shift+F5 shortcuts
GroupNode / subgraphs, mini-map, canvas search, autosave, live wire inspector, execution timing
QScintilla code editor, hot-reload, Houdini bridge hardening, scripting console
Prism Pipeline integration — 62 native nodes covering the full Prism v2 API
Core canvas, asyncio execution engine, Houdini live JSON-RPC bridge
How It Connects to Your Tools
Each integration uses a different communication model suited to the DCC's architecture.
Houdini
Live JSON-RPC bridgeA plugin starts a JSON-RPC server inside a running Houdini session. The HouBridge client communicates over a local TCP socket with TCP_NODELAY and per-call thread locking, exposing ~20 methods for node creation, parameter access, SOP construction, expression authoring, and arbitrary Python execution inside Houdini.
Maya
Headless subprocess (mayapy)Action-list pattern: maya_action_* nodes append operation dictionaries to a list; the maya_headless node executes the full list in a background mayapy subprocess. No live Maya connection is required.
Blender
Headless subprocess (blender --background)Same action-list pattern as Maya. blender_action_* nodes build the list; blender_headless runs it in a Blender background process. Supports Alembic, FBX, glTF, OBJ, USD, and render output.
Prism Pipeline
62 native nodesPrismCore is initialized automatically before graph execution — place a prism_core_init node anywhere in the graph. All prism_* nodes resolve the shared instance from a global cache; no explicit wiring required. Covers projects, entities, assets, shots, products, versions, USD, and media.
Thinkbox Deadline
Render farm submissionBundled deadline_maya_submit, deadline_houdini_submit, deadline_blender_submit, and deadline_job_status nodes. A reference workflow demonstrates integrated Prism + Deadline pipeline automation.
Three-Layer Design
Each layer has a single responsibility and communicates through typed Qt signals.
Execution Engine
src/core/
- NetworkExecutor resolves topological order and drives node coroutines
- Typed Qt signals (node_started, node_finished, node_error) deliver results to the UI without blocking
- NodeRegistry compiles embedded Python source and instantiates node classes on demand
- _source_paths map enables targeted hot-reload per node ID
Event Loop
_EventLoopRunner
- asyncio loop stepped by a zero-interval QTimer on the Qt main thread
- Each tick: call_soon(loop.stop) → run_forever() — one asyncio step per Qt frame
- UI stays responsive; no continuous-loop dependency (no aiohttp)
- HTTP I/O uses urllib.request in loop.run_in_executor(None, sync_fn)
Qt Frontend
src/ui/
- QGraphicsScene / QGraphicsView canvas; all widgets are QGraphicsItem subclasses
- _MainThreadDispatcher (QObject) with QueuedConnection routes async thread output to the Qt main thread
- NodeWidget.boundingRect() covers port connector overhang for correct dirty-region clearing
- MiniMap, CanvasSearchBar, and backdrop/sticky-note items are child widgets of NodeView
Open Core Hybrid Model
Free for individuals, students, education, and open productions. Commercial studio deployment requires a paid license.
| Component | License |
|---|---|
| Core runtime | GNU Affero General Public License v3 (AGPLv3) |
| SDK and public API | MIT License |
| Documentation and examples | Creative Commons Attribution 4.0 (CC BY 4.0) |
| Official plugins and nodes | Commercial license |
| Enterprise integrations | Commercial license |
Get Started
Vibrante-Node is open source. Download, read the docs, or browse the GitHub repository.