PGCRYPT/OpenBlender_Train huggingface dataset:
user: Describe Non-Editable Overrides from the Blender manual or Python API, including usage steps and snippets.

assistant: For technical reasons (how relationships between data-blocks are stored), Blender needs to create
overrides of a lot of data-blocks, even when only one or two of them actually needs to be edited
by the user. To reduce the amount of information and risk of potential unwanted editing, most of
these data-blocks are now marked as non-editable by default. This can be changed once the
override has been created.
user: Provide the full official documentation entry for Inputs, preserving all code examples.

assistant: Instances
:   The input geometry containing the instances to be randomized.

Selection
:   Controls which instances are affected by the randomization.
    Only selected instances will receive random transformations.

Local Space
:   - When enabled, transformations are applied in each instance’s local coordinate space.
    - When disabled, randomization is performed in the global coordinate space.

Offset
:   The maximum translation offset for each axis. Defines the random range for instance movement.

Rotation
:   The maximum rotation for each axis. Defines how much each instance can be rotated.

Scale Axes
:   Determines how scaling is applied.

    Uniform:
    :   Applies a single random scale factor uniformly to all axes.

    Axes:
    :   Applies an independent random scale factor to each axis.

Scale
:   The maximum scaling factor applied to each instance.

Flipping
:   Randomly flips instances along one or more axes, effectively mirroring them.

Seed
:   An integer value that initializes the random number generator.
    Changing the seed produces a different random arrangement while keeping the same parameters.
user: Explain Expressions in complete detail according to the official Blender documentation.

