base-node (.bn)

State of the Art — Autumn 2026: node graphs as text

Published · updated

Most node editors save their graphs in a file only the editor can read. Some write the graph as text and read the same text back: then a change shows as a diff in git, a reviewer can read it, a script or an AI model can write a graph, and a graph can be rebuilt from the file without clicking. This page compares 13 tools on that one question: which way does the graph go between the nodes and the text, and in which format.

Legend

The word after the arrow is the format: Text, JSON, XML or Python. A note in brackets says what limits it.

Comparison

Tool Host software Format Arrow Readable git diff Built from the file Licence Note
Blender Blender .blend (binary) Node ⇐ Python no binary file yes a bpy script builds the tree open source GPL The Python API builds node trees; Blender has no text form of a tree it reads back.
NodeToPython Blender add-on Python script or add-on Node ⇒ Python yes of the generated script yes the script builds the tree again open source GPL-3.0 Geometry, shader and compositor trees to a Python function or an add-on zip; v4.3.0 supports Blender 4.2 to 5.3.
Geometry Script Blender add-on Python Node ⇐ Python yes of your script yes open source GPL-3.0 A Python API that builds Geometry Nodes (also shader and compositor groups); nightly 1.0.0 builds for Blender 5.2 to 5.4.
Base Node Blender add-on, Python and Rust parsers .bn (Text) Node ⇔ Text yes canonical formatter yes in Blender, or headless with blender -b open source MIT OR Apache-2.0; Blender binding GPL-3.0-or-later Geometry Nodes, shaders and the compositor as a text language; text to tree and tree to text.
Nuke Nuke (Foundry) .nk (Text, Tcl-based) Node ⇔ Text
Node ⇐ Python
yes yes renders from the command line commercial free Non-commercial edition; its files do not open in the commercial one A script is plain text, one block of knobs per node; Foundry publishes no formal spec of the format.
Houdini Houdini (SideFX) .hip (cpio archive) Node ⇒ Python
Node ⇐ Python
partial after hexpand yes asCode() prints Python that recreates a node commercial free Apprentice for non-commercial use (.hipnc) hou builds networks; hexpand and hcollapse unpack a .hip into editable files and pack it again.
Substance 3D Designer Substance 3D Designer (Adobe) .sbs (XML) Node ⇔ XML
Node ⇐ Python
partial verbose XML with ids yes pysbs writes .sbs without the application commercial Adobe subscription The Automation Toolkit's pysbs parses and writes .sbs; .sbsar archives are read-only to it.
MaterialX Many applications and renderers .mtlx (XML) Node ⇔ XML yes yes open source Apache-2.0 An open standard for material graphs, made to move them between applications and renderers.
ComfyUI ComfyUI workflow .json; API .json Node ⇔ JSON
Node ⇒ JSON (API format)
partial positions and ids in the file yes the API format runs on the server open source GPL-3.0 The saved workflow loads back with its layout; the API format keeps the graph without the layout.
Unity Shader Graph Unity .shadergraph (JSON) Node ⇔ JSON partial generated object ids yes in the Unity editor commercial free Personal plan under $200K revenue The asset is the graph as JSON; Unity's Smart Merge covers scenes and prefabs, not shader graphs.
Godot VisualShader Godot .tres (Text) Node ⇔ Text yes with resource ids and positions yes in the Godot editor open source MIT Saved as a text resource: sub-resources per node, then the connections as a list of ports.
Unreal Blueprints Unreal Engine .uasset (binary); clipboard T3D text Node ⇔ Text (partial: copy and paste) no a diff tool inside the editor partial paste into an open graph commercial free to start, 5% royalty for games over $1M; source on request Copied nodes are Begin Object text blocks that paste back; the asset itself is binary, and Epic documents no grammar for the text.
TouchDesigner TouchDesigner (Derivative) .toe (binary) Node ⇔ Text (partial: toeexpand)
Node ⇐ Python
partial after toeexpand partial toecollapse makes the .toe again commercial free Non-Commercial licence, 1280×1280 cap Derivative says the utilities do it in part and plans a cleaner text mode; the third-party Embody writes networks as YAML (TDXN) and reads them back.

How to read it

The arrow says what you can do with the file. With ⇔, you can edit the text, load it, edit the nodes, save, and get text again. With ⇒, the text is a snapshot: edits to it do not come back. With ⇐, the code is the source and the nodes are its output.

Readable git diff says whether a change to the graph shows as a few changed lines. Partial means the file is text but carries generated ids, positions or long XML, or needs a tool to unpack it first. Built from the file says whether the graph can be made from the file by a script or a command, not by hand.

Licence: open source is an OSI licence; commercial may have a free tier, named in the cell. Each row has its sources at the bottom of the page. A cell the sources do not settle says partial.

