2025-09-22 Geometry Nodes Workshop Notes

This workshop took place at the Blender HQ in Amsterdam. This post contains just the raw meeting notes we took during the workshop. See the blog post for a better summary of what was discussed.

Present

  • Jacques Lucke
  • Hans Goudey
  • Brady Johnston
  • Manuel Casasola Merkle (3 days)
  • Lukas Tönne (4 days)
  • Simon Thommes (3 days)
  • Dalai Felinto (2 days)
  • Pablo Vasquez (0.5 days)
  • Habib Gahbiche (1 day)
  • Falk David (1 day)

Planning

Monday Tuesday Wednesday Thursday Friday
Physics Bundle Physics Solver Volume Nodes
5.0 Assets Bundle on Geometry String/List Attributes
Node Tools

Topics

  1. Declarative Nodes Design
  2. Physics Solver
  3. Viewer Node Update
  4. Closure & Bundle Nodes
  5. Asset packing
  6. Compositor: reusable node trees
  7. Compositor: layered compositing
  8. Evaluate at position node
  9. Index switch menu switch combination
  10. Output visibility inferencing
  11. Add buttons in items nodes
  12. Non-geometry evaluation outputs
  13. UV Tangent Node
  14. Node Tools Multi-Object Processing
  15. Modal Node Tools
  16. Lists
  17. Swap Node Operator
  18. 5.0 Essentials Assets
  19. Node Group Drawing
  20. Node Editor Compatibility
  21. Default Inputs
  22. String Attributes
  23. Domain Interpolation Options
  24. List Attributes
  25. Volume Nodes

Random

  • Spreadsheet Editor shortcut.
  • Join bundle node
  • Pre-fill and pre-select the current label with the F2 operator
  • Add “Requires Label” option for ID template and menu sockets
    • On by default for new sockets
    • Version existing menu sockets to enable the option
    • If the enum is a dropdown (not expanded), always draw the label in the modifier (not in the node)
    • When possible, draw the label as placeholder text
    • Always draw the label for data-blocks in modifier

Viewer

  • Displaying data inside of the node seems inconsistent with Blender’s node design
    • Might be a worthwhile trade-off
    • Check with Pablo for design sign-off
    • Solution is to use the same style as the socket inspection tooltip text (monospace and a bit grayed out).

Swap Node Operator

  • Does not work with assets.
  • Crashes with node links.

UV Tangent

  • Rename Mikktspace to MikkTSpace
  • Use Exact and Fast and put MikkTSpace in the description

Enable Output

  • internal link connects to Enable socket
  • hidden outputs that still have a connected link are still being used for evaluation
  • hidden outputs are still shown as output attributes in the modifier

Node-Group Drawing

  • With default theme it might be too subtle
  • Should take into account interface scale and editor zoom level