assistant: Expression
:   A text field where you can enter an arbitrary Python expression that refers to
    *Driver Variables* by their names.

    The expression has access to a set of standard constants and math functions from `math`,
    `bl_math` and other modules, provided in the *Driver Namespace*. For an example of adding
    a custom function to the namespace, see the [driver namespace example](workflow_examples.xhtml#driver-namespace).

    For performance reasons it is best to use the [Simple Expressions](#simple-expressions) subset as much as possible.

Use Self
:   If this option is enabled, the variable `self` can be used for drivers to reference their own data.
    Useful for objects and bones to avoid having creating a *Driver Variable* pointing to itself.

    Example: `self.location.x` applied to the Y rotation property of the same object
    will make the object tumble when moving.

    Note that dependencies for properties accessed via `self` may not be fully tracked.

### Simple Expressions

Blender can evaluate a useful subset of Python driver expressions directly,
which significantly improves performance, especially on multi-core systems.
To take advantage of this, the driver expression must only use the following features:

Variable Names
:   Use only ASCII characters.

Literals
:   Floating-point and decimal integer.

Globals
:   `frame`

Constants
:   `pi`, `True`, `False`

Operators
:   `+`, `-`, `*`, `/`,
    `==`, `!=`, `<`, `<=`, `>`, `>=`,
    `and`, `or`, `not`, conditional operator/ ternary if

Standard Functions
:   `min`, `max`, `radians`, `degrees`,
    `abs`, `fabs`, `floor`, `ceil`, `trunc`, `round`, `int`,
    `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`,
    `exp`, `log`, `sqrt`, `pow`, `fmod`

Blender Provided Functions
:   `lerp`, `clamp`, `smoothstep`

Simple expressions are evaluated even when Python script execution is disabled.

When an expression outside of this subset is used, Blender displays a “Slow Python expression”
warning. However, as long as the majority of drivers use simple expressions, using a complex
expression in select few is OK.
user: Describe CompositorNodeHueCorrect(CompositorNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # CompositorNodeHueCorrect(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.CompositorNodeHueCorrect(*CompositorNode*)
:   Adjust hue, saturation, and value with a curve

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

    *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: Show practical ways to work with Options in a Blender add-on or script – include code.

assistant: [image reference removed]

The Surface Deform modifier.

Target
:   The object to which to bind (this setting is unavailable after binding).

Interpolation Falloff
:   How much a vertex bound to one face of the target will be affected by the surrounding faces
    (this setting is unavailable after binding).
    This essentially controls how smooth the deformations are.

Strength
:   The overall amount of influence the modifier has on deforming the mesh.

Vertex Group
:   Allows you to define the influence per vertex.

    Invert
    :   Inverts the influence of the selected vertex group, meaning that the group
        now represents vertices that will not be deformed by the modifier.

        The setting reverses the weight values of the group.

Sparse Bind
:   Only record bind data for vertices that have nonzero weights in the group at the time of bind.
    This is an optimization, but adding new vertices to the group will require a rebind.

Bind
:   Bind the current state of the modified mesh to the current state of the target mesh,
    such that any later change in the target mesh will deform the modified mesh as well.
    Note that until the bind has been executed, this modifier will have no effect at all.

Unbind
:   Once the mesh is bound, the *Bind* button changes to *Unbind*.
    Executing this frees the modified mesh from the target, and resets it to its original shape.
user: How do I use ColorMapping(bpy_struct) in Blender? Include parameters, examples, warnings and best practices.

assistant: # ColorMapping(bpy_struct)

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

*class* bpy.types.ColorMapping(*bpy_struct*)
:   Color mapping settings

    blend_color
    :   Blend color to mix with texture output color

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

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

    blend_type
    :   Mode used to mix with texture output color

        Type:
        :   enum in [`'MIX'`, `'DARKEN'`, `'MULTIPLY'`, `'LIGHTEN'`, `'SCREEN'`, `'ADD'`, `'OVERLAY'`, `'SOFT_LIGHT'`, `'LINEAR_LIGHT'`, `'DIFFERENCE'`, `'SUBTRACT'`, `'DIVIDE'`, `'HUE'`, `'SATURATION'`, `'COLOR'`, `'VALUE'`], default `'MIX'`

    brightness
    :   Adjust the brightness of the texture

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

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

    contrast
    :   Adjust the contrast of the texture

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

    saturation
    :   Adjust the saturation of colors in the texture

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

    use_color_ramp
    :   Toggle color ramp operations

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Particle Instance Modifier in a Blender add-on or script – include code.

assistant: # Particle Instance Modifier

When a Particle Instance modifier is added to an object,
the mesh of this object will be duplicated
at the location of the particles of the selected particle system from another target object.
This means that to use this modifier, you must have at least one other object
that has a [Particles System](../../../physics/particles/index.xhtml) on it.

Because of the correlation in which the Particle Instance modifier is
influenced by the underlying particle systems on other objects, some of the apparent effects
generated by the modifier can look and act vastly different,
depending on the underlying settings of the particle systems it is associated with.
This is worth taking account of, when it seems that the Particle Instance modifier settings
do not return the expected results.
user: What is Camera and how is it used in Blender Python scripting?

assistant: To tweak the stereo 3D parameters, select the camera in the Outliner.
In the Camera panel go to the Stereoscopy tab and change the *Convergence Distance*.

The viewport will respond in real-time to those changes allowing you to preview the current depth value of the scene.

[image reference removed]

Stereo convergence distance.
user: Explain Movement in complete detail according to the official Blender documentation.

assistant: [image reference removed]

Boid Movement settings.

Boids avoid objects with Collision enabled, move toward goals, and flee from “predators” based on the *Boid Brain*.
Their behavior changes depending on whether they are in the air or on land.

Allow Flight
:   Enables movement in the air.

Allow Land
:   Enables movement on land.

Allow Climbing
:   Enables climbing toward goal objects.

Max Air Speed
:   The maximum velocity boids can achieve while in the air.

Min Air Speed
:   The minimum velocity boids maintain while flying.

Max Air Acceleration
:   Controls how quickly boids can change direction in the air, expressed as a percentage of their maximum velocity.
    Higher values result in more agile movements.

Max Air Angular Velocity
:   Limits how sharply boids can turn in the air, expressed as a percentage of 180 degrees.
    Lower values create smoother curves during flight.

Air Personal Space
:   The radius of personal space for boids in the air, as a percentage of their particle size.
    Larger values reduce crowding in swarms.

Landing Smoothness
:   Adjusts how softly boids land on surfaces.
    Higher values ensure gradual transitions when landing.

Max Land Speed
:   The maximum velocity boids can achieve on land.

Jump Speed
:   The velocity boids achieve during jumps.

Max Land Acceleration
:   Controls how quickly boids can change direction on land, expressed as a percentage of their maximum velocity.

Max Land Angular Velocity
:   Limits how sharply boids can turn on land, expressed as a percentage of 180 degrees.
    Lower values create smoother, less abrupt turns.

Land Personal Space
:   The radius of personal space for boids on land, as a percentage of their particle size.
    Larger values reduce crowding in herds or groups.

Land Stick Force
:   Determines the strength of a force required to influence boids on land.
    Use lower values to allow boids to move more freely when interacting with forces.

Collision Collection
:   Restricts collisions to objects within the specified collection.
    This is useful for limiting interactions to certain objects or environments.
user: What is Image Context and how is it used in Blender Python scripting?

assistant: bpy.context.edit_image
:   Type:
    :   [`bpy.types.Image`](bpy.types.Image.html#bpy.types.Image "bpy.types.Image")

bpy.context.edit_mask
:   Type:
    :   [`bpy.types.Mask`](bpy.types.Mask.html#bpy.types.Mask "bpy.types.Mask")
user: How do I use GeometryNodeExtrudeMesh(GeometryNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # GeometryNodeExtrudeMesh(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.GeometryNodeExtrudeMesh(*GeometryNode*)
:   Generate new vertices, edges, or faces from selected elements and move them based on an offset while keeping them connected by their boundary

    mode
    :   Type:
        :   enum in [`'VERTICES'`, `'EDGES'`, `'FACES'`], default `'FACES'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: Show practical ways to work with Window Cursor Items in a Blender add-on or script – include code.

assistant: # Window Cursor Items

DEFAULT:
:   Default.

NONE:
:   None.

WAIT:
:   Wait.

CROSSHAIR:
:   Crosshair.

MOVE_X:
:   Move-X.

MOVE_Y:
:   Move-Y.

KNIFE:
:   Knife.

TEXT:
:   Text.

PAINT_BRUSH:
:   Paint Brush.

PAINT_CROSS:
:   Paint Cross.

DOT:
:   Dot Cursor.

ERASER:
:   Eraser.

HAND:
:   Open Hand.

HAND_POINT:
:   Pointing Hand.

HAND_CLOSED:
:   Closed Hand.

SCROLL_X:
:   Scroll-X.

SCROLL_Y:
:   Scroll-Y.

SCROLL_XY:
:   Scroll-XY.

EYEDROPPER:
:   Eyedropper.

PICK_AREA:
:   Pick Area.

STOP:
:   Stop.

COPY:
:   Copy.

CROSS:
:   Cross.

MUTE:
:   Mute.

ZOOM_IN:
:   Zoom In.

ZOOM_OUT:
:   Zoom Out.
user: Provide the full official documentation entry for Terminology, preserving all code examples.

assistant: BSDF
:   Stands for Bidirectional Scattering Distribution Function.
    It defines how light is reflected and refracted at a surface.

Reflection
:   BSDFs reflect an incoming ray on the same side of the surface.

Transmission
:   BSDFs transmit an incoming ray through the surface, leaving on the other side.

Refraction
:   BSDFs are a type of *Transmission*, transmitting an incoming ray and
    changing its direction as it exits on the other side of the surface.
user: Provide the full official documentation entry for AnimViz(bpy_struct), preserving all code examples.

assistant: # AnimViz(bpy_struct)

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

*class* bpy.types.AnimViz(*bpy_struct*)
:   Settings for the visualization of motion

    motion_path
    :   Motion Path settings for visualization

        Type:
        :   [`AnimVizMotionPaths`](bpy.types.AnimVizMotionPaths.html#bpy.types.AnimVizMotionPaths "bpy.types.AnimVizMotionPaths"), (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: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Value
:   The values the mean and median will be calculated from.

Group ID
:   An index used to group values together for multiple separate averages.
    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: Describe Object Type Visibility from the Blender manual or Python API, including usage steps and snippets.

assistant: # Object Type Visibility

This popover lets you control the visibility and selectability of the various object types.
For example, you can hide all the Lights in the scene with one click.

The settings only apply to the current 3D Viewport. Object types marked as unselectable
can still be selected in other viewports and in the
[Outliner](../../outliner/introduction.xhtml), for example.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Value
:   The values the mean and median will be calculated from.

Group ID
:   An index used to group values together for multiple separate averages.
    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: Explain Introduction in complete detail according to the official Blender documentation.

assistant: # Introduction

Hair type particle system can be used for strand-like objects,
such as hair, fur, grass, quills, etc.

[image reference removed]

Particle hair systems example. Used for the grass and fur.
user: Show practical ways to work with Vertex Paint Tools in a Blender add-on or script – include code.

assistant: # Vertex Paint Tools

[image reference removed]

Brush
:   Tool to use for any of the vertex paint [brushes](brushes.xhtml).

[Annotate](../../../interface/annotate_tool.xhtml#tool-annotate-freehand)
:   Draw free-hand annotation.

    [Annotate Line](../../../interface/annotate_tool.xhtml#tool-annotate-line)
    :   Draw straight line annotation.

    [Annotate Polygon](../../../interface/annotate_tool.xhtml#tool-annotate-polygon)
    :   Draw a polygon annotation.

    [Annotate Eraser](../../../interface/annotate_tool.xhtml#tool-annotate-eraser)
    :   Erase previous drawn annotations.
user: Give a detailed overview of Duplicate: syntax, arguments, return values, common patterns.

assistant: # Duplicate

As in mesh editing, by pressing `Shift`-`D` the selected bones will be duplicated.
The duplicates become the selected elements and they are placed in select mode,
so you can move them wherever you like.

If you select part of a chain, by duplicating it you will get a copy of the selected chain,
so the copied bones are interconnected exactly like the original ones.

The duplicate of a bone which is parented to another bone will also be parented to the same
bone, even if the root bone is not selected for the duplication. Be aware, though,
that if a bone is parented **and** connected to an unselected bone,
its copy will be parented, but **not** connected to the unselected bone
(see Fig. [Duplication example.](#fig-rig-bone-duplication)).

Duplication example.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_editing_duplicate_example-1.png   An armature with three selected bones and a selected single root. | ../../../../_images/animation_armatures_bones_editing_duplicate_example-2.png   The three duplicated bones. Note that the selected chain is preserved in the copy, and that Bone.006 is parented but not connected to Bone.001, as indicated by the black dashed line. Similarly, Bone.007 is parented but not connected to Bone.003. |
user: Describe IDOverrideLibraryProperty(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # IDOverrideLibraryProperty(bpy_struct)

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

*class* bpy.types.IDOverrideLibraryProperty(*bpy_struct*)
:   Description of an overridden property

    operations
    :   List of overriding operations for a property

        Type:
        :   [`IDOverrideLibraryPropertyOperations`](bpy.types.IDOverrideLibraryPropertyOperations.html#bpy.types.IDOverrideLibraryPropertyOperations "bpy.types.IDOverrideLibraryPropertyOperations") [`bpy_prop_collection`](bpy.types.bpy_prop_collection.html#bpy.types.bpy_prop_collection "bpy.types.bpy_prop_collection") of [`IDOverrideLibraryPropertyOperation`](bpy.types.IDOverrideLibraryPropertyOperation.html#bpy.types.IDOverrideLibraryPropertyOperation "bpy.types.IDOverrideLibraryPropertyOperation"), (readonly)

    rna_path
    :   RNA path leading to that property, from owning ID

        Type:
        :   string, default “”, (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: Provide the full official documentation entry for Screen Space Effects, preserving all code examples.

assistant: Ray-triangle intersection is not currently supported.
Instead of this, EEVEE uses the depth buffer as an approximated scene representation.
This reduces the complexity of scene scale effects and enables a higher performance.
However, only what is in inside the view can be considered when computing these effects.
Also, since it only uses one layer of depth, only the front-most pixel distance is known.

These limitations creates a few problems:

- The screen space effects disappear when reaching the screen border.
  This can be partially fixed by using the *overscan* feature.
- Screen space effects lack deep information (or the thickness of objects).
  This is why most effects have a thickness parameter to control how to consider potential intersected pixels.
- Objects behind other objects (occluded) are not considered by these effects.
- Blended surfaces are not considered by these effects.
  They are not part of the depth prepass and do not appear in the depth buffer.
- Objects that a part of [Holdout Collections](../../../editors/outliner/editing.html#bpy-ops-outliner-collection-holdout-set)
  will not be rendered with screen space effects.

### Raytracing

- Blended materials and materials using raytrace refractions will not appear in dithered materials reflections.
- Blended materials are not compatible with raytracing.
- Only one refraction event is correctly modeled.
  An approximation of the second refraction event can be achieved using the
  [Thickness workflow](../material_settings.html#eevee-materials-thickness).
- Only dithered materials *not* using Raytrace Refractions can be refracted.
user: Show practical ways to work with Workspace Operators in a Blender add-on or script – include code.

assistant: # Workspace Operators

bpy.ops.workspace.add()
:   Add a new workspace by duplicating the current one or appending one from the user configuration

bpy.ops.workspace.append_activate(*\**, *idname=''*, *filepath=''*)
:   Append a workspace and make it the active one in the current window

    Parameters:
    :   - **idname** (*string**,* *(**optional**,* *never None**)*) – Identifier, Name of the workspace to append and activate
        - **filepath** (string, (optional, never None, blend relative `//` prefix supported)) – Filepath, Path to the library

bpy.ops.workspace.delete()
:   Delete the active workspace

bpy.ops.workspace.delete_all_others()
:   Delete all workspaces except this one

bpy.ops.workspace.duplicate()
:   Add a new workspace

bpy.ops.workspace.reorder_to_back()
:   Reorder workspace to be last in the list

bpy.ops.workspace.reorder_to_front()
:   Reorder workspace to be first in the list

bpy.ops.workspace.scene_pin_toggle()
:   Remember the last used scene for the current workspace and switch to it whenever this workspace is activated again
user: Explain Transforms to Deltas in complete detail according to the official Blender documentation.

assistant: Converts the object’s primary transforms (*Location*, *Rotation*, *Scale*) into
[Delta Transforms](../properties/transforms.xhtml#bpy-types-object-delta).
Any existing delta transforms will be added to the new values.

This allows you to “bake” the current transforms into the delta channels, while leaving the primary
transform channels free for new adjustments or keyframes.

Available options:

- **Location to Deltas** – Converts the object’s location to *Delta Location*.
- **Rotation to Deltas** – Converts the object’s rotation to *Delta Rotation*.
- **Scale to Deltas** – Converts the object’s scale to *Delta Scale*.
- **All Transforms to Deltas** – Converts all three at once.

### Options

Reset Values
:   Clear primary transform values after transferring to deltas.

    Clears the primary transform values after transferring them to deltas.
    When enabled, the object’s main *Location*, *Rotation*, and *Scale* are reset
    (e.g. to 0 for location/rotation and 1 for scale), while the appearance remains unchanged
    because the deltas now contain the previous values.
user: What is Freestyle and how is it used in Blender Python scripting?

assistant: # Freestyle

There is only one view map per view layer. It controls the edge detection parameters.
Freestyle can be enabled/disabled per View Layer by toggling the checkbox in the panel header.

[image reference removed]

View Layer: Freestyle panel.

Control Mode
:   Which detected edges are actually rendered, and how, can be controlled either through:

    Parameter Editor Mode:
    :   Lines are rendered via parameters defined in a user-friendly interface
        to define and control Line Sets and line styles.

        A view map (hence a view layer) can have multiple Line Sets,
        and each line set is linked to one line style.

    Python Scripting Mode:
    :   Lines are rendered via [Python scripting](../python.xhtml), powerful but complex.

View Map Cache
:   An option to reuse a previously computed view map for subsequent rendering.
    The cache is automatically updated when the mesh geometry of the input 3D scene has been changed.

    This functionality offers a major performance boost for Freestyle animation rendering
    when the camera-space mesh geometry is static, as well as for repeated still renders
    with updates of line stylization options.

    Although the *View Map Cache* checkbox is a view layer option,
    the cache memory is shared by all view layers and scenes.
    This means that if Freestyle is used for two or more view layers
    (possibly in different scenes through the Compositor),
    then the cached view map for one view layer is replaced by a new view map
    for another view layer and hence no performance gain is expected.

As Render Pass
:   Freestyle lines will not immediately be visible on top of the render image.
    Instead, Freestyle lines are rendered as a [Render Pass](../../layers/passes.xhtml)
    which can be composited with the rendered image with an Alpha Over node.
user: Provide the full official documentation entry for System Directories, preserving all code examples.

assistant: System directories store files that come bundled with Blender and
are required for it to function. This includes scripts, presets, essential
assets and more.

### Linux

Archive downloaded from blender.org:

```
./5.0/
```

Linux distribution packages:

```
/usr/share/blender/5.0/
```

### macOS

```
./Blender.app/Contents/Resources/5.0/
```

### Windows

Zip file downloaded from blender.org:

```
./5.0/
```

Installer downloaded from blender.org:

```
%ProgramFiles%\Blender Foundation\Blender\5.0\
```

Microsoft Store installation:

```
%ProgramFiles%\WindowsApps\BlenderFoundation.Blender<HASH>\Blender\5.0\
```

### Environment Variables

`BLENDER_SYSTEM_SCRIPTS` and `BLENDER_SYSTEM_EXTENSIONS`
[environment variables](command_line/arguments.html#command-line-args-environment-variables)
can be used to [bundle additional scripts and extensions](deploying_blender.html#deploying-blender-bundling),
that are not part of the regular Blender installation.

Other `BLENDER_SYSTEM` environment variables can override other system paths,
though are not commonly used in practice.
user: Describe Outputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Grid
:   The resulting SDF grid with the surface offset by the specified distance.
    The output preserves the SDF property, ensuring that distances remain
    accurate for subsequent operations such as booleans or conversion to a mesh.
user: Provide the full official documentation entry for Video Sequencer, preserving all code examples.

assistant: Memory Cache Limit
:   Upper limit of the Video Sequencer and Movie Clip Editor memory cache (in megabytes).
    For an optimal Clip editor and Sequencer performance, high values are recommended.

Proxy Setup
:   When and how [Proxies](../video_sequencer/sequencer/sidebar/proxy.xhtml) are created.

    Automatic:
    :   Build proxies for added movie and image strips in each preview size.

    Manual:
    :   Set up proxies manually.
user: Explain Visibility Control in complete detail according to the official Blender documentation.

assistant: Parts of the mesh can be hidden in Sculpt Mode.
Because hidden faces cannot be sculpted, hiding makes it easier to isolate what you want to work on.
Hiding geometry also improves the viewport performance.

Hiding is shared between all modes, except Object Mode
(i.e. hiding/showing of faces in one mode will hide the same faces in other modes too).

Unlike [Selection Masking](../../selection_visibility.xhtml) in other painting modes,
Sculpt Mode primarily uses Masks and Face Sets to easily control the mesh visibility
and which faces can currently be edited.
The exception is the [Clipping Region](../../selection_visibility.xhtml#clipping-region), which can be used in any mode.

The most common shortcuts are `H` to hide the face set under the cursor
and `Shift`-`H` to isolate the face set under the cursor (or show everything).

[Inverting the visibility](../editing/sculpt.xhtml#bpy-ops-sculpt-face-set-change-visibility)
and [showing all](../editing/sculpt.xhtml#bpy-ops-paint-hide-show-all) is also available in the `Alt`-`W` pie menu.

Modifying visibility can also be done via the [Hide Gesture Tools](../tools/hide_tools.xhtml).
user: Give a detailed overview of Inherited Properties: syntax, arguments, return values, common patterns.

assistant: |  |  |
| --- | --- |
| - [`bpy_struct.id_data`](bpy.types.bpy_struct.html#bpy.types.bpy_struct.id_data "bpy.types.bpy_struct.id_data") - [`ViewerPathElem.type`](bpy.types.ViewerPathElem.html#bpy.types.ViewerPathElem.type "bpy.types.ViewerPathElem.type") | - [`ViewerPathElem.ui_name`](bpy.types.ViewerPathElem.html#bpy.types.ViewerPathElem.ui_name "bpy.types.ViewerPathElem.ui_name") |
user: What is Limitations and how is it used in Blender Python scripting?

assistant: The message bus system is triggered by updates via the RNA system. This means
that the following updates will result in a notification on the message bus:

- Changes via the Python API, for example `some_object.location.x += 3`.
- Changes via the sliders, fields, and buttons in the user interface.

The following updates do **not** trigger message bus notifications:

- Moving objects in the 3D Viewport.
- Changes performed by the animation system.

Changes done from `msgbus` callbacks are not included in related undo steps,
so users can easily skip their effects by using Undo followed by Redo.

Unlike properties `update` callbacks, message bus update callbacks are postponed
until all operators have finished executing.
Additionally, for each property the callback is only triggered once per update cycle,
even if the property was changed multiple times during that period.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Curve
:   Standard geometry input.

Selection
:   Whether to change the cyclic setting for each spline. *True* means the
    setting will be changed, *false* means it will stay the same.

Cyclic
:   Whether to connect the first and last control points of each spline.
user: Explain Object Color in complete detail according to the official Blender documentation.

assistant: # Object Color

The colors that the Workbench uses to render objects can be changed.

Material:
:   Use the color that can be set per material
    in the Viewport Display [Material](display_settings.xhtml#properties-material-viewport-display) panel.

Object:
:   Use the color that can be set per object
    in the Viewport Display [Object](display_settings.xhtml#properties-object-viewport-display) panel.

Random:
:   A random color will be selected for every object in the scene.

Attribute:
:   Display the active [Color Attribute](../../modeling/meshes/properties/object_data.xhtml#modeling-meshes-properties-object-data-color-attributes)
    of an object. When an object has no active Color Attribute it will be rendered in the color set
    in the Viewport Display [Object](display_settings.xhtml#properties-object-viewport-display) panel.

Texture:
:   Show the texture from the active [Image Texture Node](../shader_nodes/textures/image.xhtml)
    using the active UV map. If there is no active texture, the object will be
    rendered with the settings in the [Material](display_settings.xhtml#properties-material-viewport-display)’s
    Viewport Display panel.

Custom:
:   Render the whole scene using a single color. The color can be chosen.
user: Show practical ways to work with Fly Navigation in a Blender add-on or script – include code.

assistant: On activation, the cursor is centered inside a rectangle that defines a safe zone.
When the cursor is outside this zone, the view will rotate/pan.

### Usage

Move the mouse outside the safe zone in the direction you want to look.

Click `LMB` or press `Spacebar` to keep the current view and exit Fly navigation.
In case you want to go back to where you started, press `Esc` or `RMB`.

|  |  |
| --- | --- |
| `W`/`Up` | Accelerate forward. |
| `S`/`Down` | Accelerate backward. |
| `A`/`Left` | Accelerate left. |
| `D`/`Right` | Accelerate right. |
| `E` | Accelerate upward. |
| `Q` | Accelerate downward. |
| `MMB` | Drag to pan the view. Flying will pause while you’re doing this. |
| `WheelUp`/`NumpadPlus` | Increase the acceleration in the direction of motion. If there is no motion, start accelerating forward. |
| `WheelDown`/`NumpadMinus` | Decrease the acceleration in the direction of motion. If there is no motion, start accelerating backward. |
| `Alt` | Slow down as long as the key is held, until the view eventually comes to a standstill. |
| `Ctrl` | Disable rotation – while held, the view rotation doesn’t influence the flight direction. This allows you to fly past an object, keeping it centered in the view even as you fly away from it. |
| `X` | Toggle X axis correction. If enabled, the view will smoothly pitch to look at the horizon when the cursor is in the safe zone. |
| `Z` | Toggle Z axis correction. If enabled, the view will smoothly roll to an upright orientation. |
user: Explain Example in complete detail according to the official Blender documentation.

assistant: Glow Effect samples.

|  |  |  |  |
| --- | --- | --- | --- |
| <../../_images/grease-pencil_visual-effects_glow_original.png>   Original image. | <../../_images/grease-pencil_visual-effects_glow_luminance.png>   Mode: Luminance. | <../../_images/grease-pencil_visual-effects_glow_luminance-alpha.png>   Mode: Luminance (Glow Under). | <../../_images/grease-pencil_visual-effects_glow_color.png>   Mode: Color (Black lines). |
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Divergence
:   A float grid representing the divergence of the input field.

    Positive values correspond to regions where vectors spread apart (sources),
    while negative values represent regions where vectors converge (sinks).
user: Provide the full official documentation entry for Select Random, preserving all code examples.

assistant: Selects a random subset of points in the point cloud.

Seed
:   The [seed](../../glossary/index.xhtml#term-Seed) value used by the pseudo-random number generator.
    Adjusting this value changes which points are randomly selected.

Probability
:   A value between 0.0 and 1.0 that determines the percentage of points to be selected.
    For example, a value of 0.25 selects roughly 25% of the points.

This operator is useful for procedural modeling, scattering, or testing effects with a random distribution.
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: To use Open Shading Language (OSL) in Blender, follow these steps:

1. **Enable OSL Rendering**

   In the Render Properties enable
   [Open Shading Language](../render_settings/index.xhtml#bpy-types-cyclesrendersettings-shading-system).
2. **Add a Script Node**

   In the Shader Editor add [Script Node](../../shader_nodes/utilities/script.xhtml) then in the node’s properties:

   - Set the *Mode* to *Internal* to use a Blender text data-block, or
   - Set it to *External* to load a shader file from disk (either .osl or compiled .oso).

   For the internal mode, create a new text data-block in the Text Editor,
   then write or paste your OSL code there.

   Blender will compile the OSL source file automatically.
   If the source is .osl, it will be compiled into .oso bytecode.
   Compilation errors will be shown in the system console.
3. **Use Shader Outputs**

   Once compiled, the node’s outputs will reflect the `output` parameters defined in the OSL code.
   These outputs can be connected to any part of the material node tree.
user: Provide the full official documentation entry for GeometryNodeSDFGridMedian(GeometryNode), preserving all code examples.

assistant: # GeometryNodeSDFGridMedian(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.GeometryNodeSDFGridMedian(*GeometryNode*)
:   Apply median filter to a signed distance field. Reduces noise while preserving sharp features and edges in the distance field

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

assistant: # Mesh Boolean Node

[image reference removed]

The *Mesh Boolean Node* allows you to cut, subtract, and join the geometry of two inputs.
This node offers the same operations as the [Boolean modifier](../../../modifiers/generate/booleans.html).
user: Describe Insert Keyframe from the Blender manual or Python API, including usage steps and snippets.

assistant: There are several methods of adding new keys. Namely:

- In the 3D Viewport and Video Sequencer Preview, pressing `I` will key properties based on the
  [Default Key Channels](../../editors/preferences/animation.xhtml#bpy-types-preferencesedit-key-insert-channels) User Preferences.
- When a [Keying Set](keying_sets.xhtml) is active,
  it is used instead of reading the User Preferences.
- Hovering over a property and pressing `I` or with the context menu by `RMB`
  a property and choose *Insert Keyframe* from the menu.
- With the User Preference “Pie Menu on Drag” enabled, holding down `I`
  and moving the cursor will bring up a pie menu to insert one of Location, Rotation, Scale, and Available.

### Auto Keyframe

[image reference removed]

Timeline Auto Keyframe.

Auto Keyframe is the record button in the *Timeline* header. Auto Keyframe adds
keyframes automatically to the set frame if the value for transform type properties changes.

See [Timeline Keyframe Control](../animation_editors.xhtml#bpy-types-toolsettings-use-keyframe-insert-auto) for more info.
user: Give a detailed overview of BlendDataParticles(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # BlendDataParticles(bpy_struct)

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

*class* bpy.types.BlendDataParticles(*bpy_struct*)
:   Collection of particle settings

    new(*name*)
    :   Add a new particle settings instance to the main database

        Parameters:
        :   **name** (*string**,* *(**never None**)*) – New name for the data-block

        Returns:
        :   New particle settings data-block

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

    remove(*particle*, *\**, *do_unlink=True*, *do_id_user=True*, *do_ui_user=True*)
    :   Remove a particle settings instance from the current blendfile

        Parameters:
        :   - **particle** ([`ParticleSettings`](bpy.types.ParticleSettings.html#bpy.types.ParticleSettings "bpy.types.ParticleSettings"), (never None)) – Particle Settings to remove
            - **do_unlink** (*boolean**,* *(**optional**)*) – Unlink all usages of those particle settings before deleting them
            - **do_id_user** (*boolean**,* *(**optional**)*) – Decrement user counter of all data-blocks used by this particle settings
            - **do_ui_user** (*boolean**,* *(**optional**)*) – Make sure interface does not reference this particle settings

    tag(*value*)
    :   tag

        Parameters:
        :   **value** (*boolean*) – Value

    *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