NodeBooster: New nodes and functionalities for node wizards, for free

[BD3D (Dorian B.)]

Hey folks,

I absolutely love Geometry Nodes. I’ve been using them since it was introduced in alpha stage. Over the years, I’ve developed a few useful scripts to improve my Python skills and for my own commercial pipelines (see the Geo-Scatter project, which runs entirely on Geometry Nodes).

Recently, I’ve decided to centralize all these node tools into a single free plugin: a super-powerful tool that node wizards will surely love!

Here it is, say hello to Node Booster

Features

---

---

You can consider NodeBooster a hybrid between two types of projects:

1. A very useful set of operators and functionalities to improve your nodal workflow!
   You’ll be able to create node trees faster and more efficiently, thanks to shortcut-based nodal operators, for example.
2. A set of new nodes that will be added alongside Blender’s native nodes.
   You’ll find new nodes, such as the Math Expression node in the Add Menu > Booster Nodes.
   (For now, only the Geometry Node Editor is supported.)

New Node: Math Expression

With this node, you’ll be able to evaluate a math expression. The variables will be created as sockets input or constants automatically when you confirm the expression and press Enter.

About:

• The following notations are supported: +, -, *, /, %, //, **, and the ² operator.
• Many functions are recognized, such as sin(a), nroot(a,n), lerp(fac,a,b), and many others. Please see the full list in your node editor under N Panel > Node Booster > Active Node > Glossary for the function names, their arguments, and descriptions.
• Macros for irrational numbers are available. The macros Pi, eNum, and Gold can be automatically assigned to their Unicode symbols π, 𝑒, and φ, which will be recognized and assigned. Make sure to press the π button to activate these macros.
• Algebraic notations are supported (also known as implicit multiplication). You can work with expressions such as 2ab(4ac+π)², where variable names are split into individual characters (e.g., abc will be interpreted as a*b*c). To activate this feature, make sure the ab button is toggled ON!
  • Note that function names will still be recognized and prioritized. For example, if you use sin, the interpreter will treat the sequence as a function rather than as individual variables.
  • When using this algebraic notation mode, ensure there is no ambiguity in the order of operations. For instance, 1/2ab does not yield the same result as 1/(2ab).
• If anything goes wrong, you will receive an error message.
• In N Panel > Node Booster > Active Node, you can bake the Plugin Node into a Blender Node Group for sharing with third parties who do not have the tool.
• Debug: You can see how the node operates behind the scenes. Your expression is first sanitized, then transformed into a function expression, which is executed by the plugin to create a hidden node tree. Navigate to N Panel > Node Booster > Active Node > Development to view these debug expressions.
  • Pro Tip: You’ll also see a ‘NodeTree’ template below these two debug strings. You can drag and drop the Node Group icon (located to the left of the template) to add the hidden node tree to your tree, allowing you to observe what the plugin is doing behind the scenes.
• WARNING: This is an early release. Please verify the results; if you believe the math is incorrect, let me know and I’ll fix it.

Limitations:

• Currently, only Geometry Node Tree types are supported.

For Later (?):

• This node has a lot of potential. I could implement dynamic Int or Bool types and easily evaluate comparison operations, as well as add more functions such as ispair(a) or isneg(a), etc.
• This node could evolve into a more sophisticated Advanced Expressions system, allowing the creation of multi-type variables (e.g., Int, Bool, Vector, Quaternion, and Matrix) for more advanced 3D math. The socket type could dynamically swap. We could even write simple VEX-like code similar to Houdini. If you’d like to see such a project come to life, please consider a donation.

New Node: Sequence Volume

This node will evaluate the sound from the Video Sequencer Editor’s volume on each depsgraph frame_pre update, which is useful if you’d like to create motion graphics or effects that react to music, for example.

This node was made possible thanks to @tintwotin and his post Get the sound intensity of a current frame.

Limitations:

• The node will not work if the plugin is disabled.
• Currently, only Geometry Node Tree types are supported.

For Later (?):

• This node has a lot of potential, and I would like to integrate a feature to sample only specific aspects of the sound or sample the sound with an offset.

New Node: Python Expression

This node will grant you the ability to evaluate a line of Python code directly, allowing you to directly feed it to Geometry Nodes through an output socket.

About:

• You can fetch and synchronize almost any kind of data in Blender to Geometry Nodes as long as it fits into one of the following types: Float, Boolean, Integer, Vector, Color, Rotation, Matrix, bpy.types.Object, bpy.types.Collection, bpy.types.Material, or bpy.types.Image.
• The node socket output type will automatically adjust based on the value evaluated in your expression.
• The shortcuts bpy; D = bpy.data; C = context = bpy.context; scene = context.scene and from mathutils import *; from math import * will be available in your evaluation context.
• The name self is also recognized as the node object. Note that it might not be available in every context.
• The macro #frame will also work in there.
• You can define extra convenience variables in your node preferences (see Node Editor N Panel > Node Booster > Active Node > Preferences).
• The node will automatically be re-evaluated on each depsgraph post and frame_pre update by default, ensuring that the values are always in sync with Blender.

Limitations:

• The node will not work if the plugin is disabled.
• Currently, only Geometry Node Tree types are supported.
• This system relies on string evaluation, so if you use objects with escape characters (e.g., bpy.data.objects["my"name"].location), it may fail.

Tip & Trick:

• If you’re unsure how to find the code lines you need, go to Blender Preferences > Interface > Display and enable ‘Python Tooltips’. With this option enabled, hovering over properties will display the full bpy data.

New Node: Python Script

Similar to the node above, but instead of entering a line of code, you select a blender text data, the whole file will be evaluated, and the python variables starting with the letters OUT_ will automatically create new sockets and update their values.

Code Example

import bpy
from math import *
# Put any complex calculation here, 
# the values will be updated automatically & feed to geometry node
# Their var names simply needs to ends with 'OUT_' prefix
x = sin(10/50)
this_name = "Foo"

OUT_FloatValue = x
OUT_Foo_Object = bpy.data.objects[this_name]
OUT_MyQuaternion = bpy.context.object.rotation_euler.to_quaternion()
OUT_MyFloatList = [i for i in range(10)] #will be translated into a matrix

New Node: Camera Info

Gather information about the scene’s active camera, or any selected camera. Thanks to @Strike_Digital for the original implementation.

Limitations:

• The node will not work if the plugin is disabled.
• Currently, only Geometry Node Tree types are supported.

New Node: Is Rendered View

This node checks if the rendered view shading mode is active. It works well with is Viewport, allowing you to preview your final object even in the Cycles dynamic viewport (which can handle a heavier workload compared to a raster viewport).

Limitations:

• The node will not work if the plugin is disabled.
• Currently, only Geometry Node Tree types are supported.
• It will return True if any of your viewports are in rendered shading view. Unfortunately, Blender’s Geometry Nodes do not support returning geometry for a single viewport.

Draw Routes

Quickly draw reroutes and create links from input to output sockets in this mode. Select a node, then press E to enter nodal mode.

For Later (?):

• The new Blender node panel system is not yet supported; it’s unclear if the API allows for it.
• It would be nice to enable right-to-left linking and possibly implement a way to add nodes on the fly while continuing the linking process.

Favorites

Add a favorites flag with CTRL+Y, and cycle through your favorites with Y.

Color Palette Assign

Assign colors to selected nodes easily using a palette.

Draw Frames

Quickly draw and assign frames by continuously pressing J.

For Later (?):

• There is room for improvement; currently, parenting frames is not supported.

Reroute Chamfer

Chamfer selected reroutes with CTRL+B. Note that this is not as useful if your noodle curvature is not set to straight. You can change this in Theme > Node Editor > Noodle Curving.

Downstream/Upstream Selection

Select nodes downstream or upstream by using CTRL+Left Mouse or CTRL+ALT+Left Mouse. Hold the SHIFT key to preserve the selection.

Advanced Node Search

Quickly search for nodes using the advanced node search tool, located in the N panel.

For Later (?):

• This functionality could be greatly improved; for instance, by implementing recursive search and visualizing the results in the UI before selection. Consider making a donation if you’d like to see this feature implemented.

Purge Unused

Remove unused nodes or elements. This operator can be found in the node editor’s ‘Node’ header menu.

Customized Shortcuts

All operator shortcuts can be customized in Node Editor N Panel > Node Booster.

For Later (?):

• It would be nice if the shortcuts were saved in the plugin preferences.

Download it now

---

---

Node Booster is completely free!
However, to keep this project alive and well-maintained, your support makes all the difference.

If you enjoy using it and want to see new, cool features, continued development, or any form of customer support, please consider a one-time donation or joining on Patreon.

• nodebooster.zip (Free)
• Github (Free)
• BlenderExtension (Free) (Coming soon…)
• Gumroad (for Donations) (Coming soon…)
• BlenderMarket (for Donations) (Coming soon…)
• Patreon (for Donations)

Changelogs

v1.0 Beta

Release Date: 24/02/2025
Blender Compatibility: 4.2 | 4.3 | 4.4
Description: This is the initial release, ready for beta testers.

[BD3D (Dorian B.)]

Finished!
I Need beta testers now

[thorn]

@BD3D

Downstream/Upstream Selection

Nice feature. I don’t love pressing L L L L L L and hoping it got it all.

[mart0nnn (Marton)]

This looks extremely useful! I’m gonna give it a twirl the first chance I get!

[Blender_Fun1 (Blender.Fun)]

wow, the python node makes GN so much more powerful…!! Love it!!

[aryeramaty]

Ho, this looks awesome!

[BD3D (Dorian B.)]

I added support for Quaternion and Matrix type for the Python Api node, update on github

[BD3D (Dorian B.)]

I just added an extension to the Python Api Node, a Python script node,
It will automatically output any variable of your selected script as long as they start with the OUT_ Prefix

import bpy

# Put any complex calculation here, 
# the values will be updated automatically & feed to geometry node
# Their var names simply needs to ends with 'OUT_' prefix

OUT_FloatValue = 1.0
OUT_Obj = bpy.context.object
OUT_Vector_Euler = bpy.context.object.rotation_euler.to_quaternion()

[BD3D (Dorian B.)]

WIP, introducing ‘Nex Script’ node

[drumfish]

Wow this one made my mind just go boom really. The most impressive addon I’ve seen so far (after looptools haha) I really hope I’ll make something cool with it and showcase and others will too! Maybe it could be vanilla one day hh

[BD3D (Dorian B.)]

Thank you very much for the compliment @drumfish

[BD3D (Dorian B.)]

Hey Folks, since the last update last week:

• Vectors are now supported, you can do vector math, and even split vector with notations such as x, y, z = myVec or assemble float into vectors ect. Possibilities are endless.
• I integrated the BoolSocket type, you can now easily compare with the == != > notation.
• I also fully integrated all math expression function into NexScript, see all functions below currently supported.

## a + b
Addition
Add between SocketFloats and/or SocketVectors.
Type conversion is implicit.



## a - b
Subtraction.
Subtract between SocketFloats and/or SocketVectors.
Type conversion is implicit.



## a * b
Multiplication.
Multiply between SocketFloats and/or SocketVectors.
Type conversion is implicit.



## a ** b
Power.
Raise SocketFloats and/or SocketVectors by a float compatible type.



## a / b
Division.
Divide between SocketFloats and/or SocketVectors.
Type conversion is implicit.



## a // b
FloorDiv.
Do a FloorDiv operation between SocketFloats and/or SocketVectors.
Type conversion is implicit.



## a % b
Modulo.
Do a Modulo operation between SocketFloats and/or entry-wise SocketVectors.
Type conversion is implicit.



## a == b
Equal.
Compare if A and B are equals.

Supports SocketFloats, SocketVectors & SocketBool.
Will return a SocketBool.



## a != b
Not Equal.
Compare if A and B are not equals.

Supports SocketFloats, SocketVectors & SocketBool.
Will return a SocketBool.



## a > b
Greater.
Compare if A is greater than B.

Supports SocketFloats, SocketVectors & SocketBool.
Will return a SocketBool.



## a >= b
Greater or Equal.
Compare if A is greater or equal than B.

Supports SocketFloats, SocketVectors & SocketBool.
Will return a SocketBool.



## a < b
Lesser.
Compare if A is lesser than B.

Supports SocketFloats, SocketVectors & SocketBool.
Will return a SocketBool.



## a <= b
Lesser or Equal.
Compare if A is lesser or equal than B.

Supports SocketFloats, SocketVectors & SocketBool.
Will return a SocketBool.



## -a
Negate.
Negate using the 'a = -a' notation.



## abs(a)
Absolute.
Get the absolute value of a SocketFloat or SocketVector.



## round(a)
Round.
Round a SocketFloat or entry-wise SocketVector.

ex: 1.49 will become 1
1.51 will become 2.



## vA.x
Vector X.
Get or Assign a SocketFloat value from the X axis of a SocketVector.

Is equivalent to the 'vA[0]' notation.



## vA.y
Vector Y.
Get or Assign a SocketFloat value from the Y axis of a SocketVector.

Is equivalent to the 'vA[1]' notation.



## vA.z
Vector Z.
Get or Assign a SocketFloat value from the Z axis of a SocketVector.

Is equivalent to the 'vA[2]' notation.



## vA.xyz
Vector XYZ tuple.
Get or Assign a tuple of 3 SocketFloat values from the corresponding axes of a SocketVector.

Is equivalent to the 'vA[:]' notation.



## vA.length
Vector Length.
Return a SocketFloat value corresponding to the length of SocketVector.

Is a read-only property.



## vA.normalized
Vector Noralization.
Return a normalized SocketVector.

Is a read-only property.



## log(a, n)
Logarithm A base N.
Supports SocketFloat and entry-wise SocketVector if N is float compatible.



## sqrt(a)
Square Root of A.
Supports SocketFloat and entry-wise SocketVector.



## invsqrt(a)
Inverse Square Root of A.
Supports SocketFloat and entry-wise SocketVector.



## nroot(a, n)
A Root N.
Equivalent to doing 'A**(1/N)'.
Supports SocketFloat and entry-wise SocketVector if N is float compatible.



## floor(a)
Floor a Float value.
Supports SocketFloat and entry-wise SocketVector.

ex: 1.51 will become 1
-1.51 will become 2.



## ceil(a)
Ceil a Float value.
Supports SocketFloat and entry-wise SocketVector.

ex: 1.01 will become 2
-1.99 will become 1.



## trunc(a)
Trunc a Float value.
Supports SocketFloat and entry-wise SocketVector.

ex: 1.99 will become 1
-1.99 will become -1.



## frac(a)
Fraction.
The fraction part of A.
Supports SocketFloat and entry-wise SocketVector.



## wrap(v, a, b)
Wrapping.
Wrap a value V to Range A B.
Supports SocketFloat and entry-wise SocketVector.



## snap(v, i)
Snapping.
Snap a value V to the nearest increament I.
Supports SocketFloat and SocketVector.



## pingpong(v, scale)
PingPong.
Wrap a value and every other cycles at cycle Scale.
Supports SocketFloat and entry-wise SocketVector if scale is float compatible.



## sin(a)
The Sine of A.
Supports SocketFloat and entry-wise SocketVector.



## cos(a)
The Cosine of A.
Supports SocketFloat and entry-wise SocketVector.



## tan(a)
The Tangent of A.
Supports SocketFloat and entry-wise SocketVector.



## asin(a)
The Arcsine of A.
Supports SocketFloat and entry-wise SocketVector.



## acos(a)
The Arccosine of A.
Supports SocketFloat and entry-wise SocketVector.



## atan(a)
The Arctangent of A.
Supports SocketFloat and entry-wise SocketVector.



## sinh(a)
The Hyperbolic Sine of A.
Supports SocketFloat and entry-wise SocketVector.



## cosh(a)
The Hyperbolic Cosine of A.
Supports SocketFloat and entry-wise SocketVector.



## tanh(a)
The Hyperbolic Tangent of A.
Supports SocketFloat and entry-wise SocketVector.



## radians(a)
Convert a value from Degrees to Radians.
Supports SocketFloat and entry-wise SocketVector.



## degrees(a)
Convert a value from Radians to Degrees.
Supports SocketFloat and entry-wise SocketVector.



## cross(vA, vB)
Vector Cross Product.
The cross product between vector A an B.



## dot(vA, vB)
Vector Dot Product.
A dot B.



## project(vA, vB)
Vector Projection.
Project A onto B.



## faceforward(vA, vI, vR)
Vector Faceforward.
Faceforward operation between a given vector, an incident and a reference.



## reflect(vA, vB)
Vector Reflection.
Reflect A onto B.



## distance(vA, vB)
Vector Distance.
The distance between location A & B.



## normalize(vA)
Vector Normalization.
Normalize the values of a vector A to fit a 0-1 range.



## separate_xyz(vA)
Separate a SocketVector into 3 SocketFloat.

Tip: you can use python slicing notations 'myX, myY, myZ = vA' to do that instead.



## combine_xyz(fX, fY, fZ)
Combine 3 SocketFloat (or python values) into a SocketVector.



## roteuler(vA, vE, vC)
Vector Rotate (Euler).
Rotate a given Vector A with euler angle radians E, at optional center C.



## rotaxis(vA, vX, fA, vC)
Vector Rotate (Euler).
Rotate a given Vector A from defined axis X & angle radians F, at optional center C.



## min(a, b, c,.. )
Minimum.
Get the absolute minimal value across all passed arguments.
Arguments must be compatible with SocketFloat.



## smin(a, b, dist)
Smooth Minimum
Get the minimal value between A & B considering a smoothing distance to avoid abrupt transition.
Supports SocketFloats only.



## max(a, b, c,.. )
Maximum.
Get the absolute maximal value across all passed arguments.
Arguments must be compatible with SocketFloat.



## smax(a, b, dist)
Smooth Maximum
Get the maximal value between A & B considering a smoothing distance to avoid abrupt transition.
Supports SocketFloats only.



## lerp(f, a, b)
Mix.
Linear Interpolation between value A and B from given factor F.
Supports SocketFloat and SocketVector.



## mix(f, a, b)
Alternative notation to lerp() function.



## clamp(v, a, b)
Clamping.
Clamp a value a between min A an max B.
Supports SocketFloat and entry-wise SocketVector if A & B are float compatible.



## clampauto(v, a, b)
AutoClamping.
Clamp a value a between auto-defined min/max A & B.
Supports SocketFloat and entry-wise SocketVector if A & B are float compatible.



## mapl(v, a, b, x, y)
Map Range.
Remap a value V from a given range A,B to another range X,Y.
Supports SocketFloat and SocketVector.



## mapst(v, a, b, x, y, step)
Map Range (Stepped).
Remap a value V from a given range A,B to another range X,Y with a given step.
Supports SocketFloat and SocketVector.



## mapsmo(v, a, b, x, y)
Map Range (Smooth).
Remap a value V from a given range A,B to another range X,Y.
Supports SocketFloat and SocketVector.



## mapsmoo(v, a, b, x, y)
Map Range (Smoother).
Remap a value V from a given range A,B to another range X,Y.
Supports SocketFloat and SocketVector.



## getp()
Position Attribute.
Get the GeometryNode 'Position' SocketVector input attribute.



## getn()
Normal Attribute.
Get the GeometryNode 'Normal' SocketVector input attribute.

GitHub - DB3D/NodeBooster: New nodes and functionalities for blender node...

[obsurveyor]

Just wanted to say this is really cool! I needed information from Lights in GN which isn’t provided officially yet. So first I used the Python API node provided by NodeBooster to see if it was possible and that worked fine for getting the color, which blew my mind a bit. Then I went and added a new node to NodeBooster to provide info for whatever Light object I specified and it just worked!

Lights are annoying in Blender because the LIGHT internal type has a sub-type to determine if its Point, Sun, etc., so I don’t feel confident submitting a pull request for my hacky node based on the Camera Info node provided. Maybe you could put a Light Info node on your to-do list if you haven’t already.

[BD3D (Dorian B.)]

Thanks for the compliment @obsurveyor
What kind of info this node would need?

[obsurveyor]

These are what mine currently look like:

edit: It would also be nice if we could connect the light object selection as an Input so they can be used in node groups. (This would be nice for all your nodes in general that have an object selection)

[BD3D (Dorian B.)]

@obsurveyor Will add it tomorrow officially.
It can be done quickly, it’s quite simple compared on the NexScript node i’m building

It’s almost ready btw, i’ve implemented MatrixMath logic into the mix yesterday. Still need to cover SocketInt, ScoketColor & SocketQuaternion. This project is a lot of work

This is the kind of script the node can handle, on the last update on github

#NexDemo.py

# Initialization
# first we need to define our socket variables!
myFloatA:infloat
myFloatB:infloat = 0.123 #you can also assign a default value!
myV:invec
myBoo:inbool = True
sockMatrix:inmat

# do math between types  using '+' '-' '*' '/' '%' '**' '//' symbols,
# or functions. (see the full list in 'NodeBooster > Glossary' panel)
c = (myFloatA + myFloatB)/2
c = nroot(sin(c),cos(123)) // myFloatB

# do comparisons between types using '>' '<' '!=' '==' '<=' '>='
# result will be a socket bool
isequal = myFloatA == myFloatB
islarger = myV > myBoo
# to bitwise operation with symbols '&', or '|' on socket bool
bothtrue = isequal & islarger

# You can evaluate any python types you wish to, and do operations between socket and python types
frame = bpy.context.scene.frame_current
ActiveLov = bpy.context.object.location
c += abs(frame)

# easily access Vector or Matrix componements.
c += (myV.x ** myV.length) + sockMatrix.translation.z
newvec = combine_xyz(c, frame, ActiveLov.x)

# Do Advanced Matrix and Vector operation 
ActiveMat = bpy.context.object.matrix_world
pytuple = (1,2,3)
TransVec = (sockMatrix.inverted() @ ActiveMat) @ newvec.normalized()
TransVec = sockMatrix @ cross(pytuple,TransVec,)
TransVec = sqrt(TransVec) #math operations can also work entry-wise on vectors.
minElement = min(separate_matrix(sockMatrix)) #get lowest socketfloat element of Matrix.

# types can be itterable
newvalues = []
for i,component in enumerate(TransVec):
    newval = component + minElement + i
    newvalues.append(newval)
TransVec[:] = newvalues

## Because we are using python you can create functions you can reuse too
def entrywise_sinus_on_matrix_element(SockMatrix):
    new = []
    for f in separate_matrix(SockMatrix):
        new.append(sin(f))
    return combine_matrix(new)

newMat = entrywise_sinus_on_matrix_element(sockMatrix)

# Then we assign the socket to an output
# you can define a strict output type
# or auutomatically define the output scoket with 'outauto'
BoolOut:outbool = bothtrue
TransVec:outvec = TransVec
myMatrix:outauto = newMat

The nodetree the script generate is a big stairwell! Ugly, but it works, and fast! The evaluated python values from the script are be synched on each frame or depsgraph update with no noticeable slowdowns.

[obsurveyor]

@BD3D

@obsurveyor Will add it tomorrow officially.
It can be done quickly, it’s quite simple compared on the NexScript node i’m building

Awesome! I’ll test it out as soon as I see the update. I did try to do it myself but I couldn’t figure out how to restrict an in_socket(you don’t appear to use this functionality yet, though I can see its there in the utils) to only the specific kind of Light. I also couldn’t figure out how to read from it to pass back out the values from the Outputs.

[BD3D (Dorian B.)]

@obsurveyor

but I couldn’t figure out how to restrict an in_socket(you don’t appear to use this functionality yet, though I can see its there in the utils) to only the specific kind of Light. I also couldn’t figure out how to read from it to pass back out the values from the Outputs.

I’m sorry but I did not understand what you meant, could you reformulate?
What is 'restricting an in_socket’ ? What do you want to read and pass back to output?
If you wish to read something from an ‘Node Input’ using python, say you pass an input object and process it. it’s not possible unfortunately Geometry node don’t let us read the content of a socket, we are blind to what it may hold. We can onlt assign default values or tweak nodes

[obsurveyor]

So the way your current selector prop(the bottom one that you pick an object from) looks like it uses a poll function to only show matching objects. So for my Point Light Info node I wrote this:

    def light_obj_poll(self, obj):
        return obj.type == 'LIGHT' and obj.data.type == 'POINT'

    light_obj: bpy.props.PointerProperty(
        type=bpy.types.Object,
        poll=light_obj_poll,
        )

I couldn’t figure out how to make the same thing for(see comment in code below):

            ng = create_new_nodegroup(name,
                # in socket for 'Point Light' shows all objects in scene, can't
                # figure out equivalent poll function
                in_sockets={
                    "Point Light" : "NodeSocketObject",
                },
                out_sockets={
                    "Point Light" : "NodeSocketObject",
                    "Color" : "NodeSocketColor",
                    "Power" : "NodeSocketFloat",
                    "Soft Falloff" : "NodeSocketBool",
                    "Radius" : "NodeSocketFloat",
                },
            )

But it sounds like I can’t check if the in_socket has been assigned and read it’s values in update here any, which is a bummer:

        # somehow reassign to the new in_socket instead of prop?
        light_obj = self.light_obj
        
        if (light_obj and light_obj.data and light_obj.data.type == 'POINT'):
            set_socket_defvalue(self.node_tree, 0, value=light_obj)
            set_socket_defvalue(self.node_tree, 1, value=[light_obj.data.color[0], light_obj.data.color[1], light_obj.data.color[2], 1.0])
            set_socket_defvalue(self.node_tree, 2, value=light_obj.data.energy)
            set_socket_defvalue(self.node_tree, 3, value=light_obj.data.use_soft_falloff)
            set_socket_defvalue(self.node_tree, 4, value=light_obj.data.shadow_soft_size)

[BD3D (Dorian B.)]

Okay, understood. Thank you for the explanations
Unfortunately the in_socket will be useless for you in what you want to achieve. A socket data cannot be read, you cannot do anything with this information, it’s only accessible in C++ What we can do is assign an output default value, that’s it