Show asset state icon in breadcrumbs

  • Just needs a +1 from the module for the PR (#146573).

Reroute Creation Active Status

  • The first created reroute should become active
  • This doesn’t solve the entire “Selection vs. Active” concept but the expected behavior is very clear in this situation so it’s different.

Essentials Assets

  • Array
    • “No Curve Selected” warning is showing all the time (bug)
    • Circle “Count” method is broken
    • “Relative Offset” input can just be called “Offset”
      • Should have “XYZ” subtype
  • Scatter
    • “Random Flipping” should be a factor
    • Name inputs inside of the “Randomize” panel to “Randomize”
    • “Random Offset” should have XYZ subtype
    • Scattering on nested instances should be optional
    • “Surface Offset” should have distance subtype
    • “Reset Transform” on by default
  • Curve to Tube
    • “Merge” should be on by default
    • “Align Normals” should only do something when “Merge” is turned off
    • UV map extrapolation on caps needs a bit more implementation
    • “Index” UV factor seems incorrect
    • UV Parameter naming should reuse the naming of the Spline Parameter node exactly
    • Just get rid of the set material node, fix the material of the curve caps
    • “Shade Smooth” option should mvoe to the profile panel
  • Randomize Transforms
    • “Random Offset” should have a distance subtype
    • Doesn’t need “Random” at the front of all the socket names
    • Flipping needs XYZ/factor subtype
    • local space should function differently
  • Displace Geometry
    • Rename “Iterations” to “Substeps”
  • Sphere Selection
    • Totally broken
  • Normal Selection
    • Add “Evaluate on Domain > Face Corner”
  • Identify UV Seam
    • Rename to “Is UV Split”
  • Random Rotation
    • Rename “Angle” to “Zenith”
  • Vector Nodes
    • Remove “Vector” from name
    • Add shader and compositor version of nodes

Random

  • Store Named Attribute vs. Named Attribute Accelerator Keys
    • Change the order of attribute types to put the common ones first so that the accelerator keys match in these different enums.
  • Viewer Node
    • Move overlay viewer options to viewer node, per item
  • Optional Socket Labels
    • Material sockets

Node-group Assets

  • Add visibility of “Manage” panel as an option to the modifier
    • The node group knows whether the manage panel should be displayed by default
  • It might be nice to display the warning type as an icon as well

Declarative Nodes Design

  • We’re not totally satisfied with passing “World” and “Bundle” separately, and we’re looking for a way to generalize the behavior of updating the simulated geometry and data based on the output of a solver node.
    • This should become a separate builtin node that updates the world based on the new world created in the new frame.
      • Should the new state input to the “Update State” node contain everything, or just the stuff you want to change?
      • What should the specific semantics be for the “Update State” node?
  • Agreement to build simulation world bundles in parallel, to be more aligned to the semantics of building the bundle instruction set for the solver.
  • Have two separate inputs describing the simulation world. One is evaluated every frame, one is connected to the input of the simulation zone to only build the initial state, which is expected to be more expensive.

Physics Solver

  • Collision Detection / Contact handling
    • Need to detect face-point and edge-edge collisions
    • Take relative velocities into account
    • SDF collision is also an option, is potentially much faster but has other tradeoffs.
  • SDF vs BVH Tree collision detection
    • SDF
      • Fast test for whether a point is inside
      • Still needs a separate gradient field to find the direction to move the point
      • Accuracy not great with lower resolution volumes
    • BVH Tree
      • Our current implementation is somewhat slow
      • Very precise contact points
    • Hybrid
      • Use SDF for fast collision test and BVH Tree for precise collision resolution
  • Instances in colliders
    • We want to be able to collide with all the instances
    • Ideally, a combined BVH tree is build from the bvh trees of individual instances.
    • Our current BVH tree does not really support this, although support could be added
      • Alternatively, replace our current BVH tree with e.g. Embree
    • We don’t have a way to reference geometry from an instance tree with geometry nodes so we can’t expose this functionality as a node yet.
      • However, we could just support real geometry as a potential collider node input.
  • Rest Shape Initialization
    • Computes rest segment lengths, bending angles and (clamped) stiffness at each point such that when gravity is applied again, it matches the input shape.
    • Could have a separate node that computes a rest_segment_length, rest_segment_rotation, bending_stiffness, length_stiffness (name pending).
      • Could also have a node tool that writes these attributes on the original curves.
  • Hair Self Collision
    • Probably less useful for hair use cases
    • A density volume is another way to deal with some of these problems
    • Two effects: Push hair strands apart to keep volume, align velocities to simulate friction
  • Warm-starting
    • Reuse the internal constraint forces from the previous frame to start the next one
    • Seems like a critical part of most grain/sand simulations
    • Tricky for collision constraints because identifying the same collision across frames is tricky
  • Solver Outputs
    • For measuring the quality of the solution. The value goes to zero as the constraints become “more solved”.
    • If the simulation looks bad and the error is far from zero, increasing the substeps before changing the constraints may be the solution.
    • Showing the error over time is useful too.
      • In the timeline?
    • Can also show internal forces (e.g. current segment stretching).
    • Could be part of “Debug Views” as we talked in the last workshop.
  • Guide Deformation
    • Need to update hair assets to support that workflow
    • Really needs list attributes for proper interpolation

Object Evaluation Bundle Output

  • Overall conclusion is to store the bundle on the geometry. Add “Set Geometry Bundle” and “Get Geometry Bundle” nodes (the latter with a “Remove” option).
  • Add a special case of the driver access of “Geometry Bundle Property”, and the “Attribute Transform” constraint PR retrieves values from the bundle instead of an attributes (and is renamed).
  • The name is not stored in the bundle.
  • Applying modifiers and “Visual Geometry to Objects”
    • For now the data is just removed.
    • Eventually this could be changed, but the correspondence with custom properties is too complicated for now.
    • The spreadsheet should display the bundle in the “Domain” panel because you can only select one item in that panel at a time.

Pablo Topics

  • Just add icon in Menu/Index switch nodes.
  • Node group drawing.
  • Inline viewer socket values.

Node Editor Drawing when zoomed out

  • Want to show more abstract version of node tree:
    • Larger frame labels
      • Tricky aspect is to avoid overlapping frame labels with nested frames
    • Draw nodes as boxes (maybe desaturated)
  • Links (especially those between frames) are still important to see
  • It seems fine to suddenly change the drawing mode when crossing a zoom threshold
  • It’s a bit like a minimap.
    • Double click on frame when zoomed out to zoom in on that frame.
    • Should be possible to move frames around.
    • Home or numpad-dot key could be a toggle to zoom out or zoom into selection

Default Inputs

  • One use case would be handled by adding custom attribute names for field inputs.
    • Looks like it will make sense no matter what to add this option.
  • The simple attribute name solution doesn’t solve the whole problem though.
  • Another solution that was apparently discussed in the last workshop is assigning a node group to generate the default. This can work in the modifier too, potentially getting the modifier inputs inside the default node group as well.
    • Potentially a quite powerful concept (replace drivers?)
    • Needs context-less choice of node group in node editor.

Multi-Object Node Tools

  • Eventually there may be multiple interfaces for node tools. This one is more powerful than the existing “Separate” processing, but it most likely isn’t the “final” interface.
  • Don’t restrict to objects of the same type in object mode
  • Use empty geometry for non-geometry objects
  • Try to change the poll function so this can add new objects from scratch
  • If there is no instance omponent in the output, just handle the top-level geometry
    • Create one object for each geometry component type
  • If there’s no name on the geometry, use “Object” instead
  • A node to flatten the instance hierarchy would be useful
  • Use the active element node to convey the active status (combined with a named attribute on instances)
    • Add a warning if the mode of the active element node doesn’t match the object mode or the status of this option.

Modal Node Tools

  • Simulation Zone Handling
    • Use same behavior as in modifiers where it just gives data from the previous evaluation
    • There were some thoughts about running consecutive simulation zones one after the other, but that doesn’t seem to work so well.
      • State machines can be implemented in a single simulation zone.
  • Separate operator for each node tool
    • The operator system doesn’t handle the current approach of having all node tools in a single operator very well.
      • It will get worse as we need to store a separate keymap for each node tool.
    • Seems reasonable to register a separate operator for each node tool in the asset library.
    • Operator identifier has to be specified on the node group.
      • It likely also has to be copied to the asset meta data for more efficient access.
    • Duplicate operator names need to be handled in the UI somehow.
    • Should avoid making the initial experience for node tools worse:
      • Don’t require that the user provides a custom operator name.
        • Fall back to using some identifier derived from the data-block name.?“”“”"
  • Keymap inputs
    • Original approach was to specify an optional keymap input per boolean group input.
    • Proposal: Add a Modal Event node
      • Has a name of the event similar to existing modal keymaps
      • There can be an arbitrary amount of these nodes in the group, and also in nested node groups.
      • Two of these nodes with the same event name are considered to be the same and any keymap item setup for it, would apply to all.
      • There is a boolean output indicating whether that keymap item is active.
      • There could be an additional string output that outputs the key that was pressed.
        • This is e.g. used by the insert text operator in text edit mode.
      • On the top level node group level, there is a panel to setup the default keymap.

Volumes

  • Blocking features for releasing grids in 5.0
    • Volume grids in viewer node missing
    • Tooltips need to be improved a bit
    • “Attribute search for grid names”
    • There are only two types in the “Grid Info” node
    • Need an error message when grids are connected to the few function nodes that don’t work
    • Display the type and class in the spreadsheet when you connect a grid.
    • Fix crash with color grids
  • Set grid transform node
  • “Voxelize” node
    • Selection field input (only evaluated on tiles)
  • “Prune” node
    • Input can be a boolean field.
    • In the future, we may want to have a “Voxel Value” input node so you don’t have to sample the grid when you’re already evaluating at a specific voxel. This would only work in evaluations with a single grid though.
  • “Field to Grid” node for creating grids.
    • Topology input for the voxel activation structure
    • Arbitrary number of fields that turn into an arbitrary number of grids
  • Curl, divergence, and gradient nodes should be simple to add based on OpenVDB functions
  • The spreadsheet could also show the number of active voxels.
  • Raycasting into volumes
    • Should probably have a threshold input and raymarch until it finds a voxel with that threshold
  • Poisson Solver
    • Useful for fluid simulations
    • There is an implementation in OpenVDB
    • Should be added as a node later on
  • Point Rasterization
    • Kernel function for points when are then reduced for each voxel (e.g. sum or (weighted) average).

Sockets

At the moment the multi-grid input socket (see SDF Grid Boolean) seems related to the single-input sockets (see Trilinear input in Sample Grid):

A proposal would be to always show a grid, but keep adding new rows to it the more inputs we have.

It was also mentioned that we could have a generic “multi-input” socket shape that gets combined with the specific socket type (circle, grid, diamond, …).

List (Fields/Attributes)

  • Closure to List and Field to List should be able to generate multiple lists at the same time
    • Join List input should have dynamic socket shape
  • Combining list fields and values with function nodes
    • List + list
      • Output a list. Choose the longest length, repeat the smaller list.
      • For zero length lists, options are “error”, outputting 0 length list, repeating the default value. We choose the last.
    • List + single value
      • Same as list + list but the second list is length one
    • Field + list
      • Could output a list field, using the length of the longest list
      • OR, could output a list with the field evaluated on the list <-----
    • List field + list field
      • List field output (same rules as list + list for every element)
    • List field + list
      • List field output
    • List field + field
      • Outputs a list field
    • Grid + list
      • Doesn’t work
    • Image + list
      • Doesn’t work
  • If the list length node has a list field input, the output should be a field
  • Attributes
    • Need attribute refactor and various code changes first
    • Need rules for how to propagate lists with mixing, etc.

Bundle and Closure Socket Shapes

  • “Type Definition” and “Bundle Type” are new terms.
    • “Define Signature” is probably clearer.
  • Eventually also propagate properties like “Dimensions” and “Subtype” when the type definition is true.

Implement Today

  • Join Bundle node (Brady) #146750
  • Pre-fill and pre-select the current label with the F2 operator (would require new operator)
  • Requires Label #146781
  • Swap Operator #133452
  • Enable Output (Jacques)
  • Show pack icon in breadcrumb
  • reroute creation (Brady) #146774
  • Manage panel visibility (Hans) #146775
  • Warning type icon in modifier
  • Plus icon in Index/Menu switch
  • Multi Object Node Tools (Hans)
    • Warning when outputting real data
    • New objects for separate geometry types
  • Volume Grids
    • Volume Grid in Viewer, spreadsheet (Hans) #146780
    • Remove experimental flag #146789
    • Grid Info node types (Brady) #146785
    • Set grid transform #146824
    • OpenVDB operator nodes 146845
    • Fix crash with color grids
  • Finish bundle/closure socket shapes
  • Interleave assets in add modifier menu
10 Likes

RE: Modal Node tools.

Last year I made mockups for nodes that seem to align to design that was agreed now. I looked at the Bool Tools modal operators, which are quite complex, and how they could be recreated with modal node tools, and made this list of things that would be required or nice to have:

  • Keymap Input node. Similar to what was agreed in the workshop I think. Shows input types (keyboard, mouse, NDOF, etc), button, and event type (press, hold, tap, drag in the direction). Ctrl/Alt/Shift booleans make sure its only registered if its combined with them.

  • Mouse Gesture - This is important for creating tools that need to take drawings into account. Like lasso selects/cuts, or anything Grease Pencil related. My idea is to output poly curve of the gesture.

  • Event - This is for registering Shift/Ctrl/Alt events without any additional keymap inputs. For cases like precision and snapping in default transform operator, where its just cursor moving and nothing else.

  • Number Input - To allow users to type values, similar to how you can type how many meters to move by in transform operator.

  • Mouse Position (needs a new name I think) - To create box selects/cuts, its important to be able to calculate a region from initial mouse position (where the LMB was pressed), and last position (where it was let go). Region Width/Height output the X and Y dimensions of the square created between them.

3 Likes

Parts of this are definitely reasonable. There is one important aspect that this is not solved by the proposal in this form: users should be able to adapt the keymap without changing the node group using a normal keymap editor. This requires giving certain events a name (e.g. “move left” or " increase count").

2 Likes

I have tried something like this in the past by not showing the buttons/sockets and using the header color for the entire node:

It’s probably a bit crass, but being able to grab nodes anywhere did help with moving stuff around while zoomed out.
Grid snapping becomes basically useless at those smaller zoom levels, though. So that might need some consideration as well if this isn’t just meant as an aid for navigation.

10 Likes

I’m liking the look of this, it reminds me of VSCode’s simplified “scrollbar” widget

I was thinking, would anyone be opposed to a toggle where you could actually HAVE this as a minimap? my guess is it should be where the navigation widget would be in the 3d view, but for the node editor view, and controlled by a similar button


maybe not by default, but if someone has a large node tree, maybe they can switch it on and have very fast navigation

7 Likes

Cinema 4d has this simplified view for its node editor

1 Like

Thanks for the mockup, that looks quite nice. One thing we were wondering is if there is a good way to scale the frame labels up automatically in this view so that they are not huge when zoomed in. The problem is that this is quite tricky to do with nested frames, not sure if there is a good solution.

Minimaps were declined in the past. Can’t find the discussion right now, but I think it was mainly against some UI principles with overlaying UI elements, don’t remember the exact details. It’s not really something we want to get into now I think.

Overall, the design constraints are a bit similar though I think. So finding a good design for this zoomed-out view may also help with designing a minimap in case opinions change.

2 Likes

oh, alright, that makes sense. If the simplified node tree can be exposed as a UI template to python, then people can make their own minimap add-ons as well, even if for the main repo people don’t consider it necessary

this stuff?

the patch looked promising too Blender Archive - developer.blender.org

5 Likes