PGCRYPT/OpenBlender_Train huggingface dataset:
user: Give a detailed overview of Wayland: syntax, arguments, return values, common patterns.

assistant: Support for Wayland is a more recent addition, so there may be configurations that have not been tested yet. Please
[report a bug](../../troubleshooting/report_bug.xhtml) if you experience problems.

Blender has been tested with Gnome-Shell (mutter), KDE (plasma) & SWAY (wlroots) based compositors.

### Requirements

Gnome-Shell
:   Under Gnome-Shell the `libdecor` library is required. This is available as a package on most Linux distribution.

    If the library isn’t found X11 will be used as a fallback.

### Troubleshooting

Detailed Wayland output can help to track down problems. Launch Blender from the
[command-line](../../advanced/command_line/launch/linux.xhtml) with additional arguments:

Blender’s Wayland Logging
:   ```
    blender --log "ghost.wl.*" --log-level 2
    ```

Wayland Built-In Logging
:   ```
    WAYLAND_DEBUG=1 blender
    ```

Disable Wayland (forcing X11)
:   ```
    WAYLAND_DISPLAY="" blender
    ```

Disable `libdecor` (forcing borderless windows under Gnome-Shell)
:   Uninstall `libdecor`, then run Blender with an empty X11 display variable.

    ```
    DISPLAY="" blender
    ```

### Environment Variables

`XCURSOR_THEME`
:   The cursor theme to use (must refer to a locally installed cursor).

`XCURSOR_SIZE`
:   The cursor size, defaults to 28, you may wish to increase the size on Hi-DPI displays.

### Known Limitations