By family

Blender

Blender, NodeToPython, Geometry Script, Base Node

Blender saves node trees inside the binary .blend file. Its Python API (bpy) can build any tree, but Blender has no text form of a tree that it reads back. NodeToPython goes one way: it writes a tree out as a Python script that builds it again. Geometry Script goes the other way: you write Python and it builds the tree. In both, the Python is not made again from the nodes after you edit them in the editor. Base Node reads and writes the same text in both directions.

Compositing and procedural

Nuke, Houdini, TouchDesigner

Nuke has stored its scripts as text from the start: a .nk file is a list of Tcl-style commands, one block per node with its knobs. It diffs well and renders from the command line. Houdini's .hip is a cpio archive; hexpand and hcollapse unpack and repack it, and hou.Node.asCode() prints Python that recreates a node. TouchDesigner's .toe is binary; toeexpand and toecollapse turn it into readable files and back.

Materials

Substance 3D Designer, MaterialX

Substance Designer's .sbs is XML, and Adobe's Automation Toolkit (pysbs) reads and writes it without the application. MaterialX is an open standard: its .mtlx XML is meant to carry a material graph between applications and renderers. Both are full round trips; the XML is long, so a diff is readable but noisy.

AI image pipelines

ComfyUI

ComfyUI saves a workflow as JSON and loads it back, with node positions and groups. A second JSON, the API format, drops the layout: it is what a script sends to the server to run the graph. Images made with ComfyUI carry their workflow, so dropping one on the canvas loads the graph again.

Game engines

Unity Shader Graph, Godot VisualShader, Unreal Blueprints

Unity Shader Graph assets are JSON files, and Godot saves a VisualShader as a text resource (.tres): both load back and go into git as text, with generated ids in them. Unreal keeps Blueprints in binary .uasset files and offers a diff tool inside the editor; nodes copied to the clipboard become text that pastes back into a graph, but that text is not the saved asset.

Sources

Checked on 2026-11-20. The data of this page is compare/tools.toml.

  1. Blender
    https://docs.blender.org/api/current/bpy.types.NodeTree.html
    https://formats.kaitai.io/blender_blend
  2. NodeToPython
    https://github.com/BrendanParmer/NodeToPython
  3. Geometry Script
    https://github.com/carson-katri/geometry-script
  4. Base Node
    https://github.com/marcgardent/base-node-language
  5. Nuke
    https://learn.foundry.com/nuke/content/getting_started/managing_scripts/managing_scripts.html
    https://learn.foundry.com/nuke/content/comp_environment/configuring_nuke/command_line_operations.html
    https://learn.foundry.com/nuke/content/getting_started/meet_nuke/about_nc.html
  6. Houdini
    https://www.sidefx.com/docs/houdini/hom/hou/OpNode.html
    https://www.sidefx.com/docs/houdini/ref/utils/hexpand.html
    https://www.sidefx.com/products/houdini-apprentice/
  7. Substance 3D Designer
    https://helpx.adobe.com/substance-3d-sat/pysbs-python-api/api-content/helpers/sbsparser.html
    https://helpx.adobe.com/substance-3d-sat/pysbs-python-api/api-content/helpers/sbswriter.html
    https://helpx.adobe.com/substance-3d/pricing-change.html
  8. MaterialX
    https://github.com/AcademySoftwareFoundation/MaterialX
    https://github.com/AcademySoftwareFoundation/MaterialX/blob/main/documents/Specification/MaterialX.Specification.md
  9. ComfyUI
    https://github.com/comfyanonymous/ComfyUI
    https://docs.comfy.org/development/api-development/workflow-api-format
  10. Unity Shader Graph
    https://github.com/Unity-Technologies/Graphics/blob/master/Packages/com.unity.render-pipelines.core/Samples~/Common/Materials/Shaders/SamplesArrow.shadergraph
    https://docs.unity.com/en-us/engine/current/manual/get-started/project-configuration/version-control/smart-merge
    https://unity.com/products
  11. Godot VisualShader
    https://docs.godotengine.org/en/stable/engine_details/file_formats/tscn.html
    https://docs.godotengine.org/en/stable/classes/class_visualshader.html
    https://godotengine.org/license/
  12. Unreal Blueprints
    https://dev.epicgames.com/documentation/en-us/unreal-engine/ue-diff-tool-in-unreal-engine
    https://forums.unrealengine.com/t/cant-copy-paste-blueprint-nodes-consistently/2715099
    https://www.unrealengine.com/en-US/license
  13. TouchDesigner
    https://derivative.ca/UserGuide/Toeexpand
    https://forum.derivative.ca/t/git-compatible-toe-tox-files/298851
    https://derivative.ca/UserGuide/TouchDesigner_Non-Commercial
    https://github.com/dylanroscover/Embody