For some of you the concept node as it is used in Paragraphic might be unfamiliar. Or, if you’re familiar with node graphs and node-based design tools Paragraphic might not be immediately recognizable as one. This post will attempt to shed some light on this and explain how the node system works in Paragraphic. If you’re already familiar with node based systems you might want to skip to the paragraphic section at the end.
Node graphs and node-based design tools
A node graph in this contexts refers to a sequence of connected steps or building blocks called nodes. Each node uses some input parameters to produce a combined output result. These input and output parameters can then be connected to other nodes to form a sequence or graph where the nodes are the knots for these connected paths.
This kind of system is often used in parametric and procedural design tools as it allows a great deal of flexibility, where the designer can freely combine these individual nodes in many different ways to produce different results. For example creating composited visual effects, 3d geometry or textures and materials.
Below you can see some examples of such node based interfaces where you edit a node graph directly by adding nodes and making connections between them in Blender, Grasshopper and Godot.
In these interfaces you have an end point node that represents what will be output as the result. Connected to this output node is then a sequence of other nodes before it that generates this output.
For example a texture generator could take the color from an image in an image node, or set it based on some calculation in some other node. Since these connected nodes can then take input from additional nodes this allows a very flexible way to create complex step by step procedures to generate output. This system also has the benefit of being to adjust any step in the process and see the end result without needing to undo/redo any steps.
Patternodes, node based 2d vector graphics
The flexibility of these node graph interfaces was the inspiration for Patternodes, our macOS app for creating 2d vector graphics using a node based interface. Where instead of adding and processing images for textures or visual effects it would generate, repeat and transform vector shapes and image elements to create patterns, vector gradients and generative art.
The node graph interface here is similar to the examples above: We have an end output Artboard node, with input connections for each layer. And then we connect a sequence of nodes that describes what should be added to each such layer.
As a basic example below we add a rectangle with the first Shape node, repeat this in a 5×5 grid in the Grid node, rotate every other element in this grid in the third Transform node, and finally connect it to an output layer in the Artboard node.
With this sequence we could then easily change the size or shape of the rectangle, and the repetition and rotation would then be automatically performed on this new shape. Or we could change the number of repetitions in the grid, and every other square would still be rotated 45 degrees.
In addition to just connecting the sequence of steps that generates the graphics content, you can also connect other types of parameters. For example below we’ve now added a simple Value node and connected this to the Grid node horizontal (X) spacing, and then connected that to the Transform node Angle parameter. If we now change this value, both the spacing in the grid and angle will update.
If we wanted to expand our design with a second layer with blue squares we could just add a new sequence of nodes (Shape 2 and Grid 2) and connect that to another layer input on the Artboard node. All the nodes for all layers are placed in a common global node graph. For example like this:
Simplified to a schematic illustration a node graph in Patternodes with the two layers could looks something like this, showing the generation sequence and connected values:
Paragraphic, the hidden node graph
Now, returning to Paragraphic, with the node graph structure of Patternodes in mind we can see that it actually employs a very similar node based system. Reproducing the first example above would looks something like this in Paragraphic:
On the surface this might look different, with the big node graph replaced with a main view where you can select and move layers around, and a selection details panel to the right.
However, in the Selection panel to the right a node sequence for this layer is displayed. Only it’s represented as a vertical stack of panels instead of connected panels from left to right. The steps are the same: we add a rectangle (and set the fill color), repeat this rectangle in a grid and rotate every other rectangle. And just like in Patternodes we can still edit any step in this process and the result will update automatically.
Layer node graphs
The main difference is that Paragraphic introduces layers to the system, and each layer has a node graph of its own. Instead of a global node graph view where you can see and edit nodes for all layers at once you instead see and edit nodes for one layer at a time. This change gets rid of the visible end point output node, as the end result of all visible layers is just added to the output. It also gets rid of the need to connect nodes in the sequence of each layer, as the nodes are all connected in order as you add them to a layer. Finally, to allow moving layers around in a more natural way each layer has a layer transform that is applied after the node sequence to allows you to move, scale and rotate the layer freely without needing to add additional nodes for this.
However, as all nodes are now part of a specific layer node sequence, you can no longer add separate “free” nodes like the Value node in the Patternodes example above. To get around this limitation, Paragraphic instead introduces a separate set of Document Parameters. These are custom parameters you can add in each document to use as a sort of control panel, and connect to any layer node parameters.
Using the same type of schematic illustration, the example from above could look something like this in Paragraphic:
And in the Paragraphic interface it would look something like this:
To add or remove connections you can click the input/output sockets on the left/right of each parameter, or click and drag out from them. In order to not obstruct the interface connections are normally only show as little ends on the sockets, but if you hover over them you can see where they go. Above you can see hovering the Transform node Angle input socket shows the parameter is connected to the document parameter Value output socket.
In addition to simple value connections like this, there are also input nodes you can add to transform inputs in more advanced ways and establish more complex relationships. You can read more about that here: Input nodes and Using expressions for value inputs.
Layer hierarchy and groups
The addition of the layer hierarchy in Paragraphic doesn’t just make working with each individual layer more focused and natural, it also introduces layer groups.
Grouping layers is of course familiar to anyone using design software. This works the same in Paragraphic, allowing you to move and transform a set of layers together. However, in Paragraphic group layers also have their own node sequence, so just like when you start with a simple shape you can repeat or transform the output of a group of layers using nodes.
This means you can construct more complex pattern elements where you can still edit the individual components by grouping layer.
It also means you can combine manually placing layers in groups and then applying nodes to the group, for example to randomize or apply a gradient transform based on their position.
Conclusion
I hope this introduction has helped you to understand some of the thinking behind the node system Paragraphic employs, and how you can use it to make designs.
For more detailed discussions on various features you can take a look at the Documentation-tagged posts in the blog or check out the feature presentation videos in the Youtube Paragraphic playlist.