PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain GeometryNodeListLength(GeometryNode) in complete detail according to the official Blender documentation.

assistant: # GeometryNodeListLength(GeometryNode)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), [`NodeInternal`](bpy.types.NodeInternal.html#bpy.types.NodeInternal "bpy.types.NodeInternal"), [`GeometryNode`](bpy.types.GeometryNode.html#bpy.types.GeometryNode "bpy.types.GeometryNode")

*class* bpy.types.GeometryNodeListLength(*GeometryNode*)
:   Count how many items are in a given list

    data_type
    :   Type:
        :   enum in [Node Socket Data Type Items](bpy_types_enum_items/node_socket_data_type_items.html#rna-enum-node-socket-data-type-items), default `'GEOMETRY'`

    *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

    *classmethod* input_template(*index*)
    :   Input socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

        Return type:
        :   [`NodeInternalSocketTemplate`](bpy.types.NodeInternalSocketTemplate.html#bpy.types.NodeInternalSocketTemplate "bpy.types.NodeInternalSocketTemplate")

    *classmethod* output_template(*index*)
    :   Output socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

        Return type:
        :   [`NodeInternalSocketTemplate`](bpy.types.NodeInternalSocketTemplate.html#bpy.types.NodeInternalSocketTemplate "bpy.types.NodeInternalSocketTemplate")

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with CompositorNodeDiffMatte(CompositorNode) in a Blender add-on or script – include code.

assistant: # CompositorNodeDiffMatte(CompositorNode)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), [`NodeInternal`](bpy.types.NodeInternal.html#bpy.types.NodeInternal "bpy.types.NodeInternal"), [`CompositorNode`](bpy.types.CompositorNode.html#bpy.types.CompositorNode "bpy.types.CompositorNode")

*class* bpy.types.CompositorNodeDiffMatte(*CompositorNode*)
:   Produce a matte that isolates foreground content by comparing it with a reference background image

    *classmethod* is_registered_node_type()
    :   True if a registered node type

        Returns:
        :   Result

        Return type:
        :   boolean

    *classmethod* input_template(*index*)
    :   Input socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

        Return type:
        :   [`NodeInternalSocketTemplate`](bpy.types.NodeInternalSocketTemplate.html#bpy.types.NodeInternalSocketTemplate "bpy.types.NodeInternalSocketTemplate")

    *classmethod* output_template(*index*)
    :   Output socket template

        Parameters:
        :   **index** (*int in* *[**0**,* *inf**]*) – Index

        Returns:
        :   result

        Return type:
        :   [`NodeInternalSocketTemplate`](bpy.types.NodeInternalSocketTemplate.html#bpy.types.NodeInternalSocketTemplate "bpy.types.NodeInternalSocketTemplate")

    update()

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Explain Example in complete detail according to the official Blender documentation.

assistant: |  |  |  |
| --- | --- | --- |
| ../../../_images/modeling_modifiers_deform_smooth_mesh-before.png   Mesh before smoothing. | ../../../_images/modeling_modifiers_deform_smooth_mesh-one-iteration.png   Mesh after one smoothing iteration. | ../../../_images/modeling_modifiers_deform_smooth_mesh-ten-iterations.png   Mesh after ten smoothing iterations. |
user: What is Areas and how is it used in Blender Python scripting?

assistant: # Areas

[image reference removed]

Area boundaries are indicated by rounded corners (yellow highlights).

The Blender window is divided into a number of rectangles called Areas.
Areas reserve screen space for [Editors](../../editors/index.xhtml), such as the
[3D Viewport](../../editors/3dview/introduction.xhtml) or the
[Outliner](../../editors/outliner/introduction.xhtml).
Each editor offers a specific piece of functionality.

Areas are grouped into [Workspaces](workspaces.xhtml),
which are geared towards particular tasks (modeling, animating and so on).
user: Explain Example Script in complete detail according to the official Blender documentation.

assistant: ```
# This example assumes we have a mesh object selected

import bpy
import bmesh

# Get the active mesh
me = bpy.context.object.data

# Get a BMesh representation
bm = bmesh.new()   # create an empty BMesh
bm.from_mesh(me)   # fill it in from a Mesh

# Modify the BMesh, can do anything here...
for v in bm.verts:
    v.co.x += 1.0

# Finish up, write the bmesh back to the mesh
bm.to_mesh(me)
bm.free()  # free and prevent further access
```

### Standalone Module

The BMesh module is written to be standalone except for [`mathutils`](mathutils.html#module-mathutils "mathutils")
which is used for vertex locations and normals.
The only other exception to this are when converting mesh data to and from [`bpy.types.Mesh`](bpy.types.Mesh.html#bpy.types.Mesh "bpy.types.Mesh").
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: Threshold
:   Areas brighter than the *Threshold* are blurred.

Clamp
:   The maximum luminosity that is added.

Boost Factor
:   Multiplier of the brightness.

Blur Distance
:   The size of the blur.

Quality
:   Improves the quality of the glow by giving smoother results but will be slower.

Only Boost
:   This checkbox allows you to only show/use
    the “modified” version of the image, without the base one.
user: What is Header(bpy_struct) and how is it used in Blender Python scripting?

assistant: # Header(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.Header(*bpy_struct*)
:   Editor header containing UI elements

    bl_idname
    :   If this is set, the header gets a custom ID, otherwise it takes the name of the class used to define the header; for example, if the class name is “OBJECT_HT_hello”, and bl_idname is not set by the script, then bl_idname = “OBJECT_HT_hello”

        Type:
        :   string, default “”, (never None)

    bl_region_type
    :   The region where the header is going to be used in (defaults to header region)

        Type:
        :   enum in [Region Type Items](bpy_types_enum_items/region_type_items.html#rna-enum-region-type-items), default `'HEADER'`

    bl_space_type
    :   The space where the header is going to be used in

        Type:
        :   enum in [Space Type Items](bpy_types_enum_items/space_type_items.html#rna-enum-space-type-items), default `'EMPTY'`

    layout
    :   Structure of the header in the UI

        Type:
        :   [`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (readonly)

    draw(*context*)
    :   Draw UI elements into the header UI layout

    *classmethod* append(*draw_func*)
    :   Append a draw function to this menu,
        takes the same arguments as the menus draw function

    *classmethod* is_extended()

    *classmethod* prepend(*draw_func*)
    :   Prepend a draw function to this menu, takes the same arguments as
        the menus draw function

    *classmethod* remove(*draw_func*)
    :   Remove a draw function that has been added to this menu.

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Describe LineStyleColorModifier_DistanceFromObject(LineStyleColorModifier) from the Blender manual or Python API, including usage steps and snippets.

assistant: # LineStyleColorModifier_DistanceFromObject(LineStyleColorModifier)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`LineStyleModifier`](bpy.types.LineStyleModifier.html#bpy.types.LineStyleModifier "bpy.types.LineStyleModifier"), [`LineStyleColorModifier`](bpy.types.LineStyleColorModifier.html#bpy.types.LineStyleColorModifier "bpy.types.LineStyleColorModifier")

*class* bpy.types.LineStyleColorModifier_DistanceFromObject(*LineStyleColorModifier*)
:   Change line color based on the distance from an object

    blend
    :   Specify how the modifier value is blended into the base value

        Type:
        :   enum in [Ramp Blend Items](bpy_types_enum_items/ramp_blend_items.html#rna-enum-ramp-blend-items), default `'MIX'`

    color_ramp
    :   Color ramp used to change line color

        Type:
        :   [`ColorRamp`](bpy.types.ColorRamp.html#bpy.types.ColorRamp "bpy.types.ColorRamp"), (readonly)

    expanded
    :   True if the modifier tab is expanded

        Type:
        :   boolean, default False

    influence
    :   Influence factor by which the modifier changes the property

        Type:
        :   float in [0, 1], default 0.0

    range_max
    :   Upper bound of the input range the mapping is applied

        Type:
        :   float in [-inf, inf], default 0.0

    range_min
    :   Lower bound of the input range the mapping is applied

        Type:
        :   float in [-inf, inf], default 0.0

    target
    :   Target object from which the distance is measured

        Type:
        :   [`Object`](bpy.types.Object.html#bpy.types.Object "bpy.types.Object")

    type
    :   Type of the modifier

        Type:
        :   enum in [Linestyle Color Modifier Type Items](bpy_types_enum_items/linestyle_color_modifier_type_items.html#rna-enum-linestyle-color-modifier-type-items), default `'ALONG_STROKE'`, (readonly)

    use
    :   Enable or disable this modifier during stroke rendering

        Type:
        :   boolean, default False

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.LineStyleColorModifier_DistanceFromObject.type "bpy.types.LineStyleColorModifier_DistanceFromObject.type")
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The Build modifier.

Mode
:   Determines how many strokes are being animated at a time.

    Sequential:
    :   Strokes appear/disappear one after the other, but only a single one changes at a time.

    Concurrent:
    :   Multiple stroke appear/disappear at a time.

    Additive:
    :   Builds only the strokes that are new compared to last keyframe.
        The assumption is Additive Drawing was used so that the shared strokes are the same.

Transition *(in Sequential and Concurrent Mode)*
:   Determines the animation type to build the strokes.

    Grow:
    :   Shows points in the order they occur in each stroke, from first to last stroke.
        (Simulating lines being drawn.)

    Shrink:
    :   Hide points from the end of each stroke to the start, from last to first stroke.
        (Simulating lines being erased.)

    Vanish:
    :   Hide points in the order they occur in each stroke, from first to last stroke.
        (Simulating ink fading or vanishing after getting drawn.)

Timing
:   The way you want to time the building of the strokes.

    Natural Drawing Speed:
    :   Use the recorded speed of the stylus when the strokes were drawn.
        Only available in Sequential and Additive Mode.

        Speed Factor
        :   The recorded speed is multiplied by this value.

        Maximum Gap
        :   The maximum gap between strokes in seconds.

    Number of Frames:
    :   Set a fixed maximum number of frames for the build animation.
        (Unless another Grease Pencil keyframe occurs before this time has elapsed.)

        Frames
        :   The maximum number of frames used.

        Delay
        :   Number of frames after each Grease Pencil keyframe before the modifier has any effects.

    Percentage Factor:
    :   Manually set a percentage factor to control the amount of the strokes that are visible.

        Factor
        :   The factor from 0 to 1.

    Time Alignment:
    :   Only available in Concurrent Mode.

        Align Start
        :   All stroke start at the same time (i.e. shorter strokes finish earlier).

        Align End
        :   All stroke end at the same time (i.e. shorter strokes start later).

Object
:   Use the distance to an object to define the order in which strokes appear.

### Custom Range

If enabled, only modify strokes during the specified frame range.

Start, End
:   Determines the start and end frame for the build effect.

### Fade

Factor
:   Defines how much the stroke is fading in/out.

Thickness
:   How much strength fading is applied to the stroke’s thickness.

Opacity
:   How much strength fading applies to the stroke’s opacity.

Weight Output
:   Assign a weight value to points that have started/finished the fade.

### Influence Filters

See [Influence Filters](../introduction.html#grease-pencil-modifier-influence-filters).
user: Provide the full official documentation entry for Separate, preserving all code examples.

assistant: Disconnects the selected sub grid from the rest of the surface and moves it into
a new Surface object. The control points at the border are duplicated so that both
the original surface and the disconnected surface have them.

The sub grid must consist of one or more complete rows or columns of the surface grid.
user: Explain Levels in complete detail according to the official Blender documentation.

assistant: Adds an offset and a scale to all weights of the selected weight groups.
with this tool you can raise or lower the overall “heat” of the weight group.

[image reference removed]

Levels example.

Subset
:   Restrict the tool to a subset.
    See above [The Subset Option](#sculpt-paint-weight-paint-editing-subset) for how subsets are defined.

Offset
:   A value from the range (-1.0 - 1.0) to be added to all weights in the vertex group.

Gain
:   All weights in the Subset are multiplied with the gain.
user: How do I use Attribute Domain Point Edge Face Curve Items in Blender? Include parameters, examples, warnings and best practices.

assistant: # Attribute Domain Point Edge Face Curve Items

POINT:
:   Point.

    Attribute on point.

EDGE:
:   Edge.

    Attribute on mesh edge.

FACE:
:   Face.

    Attribute on mesh faces.

CURVE:
:   Spline.

    Attribute on spline.
user: Explain Inherited Properties in complete detail according to the official Blender documentation.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`FileHandler.bl_idname`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_idname "bpy.types.FileHandler.bl_idname") - [`FileHandler.bl_import_operator`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_import_operator "bpy.types.FileHandler.bl_import_operator") | - [`FileHandler.bl_export_operator`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_export_operator "bpy.types.FileHandler.bl_export_operator") - [`FileHandler.bl_label`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_label "bpy.types.FileHandler.bl_label") - [`FileHandler.bl_file_extensions`](bpy.types.FileHandler.html#bpy.types.FileHandler.bl_file_extensions "bpy.types.FileHandler.bl_file_extensions") |
user: What is Nodes and how is it used in Blender Python scripting?

assistant: # Nodes

Blender contains different node-based editors with different purposes,
so this section only explains how to work with nodes in general.
The list below shows the different types of nodes and where they’re documented.

[image reference removed]

Example of a node editor.

| Icon | Name | Description |
| --- | --- | --- |
|  | [Geometry Nodes](../../../modeling/geometry_nodes/index.html) | Used for procedural modeling. |
|  | [Shader Nodes](../../../render/shader_nodes/index.html) | Used to create materials for objects. |
|  | [Composite Nodes](../../../compositing/index.html) | Used to edit rendered images. |
|  | [Texture Nodes](../../../editors/texture_node/introduction.html) | Used to create custom textures. |
user: What is Sample Nearest Node and how is it used in Blender Python scripting?

assistant: # Sample Nearest Node

[image reference removed]

The *Sample Nearest* node retrieves the [index](../read/input_index.xhtml)
of the geometry element in its input geometry that is closest to the input position.

This node is similar to the [Geometry Proximity Node](geometry_proximity.xhtml),
but it outputs the index of the closest element instead of its distance from the current location.
user: Give a detailed overview of Properties: syntax, arguments, return values, common patterns.

assistant: Mode
:   How to link to OSL shaders.

    Internal:
    :   A text data-block is used to store the OSL shader, and the OSO bytecode is stored in the node itself.
        This is useful for distributing a blend-file with everything packed into it.

        Script Node Update
        :   Reloads the text file data-block, creating new inputs and outputs if needed.

    External:
    :   Used to specify a `.osl` file from a drive,
        and this will then be automatically compiled into a `.oso` file in the same directory.
        It is also possible to specify a path to a `.oso` file, which will then be used directly,
        with compilation done manually by the user. The third option is to specify just the module name,
        which will be looked up in the shader search path.

        The shader search path is located in the same place as the scripts or configuration path, under:

        **Linux:**

        ```
        $HOME/.config/blender/5.0/shaders/
        ```

        **Windows:**

        ```
        C:\Users\$user\AppData\Roaming\Blender Foundation\Blender\5.0\shaders\
        ```

        **macOS:**

        ```
        /Users/$USER/Library/Application Support/Blender/5.0/shaders/
        ```
user: Describe USERPREF_UL_extension_repos(UIList) from the Blender manual or Python API, including usage steps and snippets.

assistant: # USERPREF_UL_extension_repos(UIList)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`UIList`](bpy.types.UIList.html#bpy.types.UIList "bpy.types.UIList")

*class* bpy.types.USERPREF_UL_extension_repos(*UIList*)
:   draw_item(*_context*, *layout*, *_data*, *item*, *icon*, *_active_data*, *_active_propname*, *_index*)

    filter_items(*_context*, *data*, *propname*)

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Physical Properties: syntax, arguments, return values, common patterns.

assistant: # Physical Properties

Vertex Mass
:   The mass of the cloth material.

Air Viscosity
:   Air has some thickness which slows falling things down.

Bending Model
:   Linear:
    :   Cloth model with linear bending springs (old).

    Angular:
    :   Cloth model with angular bending springs.
user: Give a detailed overview of Sidebar: syntax, arguments, return values, common patterns.

assistant: # Sidebar

The Sidebar can be toggled with the menu item View ‣ Sidebar
or with the shortcut `N`.

The image below shows two Video Sequencers, one in Preview mode and one in Sequencer mode,
both with their Sidebar open.

[image reference removed]
user: What is Concept and how is it used in Blender Python scripting?

assistant: When an image is convolved with a kernel, the kernel is centered over each pixel in the image.
Each pixel in the neighborhood is multiplied by the corresponding kernel value, and the results
are summed to form the output pixel color.
The process repeats for every pixel in the image.

The kernel values can be positive, negative, or fractional,
and their pattern determines the effect produced.
user: Give a detailed overview of SDF Grid Offset Node: syntax, arguments, return values, common patterns.

assistant: # SDF Grid Offset Node

[image reference removed]

The *SDF Grid Offset* node offsets the surface of a Signed Distance Field (SDF)
by a specified world-space distance.
This operation effectively dilates (expands) or erodes (contracts) the
surface while maintaining the correct signed distance values across the field.

A positive offset increases the surface thickness by pushing it outward,
while a negative offset shrinks it inward. This is a fundamental operation in
volumetric modeling, useful for adjusting wall thickness, creating shells,
expanding collision volumes, or controlling blend margins between shapes.
user: Describe NodeTreeInterfaceSocketVectorTranslation(NodeTreeInterfaceSocket) from the Blender manual or Python API, including usage steps and snippets.

assistant: # NodeTreeInterfaceSocketVectorTranslation(NodeTreeInterfaceSocket)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`NodeTreeInterfaceItem`](bpy.types.NodeTreeInterfaceItem.html#bpy.types.NodeTreeInterfaceItem "bpy.types.NodeTreeInterfaceItem"), [`NodeTreeInterfaceSocket`](bpy.types.NodeTreeInterfaceSocket.html#bpy.types.NodeTreeInterfaceSocket "bpy.types.NodeTreeInterfaceSocket")

*class* bpy.types.NodeTreeInterfaceSocketVectorTranslation(*NodeTreeInterfaceSocket*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

        Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], default (0.0, 0.0, 0.0)

    dimensions
    :   Dimensions of the vector socket

        Type:
        :   int in [2, 4], default 0

    max_value
    :   Maximum value

        Type:
        :   float in [-inf, inf], default 0.0

    min_value
    :   Minimum value

        Type:
        :   float in [-inf, inf], default 0.0

    subtype
    :   Subtype of the default value

        Type:
        :   enum in [`'DEFAULT'`], default `'DEFAULT'`

    draw(*context*, *layout*)
    :   Draw interface socket settings

        Parameters:
        :   **layout** ([`UILayout`](bpy.types.UILayout.html#bpy.types.UILayout "bpy.types.UILayout"), (never None)) – Layout, Layout in the UI

    init_socket(*node*, *socket*, *data_path*)
    :   Initialize a node socket instance

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the socket to initialize
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Socket to initialize
            - **data_path** (*string**,* *(**never None**)*) – Data Path, Path to specialized socket data

    from_socket(*node*, *socket*)
    :   Setup template parameters from an existing socket

        Parameters:
        :   - **node** ([`Node`](bpy.types.Node.html#bpy.types.Node "bpy.types.Node"), (never None)) – Node, Node of the original socket
            - **socket** ([`NodeSocket`](bpy.types.NodeSocket.html#bpy.types.NodeSocket "bpy.types.NodeSocket"), (never None)) – Socket, Original socket

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: Auto-Velocity Emitter
:   Recalculate velocities of particles according to their edited paths.
    Otherwise, the original velocities values remains unchanged
    regardless of the actual distance that the particles moves.

Mirror X
:   Enable mirror editing across the local X axis.

Preserve
:   Strand Length
    :   Keep the length of the segments between the keypoints when combing or smoothing the hair.
        This is done by moving all the other keypoints.

    Root Positions
    :   Keep first key unmodified, so you cannot transplant hair.

### Cut Particles to Shape

Shape Object
:   A mesh object which boundary is used by the *Shape Cut* tool.

Cut
:   This grooming tool trims hairs to a shape defined by the *Shape Object*.
    This is a quicker way of avoiding protruding hair sections from lengthening than using the Cutting tool.
    It works especially well for characters with extensive fur,
    where working in a single plane with the Cutting tool becomes tedious.

Shape Cut example.

|  |  |
| --- | --- |
| ../../_images/physics_particles_mode_shapecut-before.png   Before. | ../../_images/physics_particles_mode_shapecut-after.png   After. |

### Viewport Display

Path Steps
:   The number of steps used to draw the path; improves the smoothness of the particle path.

Children Hair
:   Displays the children of the particles too.
    This allows to fine-tune the particles and see their effects on the result,
    but it may slow down your system if you have many children.

Particles Emitter
:   Displays the actual particles on top of the paths.

Fade Time
:   Fade out paths and keys further away from current time.

    Frames
    :   How many frames to fade.
user: What is Film and how is it used in Blender Python scripting?

assistant: # Film

Filter Size
:   Due to limited resolution of images and computer screens, pixel filters are needed to avoid [Aliasing](../../../glossary/index.xhtml#term-Aliasing).
    This is achieved by slightly blurring the image to soften edges.

    This Setting controls how much the image is softened;
    lower values give more crisp renders, higher values are softer and reduce aliasing.

Transparent
:   Render the background transparent, for compositing the image over another background after rendering.

Overscan
:   Percentage of the render size to add to the internal render buffer.
    This will have a serious impact on performance but can fix
    render glitches around the perimeter of the rendered image.
user: Explain Image Overlays in complete detail according to the official Blender documentation.

assistant: # Image Overlays

The Overlays pop-over configures the overlays that are displayed on top of images.
In the header, there is a button to turn off all overlays for the Image Editor.
This option also toggles the visibility of [UDIM](../../modeling/meshes/uv/workflows/udims.xhtml)
tile information.

The options that are visible in the pop-over depend on the Image Editor mode.
The following overlay categories are available:
user: What is Transform Pivot Full Items and how is it used in Blender Python scripting?

assistant: # Transform Pivot Full Items

BOUNDING_BOX_CENTER:
:   Bounding Box Center.

    Pivot around bounding box center of selected object(s).

CURSOR:
:   3D Cursor.

    Pivot around the 3D cursor.

INDIVIDUAL_ORIGINS:
:   Individual Origins.

    Pivot around each object’s own origin.

MEDIAN_POINT:
:   Median Point.

    Pivot around the median point of selected objects.

ACTIVE_ELEMENT:
:   Active Element.

    Pivot around active object.
user: Show practical ways to work with CopyScaleConstraint(Constraint) in a Blender add-on or script – include code.

assistant: # CopyScaleConstraint(Constraint)

base classes — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct"), [`Constraint`](bpy.types.Constraint.html#bpy.types.Constraint "bpy.types.Constraint")

*class* bpy.types.CopyScaleConstraint(*Constraint*)
:   Copy the scale of the target

    power
    :   Raise the target’s scale to the specified power

        Type:
        :   float in [-inf, inf], default 1.0

    subtarget
    :   Armature bone, mesh or lattice vertex group, …

        Type:
        :   string, default “”, (never None)

    target
    :   Target object

        Type:
        :   [`Object`](bpy.types.Object.html#bpy.types.Object "bpy.types.Object")

    use_add
    :   Use addition instead of multiplication to combine scale (2.7 compatibility)

        Type:
        :   boolean, default False

    use_make_uniform
    :   Redistribute the copied change in volume equally between the three axes of the owner

        Type:
        :   boolean, default False

    use_offset
    :   Combine original scale with copied scale

        Type:
        :   boolean, default False

    use_x
    :   Copy the target’s X scale

        Type:
        :   boolean, default False

    use_y
    :   Copy the target’s Y scale

        Type:
        :   boolean, default False

    use_z
    :   Copy the target’s Z scale

        Type:
        :   boolean, default False

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Provide the full official documentation entry for Pose, preserving all code examples.

assistant: # Pose

Deform a model simulating armature-like workflow.
This can either be useful for posing a model without a rig,
adjusting the proportions of a mesh or other fast deformations.

The brush will automatically determine an origin point,
indicated with a while line on the brush cursor.

If the [Deformation Target](../../brush/brush_settings.xhtml#bpy-types-brush-deform-target)
is changed, the brush can also be used for cloth sculpting.
user: Describe Brush Settings from the Blender manual or Python API, including usage steps and snippets.

assistant: # Brush Settings

Material
:   Data-block selector for the [material](../../../materials/index.html).
    Except for the *Erase* tool of course.

    / Pin Material
    :   Pin the material to the brush.

        The final appearance of the strokes is a combination of the brush and material used,
        binding the material to the brush gives more control and avoids a lack of coordination between the two.
user: How do I use 403 Error Accessing Extensions in Blender? Include parameters, examples, warnings and best practices.

assistant: On systems or networks that use an additional layer of SSL management:
it’s possible Blender’s connection to `https://extensions.blender.org` is blocked.

In this case the problem can’t be resolved in Blender’s side,
it’s up the system administrators to allow a connection to `extensions.blender.org`.

See: [this report](https://projects.blender.org/blender/blender/issues/129681).
user: How do I use FloatColorAttributeValue(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # FloatColorAttributeValue(bpy_struct)

base class — [`bpy_struct`](bpy.types.bpy_struct.html#bpy.types.bpy_struct "bpy.types.bpy_struct")

*class* bpy.types.FloatColorAttributeValue(*bpy_struct*)
:   Color value in geometry attribute

    color
    :   RGBA color in scene linear color space

        Type:
        :   float array of 4 items in [0, inf], default (0.0, 0.0, 0.0, 0.0)

    color_srgb
    :   RGBA color in sRGB color space

        Type:
        :   float array of 4 items in [0, inf], default (0.0, 0.0, 0.0, 0.0)

    *classmethod* bl_rna_get_subclass(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The RNA type or default when not found.

        Return type:
        :   [`bpy.types.Struct`](bpy.types.Struct.html#bpy.types.Struct "bpy.types.Struct") subclass

    *classmethod* bl_rna_get_subclass_py(*id*, *default=None*, */*)
    :   Parameters:
        :   **id** (*str*) – The RNA type identifier.

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: How do I use UV Warp Modifier in Blender? Include parameters, examples, warnings and best practices.

assistant: # UV Warp Modifier

The *UV Warp* modifier transforms an object’s UV map based on values or two objects.
Its purpose is to give you direct control over the object’s UVs in the 3D Viewport,
allowing you to directly move, rotate, and scale existing UV coordinates
using defined values or a controller object or bone.
user: Provide the full official documentation entry for Outputs, preserving all code examples.

assistant: Factor
:   When the node is used on the point domain, the value is the portion of the spline’s
    total length at each control point. On the spline domain it is the portion of the
    curve’s total length at the start of the spline.

Length
:   When the node is used on the point domain, the value is the distance along the spline to each
    control point. On the spline domain it is the length along the entire curve at the start
    of the spline.

Index
:   Each control point’s index on its spline. This is different from the output of the
    [index node](../../geometry/read/input_index.xhtml), which also counts the
    control points in all previous splines.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Value
:   The value of the input *Value* at the sample point.

Position
:   The position at the sample along the spline.

Tangent
:   The normalized [curve tangent](../read/curve_tangent.xhtml) at the sample.

Normal
:   The normalized [curve normal](../../geometry/read/normal.xhtml) at the sample.
user: Show practical ways to work with Help Menu in a Blender add-on or script – include code.

assistant: ### Web Links

The first options of this menu provide direct links to Blender-related websites. The same links can also be found in
the [Splash Screen](../interface/window_system/splash.xhtml#splash).

[Manual](../index.xhtml)
:   This is a link to the Official Blender Manual (which you are now reading).

[Support](https://www.blender.org/support)
:   Links to various sites, providing both community and professional support.

[User Communities](https://www.blender.org/community/)
:   Lists of many different community sites and support venues.

[Get Involved](https://www.blender.org/get-involved)
:   Learn how to give back to the Blender community by contributing to projects or donating.

[Release Notes](https://developer.blender.org/docs/release_notes/)
:   Link to the release notes for the current Blender version.

---

[Report a Bug](https://projects.blender.org/blender/blender/issues/new?template=.gitea%2fissue_template%2fbug.yaml)
:   The Blender Bug Tracker (registration needed). For more information on bug reporting, please see
    [Reporting a Bug](../troubleshooting/report_bug.xhtml).

### Save System Info

This extracts system information which can be useful for including in bug reports, inspecting the configuration, or
diagnosing problems.

You will be prompted to save a text file called `system-info.txt`.

It contains the following sections:

Blender
:   This section shows you the Blender version, details about the build configuration, and the path in which Blender is
    running.

Python
:   The version and path of your Python installation.

Directories
:   Paths used for scripts, data files, presets and temporary files.

    Those directories are configured using the [Preferences](../editors/preferences/file_paths.xhtml) Editor.

FFmpeg
:   The version of the installed FFmpeg components and codecs.

Other Libraries
:   The version of other libraries used by Blender such as OpenColorIO, Alembic, USD, etc.

GPU
:   Shows the GPU vendor, version and the capabilities of your hardware and driver.

Implementation Dependent GPU Limits
:   Specific limits on GPU functions related to how the current version of Blender was compiled.

Cycles
:   The instruction sets and capabilities of each hardware render device available for use with Cycles.

Enabled Add-Ons
:   Lists add-ons currently in use along with their versions and paths.
user: What is View Layer Attribute Lookup and how is it used in Blender Python scripting?

assistant: The material [Attribute Node](../../render/shader_nodes/input/attribute.xhtml) in the View Layer mode
automatically searches for the attribute property in multiple locations. This, for example, can allow
setting a certain value of the custom attribute at the [Scene](../../scene_layout/scene/introduction.xhtml)
or [World](../../render/lights/world.xhtml) level, and then overriding it
differently for one [View Layer](../../render/layers/introduction.xhtml).

[image reference removed]

Context Properties of drivers don’t implement this behavior, so if necessary it has to be manually
emulated via fallback values and a conditional expression (conditions are
[Simple Expressions](drivers_panel.xhtml#drivers-simple-expressions)).

For an attribute named `attr`, the node tries the following six RNA path lookups in order:

- `["attr"]` in the active View Layer (custom property).
- `attr` in the active View Layer (built-in property).
- `["attr"]` in the active Scene.
- `attr` in the active Scene.
- `world["attr"]` in the active Scene.
- `world.attr` in the active Scene.

Depending on the specific property it may be sufficient to check only a subset of these locations.
For example, the image on the right shows how to access an attribute that is known to definitely be
a custom property with a color value.

Driver variables accessing locations that are not final in the lookup chain should use fallback values that are
invalid for the attribute (e.g. negative color values), which can then be checked by the conditional expression.
The final variable should fallback to a valid default value to be used when the property is not set at all.
user: Provide the full official documentation entry for Absolute Shape Keys, preserving all code examples.

assistant: [[image reference removed]](../../_images/animation_shape-keys_shape-keys-panel_absolute.png)

Absolute Shape Keys options.

See [Relative or Absolute Shape Keys](introduction.html#animation-shapekeys-relative-vs-absolute).

With absolute shape keys, the value shown for each shape in the list represents
the *Evaluation Time* at which that shape key will be active.

Re-Time Shape Keys (clock icon)
:   Absolute shape keys are timed, by order in the list, at a constant interval.
    This button resets the timing for the keys. Useful if keys were removed or re-ordered.

Interpolation
:   Controls the interpolation between shape keys.

    Linear, Cardinal, Catmull-Rom, B-Spline

    [image reference removed]

    Different types of interpolation.

    The red line represents interpolated values between keys (black dots).

Evaluation Time
:   Controls the shape key influence. Scrub to see the effect of the current configuration.
    Typically, this property is keyed for animation or rigged with a driver.
user: How do I use Gabor Texture Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Gabor Texture Node

[image reference removed]

The *Gabor Texture* node evaluates a Gabor noise at the input texture coordinates. Gabor noise is
visually characterized by random interleaved bands whose direction and width can be controlled.
Additionally, it can be used to create omnidirectional noise like the standard Noise Texture node,
but since it is more expensive to compute, using the Noise Texture node is probably the better
option in those cases. See the examples for more information.
user: How do I use Cycles Render Devices in Blender? Include parameters, examples, warnings and best practices.

assistant: Changes the [Computing Device](../../render/cycles/render_settings/index.xhtml#bpy-types-cyclesrendersettings-device)
the [Cycles](../../render/cycles/index.xhtml) render engine uses to render images.
Cycles can use either the CPU or certain GPUs to render images,
for more information see the [GPU Rendering](../../render/cycles/gpu_rendering.xhtml) page.

None:
:   When set to *None* or when the only option is *None*:
    the CPU will be used as the computing device for Cycles.

CUDA:
:   If the system has a compatible NVIDIA CUDA device, it will be available as an option for rendering with Cycles.

OptiX:
:   If the system has a compatible NVIDIA OptiX device, it will be available as an option for rendering with Cycles.

HIP:
:   If the system has a compatible AMD HIP device, it will be available as an option for rendering with Cycles.

oneAPI:
:   If the system has a compatible Intel oneAPI device, it will be available as an option for rendering with Cycles.

Metal:
:   If the system has a compatible Apple Metal device, it will be available as an option for rendering with Cycles.

Distribute Memory Across Devices
:   Allocates resources across multiple GPUs rather than duplicating data,
    effectively freeing up space for larger scenes. Note that in order for this option to be available,
    the GPUs must be connected together with a high bandwidth communication protocol.

    Currently only NVLink on NVIDIA GPUs is supported.

Embree on GPU
:   Enables the use of hardware ray tracing on Intel GPUs, providing better overall performance.

    Only supported with oneAPI rendering devices.

HIP RT
:   Speeds up rendering by enabling AMD hardware ray tracing on RDNA2 and above.

    This feature is only available when using a *HIP* render device.

MetalRT
:   MetalRT for ray tracing uses less memory for scenes which use curves extensively,
    and can give better performance in specific cases.

    Off:
    :   Disable MetalRT (uses BVH2 layout for intersection queries).

    On:
    :   Enable MetalRT for intersection queries.

    Auto:
    :   Automatically pick the fastest intersection method.
user: How do I use Subdivide in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Subdivide* operator adds new control points to selected curve segments by dividing them into smaller sections.
This is useful for creating smoother transitions, preparing curves for finer adjustments,
or adding more detail for animation or modeling.

Number of Cuts
:   Specifies the number of divisions for each selected segment; each cut adds one new control point per segment.
user: How do I use Cache Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: This panel allows configuration of how and when image data is cached during editing.
These settings apply globally to all strips in the Video Sequence Editor.

Prefetch Frames
:   When enabled, Blender will automatically prefetch and cache frames after the current frame
    in the background. This can result in smoother playback performance.

    Note: prefetching is not currently supported for Scene strips.

Cache
:   Raw
    :   Caches raw image data immediately after it is read from disk.
        This speeds up adjustments to strip parameters such as color correction,
        but increases memory usage.

    Final
    :   Caches the final composited image for each frame,
        allowing faster playback of fully processed strips.

### Display

Visual indicators in the Timeline showing which frames are cached.

Cache
:   Raw
    :   Displays a red bar in the Timeline below frames cached in their raw state.

    Final
    :   Displays a blue bar at the top of Timeline for frames cached in their final composited state.

A readout at the bottom of the panel shows real-time statistics about cache usage:

- **Current Cache Size**: Total amount of memory currently used by the cache system.
- **Raw**: Memory usage by raw image cache.
- **Final**: Memory usage by final rendered frame cache.
user: Describe Named Attributes Overlay from the Blender manual or Python API, including usage steps and snippets.

assistant: The “Named Attributes” overlay allows displaying when a custom named attribute is used
by a node or a node group. Named attributes can be used by the
[Capture Attribute Node](attribute/capture_attribute.html), the
[Named Attribute Node](geometry/read/named_attribute.html), and the
[Remove Named Attribute Node](attribute/remove_named_attribute.html),
and can be written to, read, or removed.

Using named attributes (as opposed to [Anonymous Attributes](attributes_reference.html#anonymous-attributes)) can be problematic
when the original geometry already has attributes with the specified names. In that case
a geometry node group might mistakenly overwrite some essential data. The overlay helps
to make detecting that situation easy.

The same data is also available in the [Named Attributes](../modifiers/geometry_nodes.html#modifiers-geometry-nodes-named-attributes) panel
in the modifier’s UI.