Gnome Shell’s Fractional Scaling (before version 44)
:   Versions of Gnome-Shell prior to 44 don’t fully support fractional scaling.

    Using fractional under older versions of Gnome-Shell may result in glitches such as a [small cursor size](https://projects.blender.org/blender/blender/issues/105895).

NVIDIA GPU
:   Currently NVIDIA drivers don’t fully support features needed for Wayland. Graphical glitches and flickering are
    common problems. In some cases, there can be [crashes on startup](https://projects.blender.org/blender/blender/issues/103999). This is not specific to Blender, so NVIDIA users
    may want to use X11 until driver support improves.

---
user: Give a detailed overview of Animation: syntax, arguments, return values, common patterns.

assistant: # Animation

The *Animation* section lets you manage settings related to [Animation](../../animation/index.xhtml).
This includes how editors look and also some different tools properties.

[image reference removed]

Blender Preferences Animation section.
user: Show practical ways to work with Multiframe in a Blender add-on or script – include code.

assistant: # Multiframe

[image reference removed]

Multiframe pop-over.

Multiframe allows you to draw, edit, sculpt, or weight painting on several frames at the same time.
Extremely useful to avoid repeating a task one frame at a time when animating.

Use Falloff
:   When enabled, the effects on the strokes start to falloff from the current frame
    as defined by a [curve widget](../interface/controls/templates/curve.xhtml).
user: Describe Beztriple Interpolation Easing Items from the Blender manual or Python API, including usage steps and snippets.

assistant: # Beztriple Interpolation Easing Items

AUTO:
:   Automatic Easing.

    Easing type is chosen automatically based on what the type of interpolation used (e.g. Ease In for transitional types, and Ease Out for dynamic effects).

EASE_IN:
:   Ease In.

    Only on the end closest to the next keyframe.

EASE_OUT:
:   Ease Out.

    Only on the end closest to the first keyframe.

EASE_IN_OUT:
:   Ease In and Out.

    Segment between both keyframes.
user: Show practical ways to work with Flow in a Blender add-on or script – include code.

assistant: # Flow

Fluid *Flow* types are used to add or remove fluid to a domain object. Flow objects should be
contained within the domain’s [Bounding Box](../../../glossary/index.html#term-Bounding-Box) in order to work.

To define any mesh object as a *Flow* object, add Fluid physics by clicking *Fluid* in
Properties ‣ Physics. Then select *Flow* as the fluid *Type*. Now you should have
a default fluid flow source object.
user: Give a detailed overview of Field to Grid Node: syntax, arguments, return values, common patterns.

assistant: # Field to Grid Node

[image reference removed]

The *Field to Grid* node creates one or more new voxel grids by evaluating
geometry fields on the topology of an existing grid.
This allows generating new volumetric data (such as density, temperature,
velocity, or distance fields) directly from field inputs defined in the node
tree.

Each input field is sampled at the voxel positions of the provided topology
grid, producing a corresponding output grid that matches the same resolution,
transform, and domain.
This enables consistent evaluation of multiple attributes or procedural
quantities across the same volume structure.
user: Show practical ways to work with Bone Properties in a Blender add-on or script – include code.

assistant: # Bone Properties

When bones are selected (hence in *Edit Mode* and *Pose Mode*), their
properties are shown in the *Bone* tab of the Properties.
This shows different panels used to control features of each selected bone;
the panels change depending on which mode you are working in.
user: Describe Relations from the Blender manual or Python API, including usage steps and snippets.

assistant: # Relations

Parent
:   The object to which the selected object is parented to.

Parent Type
:   The type of parenting used. See [parenting](../editing/parent.xhtml)
    for information on the different types.

Use Final Indices Vertex 3 Vertices
:   Use the final evaluated indices rather than the original mesh indices.

Camera Parent Lock
:   When the camera is locked to the view, the root parent is transformed rather than the camera.
    This is useful for camera rigs where you don’t want to animate the camera directly.

Parent Vertex/Vertices
:   Indices of vertices in case of a vertex parenting relation.

Tracking Axis
:   Axis that points in the “forward” direction.
    Applies to *Instance Vertices* when *Align to Vertex Normal* is enabled.

Up Axis
:   Axis that points in the “upward” direction.
    Applies to *Instance Vertices* when *Align to Vertex Normal* is enabled.

Pass Index
:   Defines the index the object will have in the Object Index render pass. See [passes](../../../render/layers/passes.xhtml)
    and [ID mask](../../../compositing/types/mask/id_mask.xhtml) for more information.
user: How do I use GeometryNodeSetCurveNormal(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeSetCurveNormal(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.GeometryNodeSetCurveNormal(*GeometryNode*)
:   Set the evaluation mode for curve normals

    *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: What is CompositorNodeImageInfo(CompositorNode) and how is it used in Blender Python scripting?

assistant: # CompositorNodeImageInfo(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.CompositorNodeImageInfo(*CompositorNode*)
:   Returns information about an 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: Provide the full official documentation entry for Cloth Filter, preserving all code examples.

assistant: # Cloth Filter

This tool works similar to the [Cloth Brush](../brushes/cloth.xhtml),
however, it applies a cloth simulation to all vertices in the mesh at the same time.
Click and drag away from the object for a positive effect and towards for a negative effect.
user: Show practical ways to work with Header in a Blender add-on or script – include code.

assistant: See [Nodes](../../interface/controls/nodes/index.xhtml) for the header items common to
all node editors.

Texture Type
:   World
    :   Deprecated – the scene’s [World Environment](../../render/lights/world.xhtml) is now defined using
        a Material rather than a Texture.

    Brush
    :   Show brush Textures in the data-block menu. Because the other two types are deprecated,
        this effectively shows all Textures.

    Line Style
    :   Deprecated – [Line Styles](../../render/freestyle/view_layer/line_style/index.xhtml)
        for the Freestyle renderer are now defined using Materials rather than Textures.
user: How do I use Geometry Node Editor in Blender? Include parameters, examples, warnings and best practices.

assistant: # Geometry Node Editor

The Geometry Node editor is used to edit [Node Groups](../interface/controls/nodes/groups.html)
which are used by the [Geometry Node Modifier](../modeling/modifiers/geometry_nodes.html).
Such a node group can define many operations to modify an object’s geometry.

A list of all [Geometry Nodes](../modeling/geometry_nodes/index.html) is available in the modeling section.
Also see the [Nodes](../interface/controls/nodes/index.html) page for information on working with
nodes in general.
user: How do I use Camera Data Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Camera Data Node

[image reference removed]

The *Camera Data* node returns information about the shading point relative to the camera.
This could be used for example to change the shading
of objects further away from the camera, or make custom fog effects.
user: What is Strokes Location & Orientation Controls and how is it used in Blender Python scripting?

assistant: Drawing in a 3D space is not the same as drawing on a flat canvas.
When drawing with Grease Pencil you have to define
the location and orientation of the new strokes in the 3D space.

[image reference removed]

3D Viewport header Controls for strokes.

### Stroke Placement

The Stroke Placement selector defines the new strokes location in 3D space.

See [Stroke Placement](stroke_placement.xhtml) for more information.

### Drawing Planes

The Drawing Planes selector defines the plane (orientation) to which the new strokes will be restricted.

See [Drawing Planes](drawing_planes.xhtml) for more information.
user: How do I use Example in Blender? Include parameters, examples, warnings and best practices.

assistant: Fixed Mode sample.

|  |  |  |  |
| --- | --- | --- | --- |
| ../../../_images/grease-pencil_modifiers_generate_simplify_fixed-iterations-0.png   Original Model. | ../../../_images/grease-pencil_modifiers_generate_simplify_fixed-iterations-1.png   Iteration: 1. | ../../../_images/grease-pencil_modifiers_generate_simplify_fixed-iterations-2.png   Iteration: 2. | ../../../_images/grease-pencil_modifiers_generate_simplify_fixed-iterations-3.png   Iteration: 3. |

Adaptive Mode sample.

|  |  |  |  |
| --- | --- | --- | --- |
| ../../../_images/grease-pencil_modifiers_generate_simplify_adaptive-factor-0.png   Original Model. | ../../../_images/grease-pencil_modifiers_generate_simplify_adaptive-factor-01.png   Factor: 0.1. | ../../../_images/grease-pencil_modifiers_generate_simplify_adaptive-factor-02.png   Factor: 0.5. | ../../../_images/grease-pencil_modifiers_generate_simplify_adaptive-factor-05.png   Factor: 1. |
user: What is Examples and how is it used in Blender Python scripting?

assistant: |  |  |  |
| --- | --- | --- |
| ../../../../_images/modeling_meshes_editing_edge_bevel_example-5.png   Result of beveling multiple edges. | ../../../../_images/modeling_meshes_editing_edge_bevel_example-6.png   Another example of beveling multiple edges. | ../../../../_images/modeling_meshes_editing_edge_bevel_example-7.png   An example using Profile=0.150. |
user: How do I use FunctionNodeRotateRotation(FunctionNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # FunctionNodeRotateRotation(FunctionNode)

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"), [`FunctionNode`](bpy.types.FunctionNode.html#bpy.types.FunctionNode "bpy.types.FunctionNode")

*class* bpy.types.FunctionNodeRotateRotation(*FunctionNode*)
:   Apply a secondary rotation to a given rotation value

    rotation_space
    :   Base orientation for the rotation

        - `GLOBAL`
          Global – Rotate the input rotation in global space.
        - `LOCAL`
          Local – Rotate the input rotation in its local space.

        Type:
        :   enum in [`'GLOBAL'`, `'LOCAL'`], default `'GLOBAL'`

    *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: Give a detailed overview of Operators: syntax, arguments, return values, common patterns.

assistant: There are several transformation operations included in Blender.
Here are some of the main operations available:

### Move

This operations allows you to move elements along the X, Y, and Z axes in the scene.

### Rotate

You can use this function to rotate elements around the X, Y, and Z axes.

### Scale

Scaling allows you to increase or decrease the size of an object along the X, Y, and Z axes.

### Align to View

This is useful for aligning objects with the view from the camera or another specific viewpoint.

### Mirror

Mirrors objects along one or more axes.
user: How do I use Properties in Blender? Include parameters, examples, warnings and best practices.

assistant: Clamp Type
:   Method to clamp.

    Min Max:
    :   Constrain values between Min and Max.

    Range:
    :   Constrain values between Min and Max. When Min is greater than Max,
        constrain between Max and Min instead.
user: Explain Set Spline Type in complete detail according to the official Blender documentation.

assistant: Converts splines in a curve object between Bézier, NURBS, Poly, and Catmull Rom types.
This is a basic conversion, meaning Blender does not preserve the exact shape or the number of control points.
For example, converting a NURBS spline to a Bézier spline maps each group of three NURBS control points
to a single Bézier control point with two handles.

Type
:   Specifies the target spline type. For more details on spline types, see the
    [Spline Types](../structure.xhtml#curve-spline-types) documentation.

    Bézier:
    :   Converts the spline to a Bézier type.
        - Poly splines are converted with vector handles.
        - NURBS or Catmull Rom splines are converted with automatic handles.

    NURBS:
    :   Converts the spline to a NURBS type.

    Poly:
    :   Converts the spline to a poly type.

Handles
:   Includes handle information during the conversion process.
user: Provide the full official documentation entry for Edit Driver, preserving all code examples.

assistant: Displays a popover window that allows editing the custom expression and input variables
of the driver without opening the full *Drivers Editor*.

Many drivers don’t use their [F-Curve](../../editors/graph_editor/fcurves/introduction.xhtml)
component, so this reduced interface is sufficient.
user: How do I use DecimateModifier(Modifier) in Blender? Include parameters, examples, warnings and best practices.

assistant: # DecimateModifier(Modifier)

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

*class* bpy.types.DecimateModifier(*Modifier*)
:   Decimation modifier

    angle_limit
    :   Only dissolve angles below this (planar only)

        Type:
        :   float in [0, 3.14159], default 0.0872665

    decimate_type
    :   - `COLLAPSE`
          Collapse – Use edge collapsing.
        - `UNSUBDIV`
          Un-Subdivide – Use un-subdivide face reduction.
        - `DISSOLVE`
          Planar – Dissolve geometry to form planar polygons.

        Type:
        :   enum in [`'COLLAPSE'`, `'UNSUBDIV'`, `'DISSOLVE'`], default `'COLLAPSE'`

    delimit
    :   Limit merging geometry

        Type:
        :   enum set in [Mesh Delimit Mode Items](bpy_types_enum_items/mesh_delimit_mode_items.html#rna-enum-mesh-delimit-mode-items), default set()

    face_count
    :   The current number of faces in the decimated mesh

        Type:
        :   int in [-inf, inf], default 0, (readonly)

    invert_vertex_group
    :   Invert vertex group influence (collapse only)

        Type:
        :   boolean, default False

    iterations
    :   Number of times reduce the geometry (unsubdivide only)

        Type:
        :   int in [0, 32767], default 0

    ratio
    :   Ratio of triangles to reduce to (collapse only)

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

    symmetry_axis
    :   Axis of symmetry

        Type:
        :   enum in [Axis Xyz Items](bpy_types_enum_items/axis_xyz_items.html#rna-enum-axis-xyz-items), default `'X'`

    use_collapse_triangulate
    :   Keep triangulated faces resulting from decimation (collapse only)

        Type:
        :   boolean, default False

    use_dissolve_boundaries
    :   Dissolve all vertices in between face boundaries (planar only)

        Type:
        :   boolean, default False

    use_symmetry
    :   Maintain symmetry on an axis

        Type:
        :   boolean, default False

    vertex_group
    :   Vertex group name (collapse only)

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

    vertex_group_factor
    :   Vertex group strength

        Type:
        :   float in [0, 1000], default 1.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: Provide the full official documentation entry for Transfer Weights, preserving all code examples.

assistant: Copy weights from other objects to the vertex groups of the active object.

By default this tool copies only the active (selected) vertex group of the source object
to the active vertex group of target object or creates a new one if the group does not exist.
However, you can change the tool’s behavior in the [Adjust Last Operation](../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.

For example, to transfer all existing vertex groups from the source objects to the target,
change the *Source Layers Selection* option to *By Name*.

### Prepare the Copy

You first select all source objects, and finally the target object
(the target object must be the active object).

It is important that the source objects and the target object are at the same location.
If they are placed side-by-side, then the weight transfer will not work. (See the *Vertex Mapping* option.)
You can place the objects on different layers,
but you have to ensure that all objects are visible when you call the tool.

Now ensure that the target object is in Weight Paint Mode.
Open the Toolbar and call the *Transfer Weights* tool in the *Weight Tools* panel.

### Adjust Last Operation Panel Confusion

You may notice that the [Adjust Last Operation](../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel stays available
after the weight transfer is done. The panel only disappears
when you call another Operator that has its own [Adjust Last Operation](../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.
This can lead to confusion when you use Transfer weights repeatedly after you changed your vertex groups.
If you then use the still-visible [Adjust Last Operation](../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel,
then Blender will reset your work to its state right before you initially called the *Transfer Weights* tool.

So when you want to call the *Transfer Weights* tool again after you made some changes to your
vertex groups, then **always** use the *Transfer Weights* button,
even if the [Adjust Last Operation](../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel is still available.
Unless you really want to reset your changes to the initial call of the tool.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: The inputs of the node are dynamic. Some inputs are only available in certain operations.
For instance, the *Scale* input is only available in the *Scale* operator.

Vector
:   Input vector \(A = \begin{pmatrix} A_x \\ A_y \\ A_z \end{pmatrix}\).

Vector
:   Input vector \(B = \begin{pmatrix} B_x \\ B_y \\ B_z \end{pmatrix}\).

Scale
:   Input Scale \(s\).
user: What is Using an External Image Editor and how is it used in Blender Python scripting?

assistant: If you use an external program to edit your UV texture, you must:

1. Run that paint program (GIMP, Krita, etc.).
2. Load the image or create a new one.
3. Change the image.
4. And re-save it within that program.
5. Back in Blender, you reload the image in the Image Editor.

You want to use an external program if you have teams of people using different programs
that are developing the UV textures, or if you want to apply any special effects
that Texture Paint does not feature, or if you are much more familiar with
your favorite paint program.
user: How do I use Usage in Blender? Include parameters, examples, warnings and best practices.

assistant: The *Convolve* node can be used for a variety of image processing effects:

- **Blurring** – Use a kernel with evenly weighted positive values.
- **Sharpening** – Use a kernel with a high central value and negative surrounding values.
- **Edge Detection** – Use kernels such as Sobel or Laplacian to enhance image edges.
user: Explain Extrude Faces Along Normals in complete detail according to the official Blender documentation.

assistant: # Extrude Faces Along Normals

Extrusion and offset will be locked in to only move along the local normals of the selected mesh.

Flip Normals
:   Only the *normals* of the new faces created from the extrusion will be flipped.

Dissolve Orthogonal Edges
:   Removes and connects edges whose faces form a flat surface and intersect new edges.

Offset
:   Amount to move geometry along the normals.

Offset Even
:   The length of the new edges will be uniform.

Proportional Editing
:   The extruded face will affect nearby geometry.
    See [Proportional Editing](../../../../editors/3dview/controls/proportional_editing.html) for a full reference.
user: Provide the full official documentation entry for ThemePreferences(bpy_struct), preserving all code examples.

assistant: # ThemePreferences(bpy_struct)

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

*class* bpy.types.ThemePreferences(*bpy_struct*)
:   Theme settings for the Blender Preferences

    space
    :   Settings for space

        Type:
        :   [`ThemeSpaceGeneric`](bpy.types.ThemeSpaceGeneric.html#bpy.types.ThemeSpaceGeneric "bpy.types.ThemeSpaceGeneric"), (readonly, never None)

    *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 Bilateral Blur Node in a Blender add-on or script – include code.

assistant: # Bilateral Blur Node

[image reference removed]

The Bilateral Blur node performs a high-quality adaptive blur, blurring
the image while retaining sharp edges.

It can be used for various purposes like: smoothing noisy render passes to avoid longer computation times
in example ray-traced ambient occlusion, blurry refractions/reflections, soft shadows,
or to make non-photorealistic compositing effects.
user: Provide the full official documentation entry for NodeTreeInterfaceSocketVectorTranslation(NodeTreeInterfaceSocket), preserving all code examples.

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: Provide the full official documentation entry for KeyingSets(bpy_struct), preserving all code examples.

assistant: # KeyingSets(bpy_struct)

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

*class* bpy.types.KeyingSets(*bpy_struct*)
:   Scene keying sets

    active
    :   Active Keying Set used to insert/delete keyframes

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

    active_index
    :   Current Keying Set index (negative for ‘builtin’ and positive for ‘absolute’)

        Type:
        :   int in [-inf, inf], default 0

    new(*\**, *idname='KeyingSet'*, *name='KeyingSet'*)
    :   Add a new Keying Set to Scene

        Parameters:
        :   - **idname** (*string**,* *(**optional**,* *never None**)*) – IDName, Internal identifier of Keying Set
            - **name** (*string**,* *(**optional**,* *never None**)*) – Name, User visible name of Keying Set

        Returns:
        :   Newly created Keying Set

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

    *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 Fluid: syntax, arguments, return values, common patterns.

assistant: # Fluid

[image reference removed]

Fluid Physics settings.

Fluid particles are similar to Newtonian ones but this time particles are influenced by
internal forces like pressure, surface tension, viscosity, springs, etc.
From liquids to slime, goo to sand and wispy smoke the number of possible use cases is endless.

Blender particle fluids use the SPH techniques to solve the particles fluid equations.
Smoothed-particle hydrodynamics (SPH) is a computational method used for simulating fluid flows.
It has been used in many fields of research, including astrophysics, ballistics, vulcanology,
and oceanography. It is a mesh-free Lagrangian method (where the coordinates move with the fluid),
and the resolution of the method can easily be adjusted with respect to variables such as the density.
user: Give a detailed overview of Calling a File Selector: syntax, arguments, return values, common patterns.

assistant: This example shows how an operator can use the file selector.

Notice the invoke function calls a window manager method and returns
`{'RUNNING_MODAL'}`, this means the file selector stays open and the operator does not
exit immediately after invoke finishes.

The file selector runs the operator, calling [`Operator.execute`](#bpy.types.Operator.execute "bpy.types.Operator.execute") when the
user confirms.

The [`Operator.poll`](#bpy.types.Operator.poll "bpy.types.Operator.poll") function is optional, used to check if the operator
can run.

```
import bpy

class ExportSomeData(bpy.types.Operator):
    """Test exporter which just writes hello world"""
    bl_idname = "export.some_data"
    bl_label = "Export Some Data"

    filepath: bpy.props.StringProperty(subtype="FILE_PATH")

    @classmethod
    def poll(cls, context):
        return context.object is not None

    def execute(self, context):
        file = open(self.filepath, 'w')
        file.write("Hello World " + context.object.name)
        return {'FINISHED'}

    def invoke(self, context, event):
        context.window_manager.fileselect_add(self)
        return {'RUNNING_MODAL'}

# Only needed if you want to add into a dynamic menu.
def menu_func(self, context):
    self.layout.operator_context = 'INVOKE_DEFAULT'
    self.layout.operator(ExportSomeData.bl_idname, text="Text Export Operator")

# Register and add to the file selector (required to also use F3 search "Text Export Operator" for quick access).
bpy.utils.register_class(ExportSomeData)
bpy.types.TOPBAR_MT_file_export.append(menu_func)

# Test call.
bpy.ops.export.some_data('INVOKE_DEFAULT')
```
user: Provide the full official documentation entry for Visibility, preserving all code examples.

assistant: Mask – Shadow Catcher
:   Enables the object to only receive shadow rays. It is to be noted that,
    shadow catcher objects will interact with other CG objects via indirect light interaction.
    This simplifies compositing CGI elements into real-world footage.

    [image reference removed]

    Example of the shadow catcher. Note how the material of the plane can still be viewed in the spheres.

### Ray Visibility

Objects can be set to be invisible to particular ray types.
This can be used, for example, to make an emitting mesh invisible to camera rays.
For instanced objects, visibility is inherited; if the parent object is hidden for some ray types,
the children will be hidden for these too.

In terms of performance, using these options is more efficient that using a shader node setup
that achieves the same effect.
Objects invisible to a certain ray will be skipped in ray traversal already,
leading to fewer ray casts and shader executions.

Camera
:   Makes the object visible to the [Camera](../../cameras.xhtml);
    this includes the viewport’s perspective in viewport rendering.

Diffuse
:   Makes the object visible in diffuse rays.

Glossy
:   Makes the object visible in glossy rays.

Transmission
:   Makes the object visible in transmission rays.

Volume Scatter
:   Makes the object visible in volumetric scatter rays.

Shadow
:   Enables the object to cast shadows.

### Culling

In order to activate these options the respectively camera cull options have to be enabled
in the scene [simplify panel](../render_settings/simplify.xhtml#render-cycles-settings-scene-simplify-culling).

Use Camera Cull
:   Ignore and this way make objects invisible to rays outside of the camera frustum.

Use Distance Cull
:   Will cull any objects further from the camera than a given distance. When used in combination with
    camera frustum culling, this can be used to avoid culling nearby objects that are outside the camera frustum,
    but still visible in reflections. It is also useful to cull small objects far from the camera.
user: Show practical ways to work with Loop Cut in a Blender add-on or script – include code.

assistant: # Loop Cut

The *Loop Cut* tool is a modal tool version of the [Loop Cut and Slide](../editing/edge/loopcut_slide.xhtml#bpy-ops-mesh-loopcut-slide) operator.
This tool splits a loop of faces by inserting new edge loops intersecting the chosen edge.
user: Provide the full official documentation entry for Title, preserving all code examples.

assistant: The title shows the name/type of the node;
it can be overridden by changing the node’s [Label](node_editors.html#bpy-types-node-label).
On the left side of the title is the *collapse* toggle
which can be used to collapse the node. This can also be done with `H`.

[image reference removed]

How a node appears when collapsed.

### Preview

Previews are an overlay that shows a small image above the node displaying the node result.
Not all nodes support previews, but the ones that do can be toggled using
the / icons in the top right-hand corner of the node next to the title.

Previews can be disabled for the whole node tree by using
[Previews](node_editors.html#bpy-types-spacenodeoverlay-show-previews) overlay toggle.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Offset
:   Adds or subtracts a constant frame offset from the input sequence.
    Positive values delay the input, while negative values advance it.

Step
:   Skips frames by the specified step size.
    For example, a value of 2 plays every other frame, effectively doubling playback speed.

Speed
:   Scales time globally, controlling how fast or slow the sequence progresses.
    A value of 1.0 plays the sequence at normal speed, 0.5 at half speed, and 2.0 at double speed.

Cyclic
:   When enabled, the input sequence loops continuously when the retimed output exceeds
    its original frame range.

Cycle Length
:   Defines the number of frames in one loop cycle when *Cyclic* is enabled.
user: How do I use GeometryNodeEdgesToFaceGroups(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeEdgesToFaceGroups(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.GeometryNodeEdgesToFaceGroups(*GeometryNode*)
:   Group faces into regions surrounded by the selected boundary edges

    *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: How do I use ThemeSpaceGradient(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ThemeSpaceGradient(bpy_struct)

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

*class* bpy.types.ThemeSpaceGradient(*bpy_struct*)
:   gradients
    :   Type:
        :   [`ThemeGradientColors`](bpy.types.ThemeGradientColors.html#bpy.types.ThemeGradientColors "bpy.types.ThemeGradientColors"), (readonly, never None)

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

    header_text
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    header_text_hi
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    text
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    text_hi
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (0.0, 0.0, 0.0)

    title
    :   Type:
        :   [`mathutils.Color`](mathutils.html#mathutils.Color "mathutils.Color") of 3 items in [0, 1], default (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: Show practical ways to work with Shading in a Blender add-on or script – include code.

assistant: # Shading

Alternatively, you can choose which faces to smooth by entering *Edit Mode*,
then selecting some faces and picking *Shade Smooth* from the *Face Menu*.

When the mesh is in *Edit Mode*,
only the selected faces will receive the “smoothing” attribute.
You can set faces as flat (removing the “smoothing” attribute)
in the same way by selecting edges and picking the *Shade Flat* from the *Face Menu*.
user: Explain Split in complete detail according to the official Blender documentation.

assistant: Disconnects the selected sub grid from the rest of the surface, keeping it within
the same 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: What is Typical Scenarios for using Soft Bodies and how is it used in Blender Python scripting?

assistant: [[image reference removed]](../../_images/physics_soft-body_introduction_windcone.jpg)

The wind cone is a soft body, as the suspension.

[Animation](https://vimeo.com/1865817)

Soft bodies are well suited for:

- Jiggle on moving characters.
- Elastic and deformable objects made of materials like rubber or gelatin.
- Tree branches moving in the wind, swinging ropes, and the like.
- Flags, wide sleeves, cushions or other simple fabric reacting to forces.
user: What is Properties and how is it used in Blender Python scripting?

assistant: ### Format Items

A [list view](../../../../interface/controls/templates/list_view.html#ui-list-view). to manage the dynamic list of inputs used in the format string.
Each entry corresponds to a value that can be inserted into the format using a placeholder.
See [Input Naming Behavior](#input-naming-behavior) to understand how inputs must be named.

Socket Type
:   The type of value for this input:

    Float:
    :   A floating-point number (e.g. `3.14`).

    Integer:
    :   An integer number (e.g. `42`).

    String:
    :   A text string.
user: Provide the full official documentation entry for Attach Hair Curves to Surface, preserving all code examples.

assistant: # Attach Hair Curves to Surface

The *Attach Hair Curves to Surface* node binds hair curves to a surface mesh,
establishing their attachment positions and optionally aligning them to the
surface orientation.
This node is a fundamental part of hair generation and grooming workflows,
ensuring that curves remain anchored correctly to the underlying surface,
even after deformation or topology changes.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Grid
:   The input signed distance field to be smoothed.

Iterations
:   The number of Laplacian smoothing iterations to apply.
    Each iteration progressively diffuses high-frequency surface variations,
    reducing surface noise.
    Higher values increase smoothness but may cause slight surface shrinkage.