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

assistant: Blender supports different technologies to render on the GPU depending on the particular GPU manufacturer
and operating system.

### CUDA – NVIDIA

CUDA is supported on Windows and Linux and requires a
NVIDIA graphics cards with compute capability 5.0 and higher. To make sure your GPU is supported,
see the [list of NVIDIA graphics cards](https://developer.nvidia.com/cuda-gpus#compute)
with the compute capabilities and supported graphics cards.

### OptiX – NVIDIA

OptiX is supported on Windows and Linux and requires a NVIDIA graphics cards with compute capability 5.0 and higher
and a driver version of at least 535. To make sure your GPU is supported,
see the [list of NVIDIA graphics cards](https://developer.nvidia.com/cuda-gpus#compute).

OptiX takes advantage of hardware ray-tracing acceleration in RTX graphics cards, for improved performance.

GPU acceleration for OpenImageDenoise is available for compute capability 7.0 and higher, which includes
all NVIDIA RTX cards.

### HIP – AMD

HIP is supported on Windows and Linux and requires a
AMD graphics card with the RDNA1 architecture or newer. Both discrete GPUs and APUs are supported.

Supported GPUs include:

- Radeon RX 5000 Series
- Radeon RX 6000 Series
- Radeon RX 7000 Series
- Radeon RX 9000 series
- Radeon Pro W6000 Series
- Radeon Pro W7000 Series

Minimum driver versions:

- Windows: Radeon Software 24.9.1 or Radeon PRO Software 24.Q4
- Linux: Radeon Software 23.40 or ROCm 6.0

Please refer to [AMD’s website](https://www.amd.com/en/products/specifications.html) for more
information about AMD graphics cards and their architectures.

Hardware ray-tracing support is available with the most recent drivers.
This can be enabled in the preferences, and is supported on Radeon RX 6000 and newer.

GPU accelerated denoising is available on discrete Radeon RX 6000 and Radeon RX 7000 GPUs.

### oneAPI – Intel

oneAPI is a computation library that is supported on Windows and Linux and requires a
Intel® Arc™ graphics card with the Xe HPG architecture.
Hardware acceleration for ray-tracing and denoising is supported.

Supported GPUs include:

- Intel® Arc™ A-Series
- Intel® Arc™ B-Series

Minimum driver versions:

- Windows: Intel Graphics Driver XX.X.101.5518
- Linux: `intel-level-zero-gpu` package 1.3.27642,
  typically available through the `intel-compute-runtime` package XX.XX.34666.3

Please refer to [Intel’s website](https://www.intel.com/content/www/us/en/products/details/discrete-gpus.html)
for more information about Intel graphics cards and their architectures.

GPU accelerated denoising is available on all supported GPUs.

### Metal – Apple (macOS)

Metal is supported on Apple computers with Apple Silicon.
macOS 13.0 or newer is required to support all features.

GPU accelerated denoising is available on Apple Silicon.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: [image reference removed]

The UV Project modifier.

UV Map
:   Which UV map to modify. Defaults to the active rendering layer.

Aspect X/Y
:   Changes the image’s aspect ratio. Only apply when a camera is used as projector object.

Scale X/Y
:   Scales the image. Only apply when a camera is used as projector object.

Projectors
:   Up to ten projector objects are supported.
    Each face will choose the closest and aligned projector with its surface normal.
    Projections emit from the negative Z axis (i.e. straight down a camera or light).
    If the projector is a camera, the projection will adhere to its perspective/orthographic setting.

Object
:   Specify the projector object(s).
user: Explain About UVs in complete detail according to the official Blender documentation.

assistant: Every point in the UV map corresponds to a vertex in the mesh.
The lines joining the UVs correspond to edges in the mesh.
Each face in the UV map corresponds to a mesh face.
Think of a UV map as projecting the surface of your 3D model onto a 2D image.

Each face of a mesh can have many UV textures. Each UV texture can have an individual image assigned to it.
When you unwrap a face to a UV texture in the UV Editor, each face of the mesh is automatically assigned
four UV coordinates: These coordinates define the way an image or a texture is mapped onto the face.
To distinguish from XYZ coordinates, the U and V axes are used to mark the coordinates of each point.
Hence the name, UV unwrapping. These coordinates can be used for rendering or for real-time viewport
display as well.

Every face in Blender can have a link to a different image.
The UV coordinates define how this image is mapped onto the face.
This image then can be rendered or displayed in real-time.
A 3D Viewport has to be in “Face Select” mode to be able to assign Images or
change UV coordinates of the active mesh object.
This allows a face to participate in many UV textures.
A face at the hairline of a character might participate in the facial UV texture,
*and* in the scalp/hair UV texture.

These are described more fully in the next sections.
user: Explain ShaderNodeCustomGroup(ShaderNode) in complete detail according to the official Blender documentation.

assistant: # ShaderNodeCustomGroup(ShaderNode)

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

*class* bpy.types.ShaderNodeCustomGroup(*ShaderNode*)
:   Custom Shader Group Node for Python nodes

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

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

assistant: The Track Motion menu is used to perform tracking of selected tracks
(i.e. following the selected feature from frame to frame).

This operator depends on settings from the Tracking Settings panel.
If during sequence tracking the algorithm fails to track some markers,
they will be disabled and tracking will continue for the rest of the markers.
If the algorithm fails when tracking frame-by-frame, the marker is not disabled,
and the most likely position of the feature on the next frame is used.

### Backwards

Tracks the motion backward along the sequence.

### Frame Backwards

Tracks the motion backward by one frame.

### Forwards

Tracks the motion forward along the whole sequence.

### Frame Forwards

Tracks the motion forward one frame.
user: How do I use NodeFunctionFormatStringItems(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # NodeFunctionFormatStringItems(bpy_struct)

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

*class* bpy.types.NodeFunctionFormatStringItems(*bpy_struct*)
:   Collection of format string items

    new(*socket_type*, *name*)
    :   Add an item at the end

        Parameters:
        :   - **socket_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)) – Socket Type, Socket type of the item
            - **name** (*string**,* *(**never None**)*) – Name

        Returns:
        :   Item, New item

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

    remove(*item*)
    :   Remove an item

        Parameters:
        :   **item** ([`NodeFunctionFormatStringItem`](bpy.types.NodeFunctionFormatStringItem.html#bpy.types.NodeFunctionFormatStringItem "bpy.types.NodeFunctionFormatStringItem"), (never None)) – Item, The item to remove

    clear()
    :   Remove all items

    move(*from_index*, *to_index*)
    :   Move an item to another position

        Parameters:
        :   - **from_index** (*int in* *[**0**,* *inf**]*) – From Index, Index of the item to move
            - **to_index** (*int in* *[**0**,* *inf**]*) – To Index, Target index for the item

    *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 SmoothModifier(Modifier) in a Blender add-on or script – include code.

assistant: # SmoothModifier(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.SmoothModifier(*Modifier*)
:   Smoothing effect modifier

    factor
    :   Strength of modifier effect

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

    invert_vertex_group
    :   Invert vertex group influence

        Type:
        :   boolean, default False

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

    use_x
    :   Smooth object along X axis

        Type:
        :   boolean, default True

    use_y
    :   Smooth object along Y axis

        Type:
        :   boolean, default True

    use_z
    :   Smooth object along Z axis

        Type:
        :   boolean, default True

    vertex_group
    :   Name of Vertex Group which determines influence of modifier per point

        Type:
        :   string, default “”, (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: Explain Some history in complete detail according to the official Blender documentation.

assistant: Bone Collections were introduced in Blender 4.0, as a replacement for armature
layers and bone groups. Bone Collections are owned by the Armature, so they are
available in all modes. To contrast, bone groups were stored on the object’s
pose, and thus were not available in armature edit mode.
user: How do I use Bokeh Image Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Bokeh Image Node

[image reference removed]

The *Bokeh Image* node generates a special input image for use with
the [Bokeh Blur](../filter/blur/bokeh_blur.html) filter node.

The *Bokeh Image* node is designed to create a reference image which simulates optical parameters
such as aperture shape and lens distortions which have important impacts on bokeh in real cameras.
user: What is Assigning to Existing Classes and how is it used in Blender Python scripting?

assistant: Custom properties can be added to any subclass of an `ID`,
`Bone` and `PoseBone`.

These properties can be animated, accessed by the user interface and Python
like Blender’s existing properties.

```
import bpy

# Assign a custom property to an existing type.
bpy.types.Material.custom_float = bpy.props.FloatProperty(name="Test Property")

# Test the property is there.
bpy.data.materials[0].custom_float = 5.0
```
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Index
:   Determines which of the following input sockets is passed through to the output.
    The index is zero-based (i.e., the first input corresponds to index 0).

Each socket represents a possible input to select from.
The active input is determined by the *Index* value.

Additional input sockets can be added by either:
- Dragging a connection onto the empty socket at the bottom of the list.
- Clicking the  icon in the node header.
user: How do I use Curve to Tube Modifier in Blender? Include parameters, examples, warnings and best practices.

assistant: # Curve to Tube Modifier

The *Curve to Tube* modifier generates a mesh tube along an input curve.
It creates cylindrical or custom-profiled geometry that follows the curve shape,
with flexible control over radius, resampling, capping, and UV generation.
This node is useful for modeling cables, pipes, wires, or other tubular structures.
user: Describe Effect Strip from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Change Effect Type

Replaces the selected effect strip with another effect type that requires the same number of inputs.

This operator preserves existing input strips and settings where possible,
making it quicker to experiment with different effects without manually recreating the setup.

For example, you can switch between effects like *Cross*, *Gamma Cross*, and *Wipe*, since they all use two inputs.

### Reassign Inputs

This tool can be used to assign (reconnect) effect strips in a different way.
Select three arbitrary strips and press `R`.
If you don’t create a cycle, those will be connected to a new effect chain.

### Swap Inputs

Swaps the first two inputs for the effect strip.
user: Give a detailed overview of Interactive Region: syntax, arguments, return values, common patterns.

assistant: The interactive region is the bottom half of the splash screen.

New File
:   Start a new project based on a template.

Recent Files
:   Your most recently opened blend-files. This gives quick and easy access to your recent projects.

Open
:   Allows opening an existing blend-file.

Recover Last Session
:   Blender will try to recover the last [session](../../glossary/index.xhtml#term-Session) based on temporary files. See
    [Recovering Data](../../troubleshooting/recover.xhtml).

What’s New
:   Open the latest release notes.

Donate to Blender
:   Open Blender’s [Development Fund](https://fund.blender.org/) website.
user: Provide the full official documentation entry for Track, preserving all code examples.

assistant: # Track

[[image reference removed]](../../../../../_images/movie-clip_tracking_clip_sidebar_track_track_panel.png)

Track panel.

Name
:   The track name can be changed with this field.
    Track names are used for linking tracking data to other areas, like a Follow Track constraint.

Enable
:   This toggle controls if the marker is enabled.
    If a marker is disabled, its position is not used either by solver nor by constraints.

/ Lock
:   The toggle controls whether the track is locked. Locked tracks cannot be edited at all.
    This helps to prevent accidental changes to tracks which are “finished”
    (tracked accurate along the whole footage).
user: What is NodeSocketVectorXYZ4D(NodeSocketStandard) and how is it used in Blender Python scripting?

assistant: # NodeSocketVectorXYZ4D(NodeSocketStandard)

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

*class* bpy.types.NodeSocketVectorXYZ4D(*NodeSocketStandard*)
:   3D vector socket of a node

    default_value
    :   Input value used for unconnected socket

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

    links
    :   List of node links from or to this socket.

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

        (readonly)

    *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 Hide Gesture Tools from the Blender manual or Python API, including usage steps and snippets.

assistant: # Hide Gesture Tools

Hide gesture tools hide all selected vertices within the selection area and any of their connected
edges and faces.
Holding `Ctrl` while performing the selection reveals the vertices, edges, and faces.

Pressing `LMB` with any of these tools without also dragging reveals all elements of a mesh.

All hide gesture tools can be activated in the Toolbar and are comprised of the following:
user: What is API Overview and how is it used in Blender Python scripting?

assistant: # API Overview

The purpose of this document is to explain how Python and Blender fit together,
covering some of the functionality that may not be obvious from reading the API references
and example scripts.
user: Give a detailed overview of CompositorNodeVecBlur(CompositorNode): syntax, arguments, return values, common patterns.

assistant: # CompositorNodeVecBlur(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.CompositorNodeVecBlur(*CompositorNode*)
:   Uses the vector speed render pass to blur the image pixels in 2D

    *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 Separate Spherical Node in complete detail according to the official Blender documentation.

assistant: # Separate Spherical Node

[image reference removed]

The *Separate Spherical* node converts a vector from Cartesian coordinates (X, Y, Z)
into spherical coordinates (R, Φ, Θ) and outputs each component separately.
It is the inverse of the [Combine Spherical](../../../../modeling/geometry_nodes/utilities/vector/combine_spherical.html) node.

Spherical coordinates describe a position in 3D space using radius, azimuth (horizontal angle),
and polar (vertical) angle. This representation is useful for procedural effects involving
rotational symmetry, spherical gradients, or direction-based transformations.
user: Show practical ways to work with Clear Parent in a Blender add-on or script – include code.

assistant: You can *remove* a parent-child relationship via `Alt`-`P`.

Clear Parent
:   If the parent in the group is selected, nothing is done.
    If a child or children are selected, they are disassociated from the parent,
    or freed, and they return to their *original* location, rotation, and size.

Clear and Keep Transformation
:   Frees the children from the parent, and *keeps* the location, rotation, and size given to them by the parent.

    See [Non-Uniform Scale](#non-uniform-scale) which may apply here.

Clear Parent Inverse
:   Instead of removing the hierarchical parent-child relationship, this clears
    the [Parent Inverse](#parent-inverse) matrix from the selected objects. With an empty matrix,
    the location, rotation and scale properties of the children are interpreted
    in the coordinate space of the parent.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Value
:   The values to be accumulated.

Group Index
:   An index used to group values together for multiple separate accumulations.
    This can be thought of as a choice of the “bin” in which to place each value.
    This input has no effect when it is only a single value.
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: Instances
:   Standard geometry input.

Selection
:   Boolean field used to determine if an instance will be translated.

Translation
:   The vector to translate the instances by.

Local Space
:   If enabled, the instances are translated relative to their initial rotation.
    Otherwise they are translated in the local space of the modifier object.
user: What is Warp Modifier and how is it used in Blender Python scripting?

assistant: # Warp Modifier

The *Warp* modifier can be used to warp parts of a mesh to a new location in
a very flexible way, by using two objects to select the “from” and “to” regions.

[image reference removed]

A Warp modifier applied to a grid mesh.

This modifier is a bit tricky to understand at first.
It requires two points, specified by the two target objects’ origins.
The “from” point designates a point in space that is pulled toward the “to” point.
It is akin to using
the [Proportional Editing](../../../editors/3dview/controls/proportional_editing.xhtml) in Edit Mode.
user: Explain Grid Info Node in complete detail according to the official Blender documentation.

assistant: # Grid Info Node

[image reference removed]

The *Grid Info* node retrieves structural and metadata information about a voxel grid.
It provides details such as the grid’s spatial transform and background value,
which describe how the grid is positioned in space and what value is stored in
inactive (empty) voxels.

This node is useful for inspecting or reusing grid parameters in other grid
operations, such as aligning transforms, matching resolutions, or reconstructing
fields with consistent background values.
user: Show practical ways to work with Show/Hide in a Blender add-on or script – include code.

assistant: Hides the selected or unselected control points, or unhides all hidden
control points.

By default, unhiding control points adds them to the selection.
To prevent this, uncheck the *Select* option in the [Adjust Last Operation](../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.
user: How do I use Select Linked in Blender? Include parameters, examples, warnings and best practices.

assistant: Selects all control points connected to the active control point.

This operator makes it easier to select or deselect entire segments of a curve, especially in
dense or complex curves, where manually selecting each point would be time-consuming.

### Select Linked Pick

Selects (`L`) or deselects (`Shift`-`L`) control points
connected to the control point nearest the mouse cursor.
user: Explain Make Vertex Parent in complete detail according to the official Blender documentation.

assistant: You can make other selected objects [children](../../../scene_layout/object/editing/parent.html#object-parenting)
of one or three control points, as with mesh objects.

To select a mesh (that is in view) while editing a curve, `Ctrl`-`P` click on it.
Select either one or three control points,
then `Ctrl`-`LMB` the object and use `Ctrl`-`P` to make a vertex parent.
Selecting three control points will make the child follow
the median point between the three vertices. An alternative would be to use
a [Child Of constraint](../../../animation/constraints/relationship/child_of.html).
See also the [Curve modifier](../../modifiers/deform/curve.html).
user: How do I use ShaderNodeUVAlongStroke(ShaderNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ShaderNodeUVAlongStroke(ShaderNode)

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

*class* bpy.types.ShaderNodeUVAlongStroke(*ShaderNode*)
:   UV coordinates that map a texture along the stroke length

    use_tips
    :   Lower half of the texture is for tips of the stroke

        Type:
        :   boolean, default False

    *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 Add-ons in Blender? Include parameters, examples, warnings and best practices.

assistant: # Add-ons

The Add-ons section lets you manage secondary scripts, called “Add-ons” that extends Blender’s functionality.
Most of the time you can get add-ons as part of the [Extensions](../../advanced/extensions/index.xhtml#extensions-index) system.

In this section you can search, install, enable and disable Add-ons.

[image reference removed]

Blender Preferences Add-ons section.
user: Describe Behavior from the Blender manual or Python API, including usage steps and snippets.

assistant: When executed, this node evaluates the connected closure’s internal node graph.
All input values are passed into the closure by name, and all resulting values are returned through the corresponding
outputs.

If no closure is connected, or if the node is muted, *Evaluate Closure* automatically passes through any matching
inputs and outputs by name. This *pass-through mode* makes closures optional and allows node groups to function even
without one.

Evaluation occurs in the local context of the node tree where *Evaluate Closure* resides, inheriting relevant fields,
attributes, and geometry data.
user: Show practical ways to work with AnnotationStrokePoint(bpy_struct) in a Blender add-on or script – include code.

assistant: # AnnotationStrokePoint(bpy_struct)

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

*class* bpy.types.AnnotationStrokePoint(*bpy_struct*)
:   Data point for freehand stroke curve

    co
    :   Type:
        :   [`mathutils.Vector`](mathutils.html#mathutils.Vector "mathutils.Vector") of 3 items in [-inf, inf], 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: Describe SequencerTimelineOverlay(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # SequencerTimelineOverlay(bpy_struct)

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

*class* bpy.types.SequencerTimelineOverlay(*bpy_struct*)
:   show_fcurves
    :   Display strip opacity/volume curve

        Type:
        :   boolean, default False

    show_grid
    :   Show vertical grid lines

        Type:
        :   boolean, default False

    show_strip_duration
    :   Type:
        :   boolean, default False

    show_strip_name
    :   Type:
        :   boolean, default False

    show_strip_offset
    :   Display strip in/out offsets

        Type:
        :   boolean, default False

    show_strip_retiming
    :   Display retiming keys on top of strips

        Type:
        :   boolean, default False

    show_strip_source
    :   Display path to source file, or name of source data-block

        Type:
        :   boolean, default False

    show_strip_tag_color
    :   Display the strip color tags in the sequencer

        Type:
        :   boolean, default False

    show_thumbnails
    :   Show strip thumbnails

        Type:
        :   boolean, default False

    waveform_display_style
    :   How Waveforms are displayed

        - `FULL_WAVEFORMS`
          Full – Display full waveform.
        - `HALF_WAVEFORMS`
          Half – Display upper half of the absolute value waveform.

        Type:
        :   enum in [`'FULL_WAVEFORMS'`, `'HALF_WAVEFORMS'`], default `'FULL_WAVEFORMS'`

    waveform_display_type
    :   How Waveforms are displayed

        - `ALL_WAVEFORMS`
          On – Display waveforms for all sound strips.
        - `DEFAULT_WAVEFORMS`
          Strip – Display waveforms depending on strip setting.
        - `NO_WAVEFORMS`
          Off – Don’t display waveforms for any sound strips.

        Type:
        :   enum in [`'ALL_WAVEFORMS'`, `'DEFAULT_WAVEFORMS'`, `'NO_WAVEFORMS'`], default `'DEFAULT_WAVEFORMS'`

    *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 Operator Cheat Sheet from the Blender manual or Python API, including usage steps and snippets.

assistant: Creates a text file in the Text Editor that gives a list of all operators
and their default values in Python syntax, along with the generated docs.
This is a good way to get an overview of all Blender’s operators.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: # Options

Bleed
:   Seam Bleed extends the paint beyond UV island bounds to avoid visual artifacts
    (like bleed for baking).

Dither
:   Amount of dithering when painting on 8-bit images.

Occlude
:   With Geometry occlusion active only exposed (not hidden by other mesh parts) pixels are affected.
    This also allows for 3D stencils to be used to mask out areas of the surface too.

Backface Culling
:   With backface culling enabled you can only paint on the front side of faces.
user: What is Shader To RGB Node and how is it used in Blender Python scripting?

assistant: # Shader To RGB Node

[image reference removed]

EEVEE Only

The Shader to RGB node is typically used for non-photorealistic rendering,
to apply additional effects on the output of BSDFs.
For example, a color ramp on the output of a diffuse BSDF can be used to create a flexible toon shader.

Using this conversion breaks the PBR pipeline and
thus makes the result unpredictable when used in combination with effects such as
ambient occlusion, contact shadows, soft shadows and screen space refraction.

Some effects require multiple samples to converge, and applying arbitrary changes to
noisy input may not convert to a smooth result.
user: Explain Options in complete detail according to the official Blender documentation.

assistant: Source Channel
:   The channel which the Multicam Selector gets its input from.

Cut To
:   Cuts the Multicam strip at the current frame and
    changes the *Source Channel* automatically to the selected channels.
user: Give a detailed overview of Trim Hair Curves: syntax, arguments, return values, common patterns.

assistant: # Trim Hair Curves

The *Trim Hair Curves* node shortens or scales hair curves based on a specified length or length factor.
It can be used to precisely control the overall length of hair, create varied or randomized trims,
or adjust groom density and layering.
user: Give a detailed overview of Curves: syntax, arguments, return values, common patterns.

assistant: # Curves

These are global settings that apply to all instances of particle hair systems.
The resolution of the strands is controlled by the step values in particle settings.
Each hair system uses the material identified in the particle settings.

Shape
:   Controls how curves (such as hair strands) are represented during rendering.
    Different methods balance speed and accuracy,
    depending on whether the curves are viewed up close or in the distance.

    Rounded Ribbons:
    :   Render curves as flat ribbon with rounded normals, for fast rendering.
        Curves are subdivided with a fixed number of specified subdivisions.

        Curve Subdivisions
        :   Number of subdivisions used in cardinal curve intersection (power of 2).

    3D Curves:
    :   Render curves as circular 3D geometry, for accurate results when viewing curves close up.
        Curves are automatically subdivided until the curve is smooth.

    Linear 3D Curves:
    :   Render curves as 3D circular geometry with linear interpolation between control points.
        This is faster than full 3D curves but less smooth, and may show visible corners at low resolutions.

        This is an optimization to take advantage of hardware accelerated curve intersection on GPUs.
        Results will not look exactly the same on different CPU and GPU devices, so this is not
        suitable for multi device rendering or render farms with mixed hardware.
user: Explain Non Manifold in complete detail according to the official Blender documentation.

assistant: Selects the [non-manifold](../../../glossary/index.html#term-Non-manifold) geometry of a mesh.
This entry is only available in the *Vertex* and *Edge*
[selection modes](introduction.html#bpy-types-toolsettings-mesh-select-mode).

The [Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel offers the following options:

Extend
:   Adds to the current selection instead of replacing it.

Wire
:   Selects edges that do not belong to any face.

Boundaries
:   Selects edges at boundaries and holes.

Multiple Faces
:   Selects edges that belong to three or more faces.

Non Contiguous
:   Selects edges that belong to exactly two faces with opposite normals.

Vertices
:   Selects vertices that are isolated, belong to an edge that’s a *Wire*
    or has *Multiple Faces*, or are the only vertex connecting two faces.
user: Give a detailed overview of Inputs: syntax, arguments, return values, common patterns.

assistant: Width / Bottom Width / Top Width
:   The X axis size of the shape.

Height
:   The Y axis size of the shape.

Bottom Height / Top Height
:   The distance between the bottom or top point and the X axis, in *Kite* mode.

Offset
:   In *Parallelogram* mode, the relative X difference between the top and bottom edge.
    In *Trapezoid* mode, the amount to move the top edge in the positive X axis.

Point 1 - 4
:   Input vectors for the *Points* mode.
user: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: Progression
:   Profile of blend.

    Linear
    :   A linear progression.

Quadratic
:   A quadratic progression.

Easing
:   A flowing, nonlinear progression.

Diagonal
:   A diagonal progression.

Spherical
:   A progression with the shape of a three-dimensional ball.

Quadratic Sphere
:   A quadratic progression with the shape of a three-dimensional ball.

Radial
:   A radial progression: *Horizontal* / *Vertical*.
    The direction of the progression is flipped a quarter turn.
user: Show practical ways to work with Curve Tilt Node in a Blender add-on or script – include code.

assistant: # Curve Tilt Node

[image reference removed]

The *Curve Tilt* node outputs the angle used to turn the curve normal
around the direction of the curve tangent in its evaluated points.
Keep in mind that the output is per control point, just like the values
that can be controlled in curve Edit Mode. For NURBS and Bézier splines,
the values will be interpolated to the final evaluated points.

The input node for this data is the [Set Curve Tilt](../write/set_curve_tilt.html) node.
user: Describe Focus Mode from the Blender manual or Python API, including usage steps and snippets.

assistant: Expands the editor area so it fills the entire window, hiding:

- The Topbar
- The Status Bar
- Secondary [regions](regions.html) (such as toolbars, sidebars, headers, etc.) of the
  editor itself.

This mode gives the maximum possible screen space for the active editor.

To return to normal size, use the shortcut again or click the 
icon in the top-right corner of the editor (visible only when hovering over the area).
user: Provide the full official documentation entry for Properties, preserving all code examples.

assistant: Mode
:   Inputs to use to control the line.

    Offset:
    :   Specify the offset from one vertex to the next.

    End Points:
    :   Specify the start and end point of the line.

Count Mode
:   Determines how the number of vertices is chosen.
    This is only available when the mode is set to *End Points*.

    Count:
    :   Specify the total number of vertices.

    Resolution:
    :   Specify the distance between vertices.
user: Provide the full official documentation entry for Utilities (bpy.utils), preserving all code examples.

assistant:  Parameters:
    :   - **resource_type** (*str*) – Resource type in [‘DATAFILES’, ‘CONFIG’, ‘SCRIPTS’, ‘EXTENSIONS’].
        - **path** (*str*) – Optional subdirectory.
        - **create** (*bool*) – Treat the path as a directory and create it if its not existing.

    Returns:
    :   a path.

    Return type:
    :   str

bpy.utils.execfile(*filepath*, *\**, *mod=None*)
:   Execute a file path as a Python script.

    Parameters:
    :   - **filepath** (*str*) – Path of the script to execute.
        - **mod** (*ModuleType* *|* *None*) – Optional cached module, the result of a previous execution.

    Returns:
    :   The module which can be passed back in as `mod`.

    Return type:
    :   ModuleType

bpy.utils.expose_bundled_modules()
:   For Blender as a Python module, add bundled VFX library python bindings
    to `sys.path`. These may be used instead of dedicated packages, to ensure
    the libraries are compatible with Blender.
user: Give a detailed overview of Outputs: syntax, arguments, return values, common patterns.

assistant: Laplacian
:   A float grid representing the Laplacian of the input field.

    Each voxel contains the sum of the second derivatives of the input
    field along the X, Y, and Z axes. This can be used to detect local
    peaks and valleys or to drive smoothing and diffusion effects in
    procedural grids.
user: Provide the full official documentation entry for Examples, preserving all code examples.

assistant: ### Creating an Alpha Mask

An often overlooked use case of the Color Ramp is to turn a black-and-white image
into a colored image with transparency.

[image reference removed]

In the example above, a black-and-white swirl image, which is lacking an alpha channel,
is fed into the Color Ramp node as a *Factor*.

The Color Ramp node is set to a purely transparent color on the left end of the gradient,
and a fully red color on the right. As you can see in the Viewer node,
the Color Ramp node outputs an image that is transparent where the input is black,
and opaque where the input is white.

### Colorizing an Image

In this example, multiple colors are added to the color gradient,
converting a black-and-white image into a flaming swirl.

[image reference removed]

The shades of gray in the input image are mapped to three colors:
blue, yellow, and red, all fully opaque. Where the image is black,
the Color Ramp substitutes blue (the first color stop). Where it is some shade of gray,
the Color Ramp outputs a corresponding color from the gradient (bluish, yellow, to reddish).
Where the image is fully white, the Color Ramp outputs red.
user: Describe Torus from the Blender manual or Python API, including usage steps and snippets.

assistant: A doughnut-shaped primitive created by rotating a circle around an axis.
This shape is commonly used for rings, pipes, and stylized details.

Operator Presets
:   Saved torus settings that can be reused.
    These are stored as Python scripts in the presets directory.

Major Segments
:   Number of segments that make up the main circular ring of the torus.
    Think of this as the number of steps in the spin operation around the central axis.

Minor Segments
:   Number of segments making up the circular cross-section of the torus.
    Each segment is rotated around the main ring.

Dimensions Mode
:   Selects the method used to define the shape and size of the torus:

    Major/Minor:
    :   Define the torus using the radius of the main ring and the radius of the cross-sectional circle.

    Exterior/Interior:
    :   Define the torus using the total outer radius and the radius of the central hole.

Major Radius Major/Minor
:   Distance from the center of the torus to the center of the cross section.

Minor Radius Major/Minor
:   Radius of the cross-sectional circle (thickness of the ring).

Exterior Radius Exterior/Interior
:   Total radius from the center of the torus to its outer edge.

Interior Radius Exterior/Interior
:   Radius of the hole at the center of the torus.
user: Show practical ways to work with Deploying Blender in Production in a Blender add-on or script – include code.

assistant: # Deploying Blender in Production

This page contains tips for setting up Blender in environments
such as animation studios and schools.

These environments often have special requirements regarding
security, automated deployment and customization.
user: Provide the full official documentation entry for Example, preserving all code examples.

assistant: [image reference removed]

Smoke density.

[image reference removed]

Computing the color of fire using the *Blackbody* node.
Since the *Blackbody* node expects its input in Kelvin,
the temperature output has to be remapped first.
user: Show practical ways to work with Version Number Guidelines in a Blender add-on or script – include code.

assistant: # Version Number Guidelines

The Blender Extensions platform doesn’t mandate any particular version numbering
scheme, so if you already have a versioning scheme that you use for your
extension, feel free to continue using that.

However, if you don’t have an existing version numbering scheme, we recommend
following the guidelines below.
user: Show practical ways to work with Notes in a Blender add-on or script – include code.

assistant: In some configurations of the node, especially for low values of *Randomness*,
rendering artifacts may occur. This happens due to the same reasons described
in the [Notes section](../../../render/shader_nodes/textures/white_noise.html#shader-white-noise-notes) in the White Noise Texture page
and can be fixed in a similar manner as described there.
user: Describe Known Limitations from the Blender manual or Python API, including usage steps and snippets.

assistant: - Remeshing only works on the original mesh data and
  ignores generated geometry from modifiers, shape keys, rigging, etc.
- Remeshing will not work with the [Multiresolution Modifier](../../../modeling/modifiers/generate/multiresolution.xhtml).
user: Describe Examples from the Blender manual or Python API, including usage steps and snippets.

assistant: ### Blur Alpha

[[image reference removed]](../../../_images/compositing_types_converter_combine-separate_example-combine-rgba.png)

An example of blurring the alpha channel.

In this first example, we take the Alpha channel and blur it,
and then combine it back with the colors. When placed in a scene,
the edges of it will blend in, instead of having a hard edge.
This is almost like [Anti-Aliasing](../../../glossary/index.html#term-Anti-Aliasing) but in a three-dimensional sense.
Use this node setup, when adding CG elements to live action to remove any hard edges.
Animating this effect on a broader scale will make the object appear to “phase” in and out,
as an “out-of-phase” time-traveling sync effect.

### Increase Luminance

[image reference removed]

An example of the scaling the Luminance channel.

This example has a *Math (Multiply)* node increasing the luminance channel (Y)
of the image to make it brighter.
user: Explain Threads in complete detail according to the official Blender documentation.

assistant: Threads Mode
:   Method to determine the maximum number of CPU cores to use while rendering.

    Auto-Detect:
    :   Automatically chooses the amount of threads to match the number of logical processors on your computer.

    Fixed:
    :   Manually choose the maximum number threads to use for rendering.
        This can be useful for example, if you want to use your computer while rendering,
        you can set the property to a thread count lower the amount of logical processors on your computer.

Threads
:   The maximum number of CPU cores to use simultaneously while rendering.