Nodezator Manual

Welcome to the nodezator manual. This guide is meant for Nodezator's users.

You may also want to take a look at the README file of Nodezator's repository, since it showcases a lot of Nodezator's features and capabilities. Or you may want to download example nodes, like the ones used in the video presenting Nodezator.

Table of contents

  1. Defining your first node
    1. A node pack and its purpose
    2. Categories within a node pack
    3. The script folder
    4. Defining the node
    5. Loading and testing your first node
    6. The anatomy of a node pack
    7. Sharing resources among your nodes
    8. Expanded, collapsed and callable mode for nodes
  2. Defining viewer nodes
    1. Returning a visual to be displayed beside your node
    2. Returning a larger visual to be displayed in a Nodezator viewer
    3. Visualizing text
    4. Viewer nodes available by default
    5. Brief note: in-graph only vs full visual
    6. Callable mode and visuals
  3. Nodes with variable parameters and custom outputs
    1. Defining variable parameters
    2. Naming an output
    3. Defining a node with more than one output
  4. More ways to define nodes
    1. Defining a node by importing an existing callable
    2. Incompatible callables and custom signatures
    3. Call formatting for improving definitions and solving issues
  5. Loading your nodes
    1. Obtaining node packs (and their different kinds)
    2. Loading the node pack(s) you obtained
    3. Opening a file from an external source
    4. Other possible problems
  6. Color-coding inputs and outputs
    1. Examples
    2. Types with dedicated colors
    3. Color-coding a named output socket
    4. Color-coding multiple output sockets
  7. Basic way to define widgets
    1. The default holder widget
    2. The check button widget
    3. The string entry widget
    4. The intfloat entry widget
    5. Brief comment on type hints
  8. Full widget definition syntax and more widgets
    1. Presenting the full syntax
    2. The text display widget
    3. the color button widget
    4. Revisiting the string entry widget
    5. Revisiting the intfloat entry widget
  9. Widget definition presets and more widgets
    1. Presenting widget definition presets
    2. The literal entry widget
    3. The literal display widget
    4. The option menu widget
    5. The option tray widget
    6. The sorting button widget
  10. Preview widgets
    1. What are preview widget?
    2. The path preview widget
    3. The text preview widget
    4. The audio preview widget
    5. The image preview widget
    6. The video preview widget
    7. The font preview widget
  11. Other objects
    1. Text blocks
    2. App-defined nodes
      1. Operation nodes
      2. Built-in nodes
      3. Standard library nodes
      4. Snippet nodes
      5. Data nodes
      6. Redirect nodes
      7. General viewer nodes
      8. Pygame-ce nodes
    3. Relationship between data nodes and redirect nodes
    4. Callable mode in app-defined nodes
  12. Distributing your nodes
    1. Distributing as a local node pack
    2. Distributing as an installable node pack
    3. Summary of distribution methods
    4. Combining local and installable distributions
    5. Template to package and publish an installable node pack
  13. Conditional execution (branching) in Nodezator
    1. Analyzing a problem and presenting a solution
    2. Quick note on the efficiency of our solution
    3. Extending the problem and our solution
    4. A dict-based simplification
    5. Different signatures and arguments
    6. A crucial missing piece: subgraphs/group nodes
    7. Other missing pieces
  14. Looping/iterating in Nodezator
    1. Looping with functions
    2. map() and for_item_in_obj_pass()
    3. Other nodes
    4. A crucial missing piece: subgraphs/group nodes
  15. Defining a custom visualization loop for viewer nodes
    1. Defining the node
    2. Dismissing execution time tracking
    3. Callable mode in nodes with custom visualization loops
  16. Defining a more complex viewer node
  17. More advanced viewer node features - Part 1
    1. Separating the main callable into processing and looping
    2. Brief note on "output" key in backdoor dictionary
    3. Callable mode and the backdoor
  18. More advanced viewer node features - Part 2
    1. On instructional vs practical value of previous example
    2. Using the backdoor without a custom visualization loop
    3. Providing only in-graph visual via backdoor
    4. Final comment on backdoors
    5. A final optional change to nodes with custom visualization loops
    6. Small advice on visualization for still images
  19. Different ways of using Nodezator (chapter not written yet)
    1. As a standalone application
    2. Integrated with your regular Python coding
    3. To create parametric functions
    4. To create parametric data
    5. As a no-code or low-code tool