Overview
In this article, we take a look at one emerging pattern that provides a straightforward and compact way to configure services. Generally speaking, when a function expects many inputs, the most straightforward way is to directly expose those on the node. However, this quickly makes the node gigantic in size.
(Node with many parameters)
(Example in ComfyUI)
When a node has too many parameters, it becomes bulky.
(Example in Blender)
This quickly becomes infeasible when even more complex parameters are required for the functioning of nodes—for instance, if it's an online service with many potential configuration settings. A typical approach is thus to utilize a GUI element, which we shall call a "node properties panel." Below is a sophisticated example from Houdini. PowerBI and Zapier do similar things.
(Houdini node configuration panel)
This method falls short for two reasons:
- It's not explicit, and configuration parameters are not visible on the graph. Which makes it not possible to see dataflow nor to programmatically drive those values.
- It requires a dedicated GUI and can only be configured within that GUI.
The Design Approach
Usually, some kind of scripting or expression language is used to address the first problem. For instance, in Houdini, users often write VEX snippets or Python expressions inside parameter fields to control behavior dynamically. In Zapier, configuration can include custom JavaScript code or formulas in input fields to manipulate data between steps. These workarounds bring back some level of flexibility, but at the cost of breaking the visual flow and requiring users to write code inside otherwise "no-code" or "low-code" environments.
One design goal of Divooka is to be frontend-agnostic. The currently released frontend is officially known as "Neo", which is a WPF-based technology. However, Divooka graphs are designed to be generic enough to be visualized on different frontends—ideally in a way that's very easy to implement. That’s why we prefer to expose everything explicitly, so no specialized logic is required on the frontend (e.g., to be aware of the nodes they are dealing with).
Configuration in Divooka
Visually, we have a ConfigureX node and some nodes that take a configuration parameter as input. This dominant pattern is used in many places, including plotting configuration, OpenAI service configuration, and some other APIs like the image composition API.
(Example of plot configuration)
(Example of OpenAI service configuration)
(Example of image composition API)
We could provide a few different overrides for creating a configuration—so depending on how many details are needed, one can use a more lightweight or more heavy-duty configure node.
(PostgreSQL with two different configurations)
That concludes our introduction to the current setup, but the versatility of Divooka doesn't end here. Indeed, we could also introduce some kind of GUI panels for advanced configurations, and in fact, that’s desirable for certain things - at the price of losing the capability to programmatically drive the parameter values. This will be an expected standard feature in the full release of Divooka.
References
This article reference the following software:
- Houdini – A professional 3D animation and visual effects software used in film, TV, and games, known for its node-based procedural workflow.
- Blender – A free and open-source 3D creation suite that supports modeling, animation, simulation, rendering, and more.
- ComfyUI – A graphical node-based interface for building image generation workflows using AI models like Stable Diffusion.
- PowerBI – A business analytics tool by Microsoft that lets users visualize data and share insights across an organization.
- PostgreSQL – A powerful, open-source relational database system with a strong emphasis on extensibility and standards compliance.
- Divooka – A general purpose programming language for building procedural programs and data flows through node graphs.
- Zapier – An online automation platform that connects different apps and services to automate workflows without coding.