PGCRYPT/OpenBlender_Train huggingface dataset:
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Strength
:   Strength of the bump mapping effect, interpolating between no bump mapping and full bump mapping.

Distance
:   Multiplier for the height value to control the overall distance for bump mapping.

Filter Width
:   Filter width in pixels, used to compute the bump mapping direction. For most textures
    the default value of 0.1 enables subpixel filtering for stable results. For stepwise
    textures a larger filter width can be used to get a bevel like effect on edges

Height
:   Scalar value giving the height offset from the surface at the shading point; this is where you plug in textures.

Normal
:   Standard normal input.
user: Give a detailed overview of Cameras: syntax, arguments, return values, common patterns.

assistant: # Cameras

A camera is an object that provides a means of rendering images from Blender.
It defines which portion of a scene is visible in the rendered image.

Cameras are invisible in renders, so they do not have any material or texture settings.
However, they do have *Object* and *Editing* setting panels available which are displayed
when a camera is the active object.
user: Show practical ways to work with Stiffness in a Blender add-on or script – include code.

assistant: For quad faces, the diagonal edges are used as springs.
This stops quad faces to collapse completely on collisions (what they would do otherwise).

Shear
:   Stiffness of the virtual springs created for quad faces.
user: Provide the full official documentation entry for References, preserving all code examples.

assistant: |  |  |
| --- | --- |
| - [`GeometryNodeCaptureAttribute.capture_items`](bpy.types.GeometryNodeCaptureAttribute.html#bpy.types.GeometryNodeCaptureAttribute.capture_items "bpy.types.GeometryNodeCaptureAttribute.capture_items") |  |
user: Show practical ways to work with Outputs in a Blender add-on or script – include code.

assistant: Projection
:   The 3D Viewport’s perspective or orthographic projection matrix.

View
:   The view direction and location of the 3D viewport.

Is Orthographic
:   Whether the viewport is using orthographic projection.
user: Provide the full official documentation entry for Report on the Web, preserving all code examples.

assistant: The process here is similar to reporting from within Blender, with the added step of specifying details about your
computer.

To initiate a bug report:

- Open the bug reporting template on [projects.blender.org](https://projects.blender.org/blender/blender/issues/new?template=.gitea/issue_template/bug.yaml).
- Give the bug a clear, easy-to-understand title - try to avoid long run-on sentences.
- Specify details about your computer and operating system in the **System Information** and **Blender Version**
  sections.
- Enter details about the steps to reproduce the bug. Bugs that are not consistently reproducible may be more
  difficult to track down, so provide any additional information that you can. Make sure to fill in the **Short
  description of error** and the **Exact steps for others to reproduce the error** sections.
- Attach any pictures if you feel they will help the developers understand the issue more clearly. Videos can also be
  attached, but please only do so if it is absolutely required to show the issue.
- If a crash occurs, attach a crash log as discussed below: [Attaching a Crash Log](#attaching-a-crash-log).
user: Explain Options in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The Hook modifier.

Object
:   The name of the object to hook vertices to.

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

    Useful when you want something other than a spherical field of influence.

    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.

Strength
:   Adjust this hooks influence on the vertices, were (0.0 to 1.0) (no change to fully follows the hook).

    Since multiple hooks can work on the same vertices, you can weight the influence of a hook using this property.

The following settings are only available in Edit Mode:

Reset
:   Recalculate and clear the offset transform of the hook.

Recenter
:   Set the hook center to the 3D cursor position.

Select
:   Select the vertices affected by this hook.

Assign
:   Assigns selected vertices to this hook.

### Falloff

Type
:   This can be used to adjust the kind of influence curve that the hook has on the mesh.
    You can also define a custom curve to get a much higher level of control.

Radius
:   The size of the hooks influence.

Uniform Falloff
:   This setting is useful when using hooks on scaled objects,
    especially in cases where non-uniform scale would stretch the result of the hook.

    This is especially useful for lattices, where it is common to use non-uniform scaling.
user: Show practical ways to work with GizmoGroupProperties(bpy_struct) in a Blender add-on or script – include code.

assistant: # GizmoGroupProperties(bpy_struct)

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

*class* bpy.types.GizmoGroupProperties(*bpy_struct*)
:   Input properties of a Gizmo Group

    bl_system_properties_get(*\**, *do_create=False*)
    :   DEBUG ONLY. Internal access to runtime-defined RNA data storage, intended solely for testing and debugging purposes. Do not access it in regular scripting work, and in particular, do not assume that it contains writable data

        Parameters:
        :   **do_create** (*boolean**,* *(**optional**)*) – Ensure that system properties are created if they do not exist yet

        Returns:
        :   The system properties root container, or None if there are no system properties stored in this data yet, and its creation was not requested

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

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

assistant: # Viewport Display

Rendered
:   Display hair as curves.

Path
:   Display just the end points of the hairs.

Steps
:   The number of segments (control points minus 1) of the hair strand.
    In between the control points the segments are interpolated. The number of control points is important:

    - For the soft body animation, because the control points are animated like vertices,
      so more control points mean longer calculation times.
    - For the interactive editing, because you can only move the control points
      (but you may recalculate the number of control points in *Particle Edit Mode*).
user: Explain Object Families in complete detail according to the official Blender documentation.

assistant: A “family” is a way to regroup several meta objects,
producing something very similar to having several metas inside the same object.

It is defined by the left part of an object’s name (the one before the first dot).
Remember, an object’s name is the one in the *Object Name* field, in most panels,
**not** the *Metaball Name* field, which is the meta data-block’s name…
For example, the *family* part of “MetaPlane.001” is `MetaPlane`.
Each meta object in the same “family” is associated with one another as discussed below.

[image reference removed]

Metaball family.

Families of metas are controlled by a *base* meta object which is identified by
an object name **without** a dot in it. For example,
if we have three metas called `MetaThing`, `MetaThing.001`,
`MetaThing.round`, the *base* meta object would be `MetaThing`.

The *base* meta object determines the basis, the resolution, the threshold,
*and* the transformations. It also has the material and texture area.
In a way, the *base* meta is the “owner” of the other metas in the family
(i.e. it is as if the other metas were “included” or joined into the base one).
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Image
:   The texture to distort.

UV
:   The UV coordinates at which to sample the texture. The UV coordinates can either come directly from the UV render
    pass (Cycles only, see [Cycles render passes](../../../render/layers/passes.xhtml)), or from the image coordinates
    in which case the Z component must be manually set to 1 (see example below).

### Sampling

Interpolation
:   Determines how pixel values are interpolated when scaling or transforming images.

    Nearest:
    :   Uses the value of the closest pixel with no smoothing.
        This is the fastest method and is well-suited for pixel art or low-resolution images
        where sharp, blocky edges are desirable.
        In animations, motion appears in single-pixel steps, which can cause visible jittering.

    Bilinear:
    :   Averages the values of surrounding pixels to create a smoother result than *Nearest*.
        Provides a good balance between performance and visual quality.

    Bicubic:
    :   Computes a weighted average of a larger neighborhood of pixels for even smoother results.
        Ideal for photographic images or gradients where preserving fine detail is important.

    Anisotropic:
    :   Adjusts interpolation based on the direction and scale of the transformation.
        Helps reduce blurring or aliasing when scaling at steep angles or uneven resolutions,
        especially useful in textures viewed at oblique angles or in detailed 3D projections.

Extension X/Y
:   The extension mode applied to the X axis.

    Clip:
    :   Areas outside of the image are filled with transparency.

    Extend:
    :   Areas outside of the image are filled with the closest boundary pixel in the image.

    Repeat:
    :   Areas outside of the image are filled with repetitions of the image.
user: Explain AssetWeakReference(bpy_struct) in complete detail according to the official Blender documentation.

assistant: # AssetWeakReference(bpy_struct)

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

*class* bpy.types.AssetWeakReference(*bpy_struct*)
:   Weak reference to some asset

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

    asset_library_type
    :   - `ALL`
          All Libraries – Show assets from all of the listed asset libraries.
        - `LOCAL`
          Current File – Show the assets currently available in this Blender session.
        - `ESSENTIALS`
          Essentials – Show the basic building blocks and utilities coming with Blender.
        - `CUSTOM`
          Custom – Show assets from the asset libraries configured in the Preferences.

        Type:
        :   enum in [`'ALL'`, `'LOCAL'`, `'ESSENTIALS'`, `'CUSTOM'`], default `'ALL'`, (readonly)

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

assistant: [image reference removed]

Three different objects created with the Displace modifier.
[Sample blend-file](https://archive.blender.org/wiki/2015/uploads/9/9e/Manual-Modifier-Displace-Example01.blend).

[image reference removed]

A slime animation created with the Displace modifier.
[Sample blend-file](https://archive.blender.org/wiki/2015/uploads/6/62/Manual-Modifier-Displace-Slime01.blend).
user: What is Gizmos and how is it used in Blender Python scripting?

assistant: # Gizmos

[image reference removed]

Grid with gizmo in the 3D viewport.

Gizmos allow changing inputs of Geometry Nodes directly in the 3D viewport.
This is often more intuitive than controlling the inputs in the modifier or node editor.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`Area.spaces`](bpy.types.Area.html#bpy.types.Area.spaces "bpy.types.Area.spaces") - [`AreaSpaces.active`](bpy.types.AreaSpaces.html#bpy.types.AreaSpaces.active "bpy.types.AreaSpaces.active") | - [`Context.space_data`](bpy.types.Context.html#bpy.types.Context.space_data "bpy.types.Context.space_data") |
user: Describe GeometryNodeSetShadeSmooth(GeometryNode) from the Blender manual or Python API, including usage steps and snippets.

assistant: # GeometryNodeSetShadeSmooth(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.GeometryNodeSetShadeSmooth(*GeometryNode*)
:   Control the smoothness of mesh normals around each face by changing the “shade smooth” attribute

    domain
    :   Type:
        :   enum in [Attribute Domain Edge Face Items](bpy_types_enum_items/attribute_domain_edge_face_items.html#rna-enum-attribute-domain-edge-face-items), default `'EDGE'`

    *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: Provide the full official documentation entry for Asset Library Type Items, preserving all code examples.

assistant: # Asset Library Type Items

ALL:
:   All Libraries.

    Show assets from all of the listed asset libraries.

LOCAL:
:   Current File.

    Show the assets currently available in this Blender session.

ESSENTIALS:
:   Essentials.

    Show the basic building blocks and utilities coming with Blender.

CUSTOM:
:   Custom.

    Show assets from the asset libraries configured in the Preferences.
user: Show practical ways to work with GeometryNodeToolSetSelection(GeometryNode) in a Blender add-on or script – include code.

assistant: # GeometryNodeToolSetSelection(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.GeometryNodeToolSetSelection(*GeometryNode*)
:   Set selection of the edited geometry, for tool execution

    domain
    :   Type:
        :   enum in [Attribute Domain Point Edge Face Curve Items](bpy_types_enum_items/attribute_domain_point_edge_face_curve_items.html#rna-enum-attribute-domain-point-edge-face-curve-items), default `'POINT'`

    selection_type
    :   - `BOOLEAN`
          Boolean – Store true or false selection values in edit mode.
        - `FLOAT`
          Float – Store floating point selection values. For mesh geometry, stored inverted as the sculpt mode mask.

        Type:
        :   enum in [`'BOOLEAN'`, `'FLOAT'`], default `'BOOLEAN'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Separate Images and how is it used in Blender Python scripting?

assistant: For images sequence only – Converts the strip into multiple strips, one strip for each frame.
Useful for slide shows and other cases where you want to bring in a set on non-continuous images.

Length
:   You have to specify the duration you want the resulting strips will be.
user: Show practical ways to work with Brush Settings in a Blender add-on or script – include code.

assistant: ### General

Hardness
:   Slightly higher by default. This makes the profile of the brush more noticeable.
    More info at [Hardness](../../brush/brush_settings.xhtml#bpy-types-brush-hardness)

Auto-Smooth
:   Enabled by default for a consistent smoothing effect.
    With lower brush strength (for example with lower pen pressure) the smoothing effect will be more noticeable
    and can be used to create and then blend/polish shapes in a single stroke.
    Enable Pressure to modulate the use of auto-smooth even more with pen inputs.
    More info at [Auto-Smooth](../../brush/brush_settings.xhtml#bpy-types-brush-auto-smooth-factor)
user: Explain Sample Grid Node in complete detail according to the official Blender documentation.

assistant: # Sample Grid Node

[image reference removed]

The *Sample Grid* node retrieves values from a voxel grid at given positions in space.
It evaluates the grid’s stored data (such as float, integer, boolean, or vector values)
and returns the interpolated result for each queried position.

This node is useful for reading data from grids created by other nodes
(e.g. *Mesh to SDF Grid*, *Field to Grid*, or *Points to SDF Grid*) and using
those values to drive procedural effects, geometry deformation, or shading.
user: Provide the full official documentation entry for Combine Color Node, preserving all code examples.

assistant: # Combine Color Node

[image reference removed]

The *Combine Color Node* combines an image from its composite color channels.
The node can combine multiple [Color Models](../../../glossary/index.html#term-Color-Model) depending on the Mode property.
user: What is Spatial Noise and how is it used in Blender Python scripting?

assistant: # Spatial Noise

The *Spatial Noise* modifier adds some spatial noise to the stroke.
Spatial noise displacements are added in the normal direction
(i.e. the direction perpendicular to the tangent line) evaluated at each stroke vertex.

Amplitude
:   How much the noise distorts the stroke.

Scale
:   How wide the noise is along the stroke.

Octaves
:   The level of detail of the noise.

Smooth
:   When enabled, apply some smoothing over the generated noise.

Pure Random
:   When disabled, the next generated random value depends on the previous one;
    otherwise they are completely independent. Disabling this setting gives a more “consistent” noise along a stroke.
user: Show practical ways to work with Tool Settings in a Blender add-on or script – include code.

assistant: Radius
:   Control newly added point’s radius.

Stroke Placement
:   The [Stroke Placement](../../draw/stroke_placement.xhtml) of newly added points.

Drawing Plane
:   The [Drawing Planes](../../draw/drawing_planes.xhtml) of newly added points.
user: Give a detailed overview of Introduction: syntax, arguments, return values, common patterns.

assistant: # Introduction

As with any other object, you edit your armature in *Edit Mode* `Tab`.

The set of bone editing tools is quite similar to the one for
[mesh](../../../../modeling/meshes/editing/introduction.xhtml) editing.

The different [poses](../../posing/index.xhtml)
you might create afterwards are based on this rest position.
So if you modify it in *Edit Mode*, all the poses already existing will also be modified.
Thus you should in general be sure that your armature is definitive before starting to
[skin](../../skinning/index.xhtml) and [pose](../../posing/index.xhtml) it!
user: Give a detailed overview of Adding & Removing Constraints: syntax, arguments, return values, common patterns.

assistant: To add a constraint, click on *Add Object/Bone Constraint* in the [Properties Editor](../../editors/properties_editor.html)
and choose a constraint type.

To remove a constraint, click its  button.

To move a constraint to a different position in the stack, drag its handle .

The [Constraints](../../scene_layout/object/editing/constraints.html) menu in the 3D Viewport offers further options
such as copying constraints and deleting all constraints in one go.
The [Track](../../scene_layout/object/editing/track.html) menu allows quickly adding a “track” (point at)
constraint.
user: Describe Options from the Blender manual or Python API, including usage steps and snippets.

assistant: As the modifier is only a container its actual options are configured in the *Physics Properties* tab.
See the [Soft Body Physics Properties](../../../physics/soft_body/settings/index.xhtml) for more information.
user: Provide the full official documentation entry for Minimize Stretch, preserving all code examples.

assistant: The *Minimize Stretch* tool, reduces UV stretch by minimizing the difference between
the angles in 3D and the angles in UV space.
This operation is similar to the [Relax](tools/relax.html)
tool with the *Geometry* *Method*, but uses a different algorithm.

Fill Holes
:   Just during *minimize stretch*, internal holes will be filled with temporary polygons
    to prevent stretching and overlaps of the surrounding UVs.

Blend
:   The fraction between 0 and 1 of the original UVs to blend in once the stretch is minimized.
    A blend of 0 is the fully minimized stretch. Blend of 0.5 is halfway between the original UVs
    and the minimize stretch UVs.

Iterations
:   More iterations result in smoother UVs, but take longer to process.
user: Explain Curve Normal Mode Items in complete detail according to the official Blender documentation.

assistant: # Curve Normal Mode Items

MINIMUM_TWIST:
:   Minimum Twist.

    Calculate normals with the smallest twist around the curve tangent across the whole curve.

Z_UP:
:   Z Up.

    Calculate normals perpendicular to the Z axis and the curve tangent. If a series of points is vertical, the X axis is used..

FREE:
:   Free.

    Use the stored custom normal attribute as the final normals.
user: Provide the full official documentation entry for Repository Management, preserving all code examples.

assistant: ### Subcommand: `repo-list`

usage:

```
blender --command extension repo-list [-h]
```

List all repositories stored in Blender’s preferences.

options:
:   `-h, --help`
    :   show this help message and exit

### Subcommand: `repo-add`

usage:

```
blender --command extension repo-add [-h] [--name NAME]
                                     [--directory DIRECTORY]
                                     [--url URL]
                                     [--access-token ACCESS_TOKEN]
                                     [--source SOURCE]
                                     [--cache BOOLEAN] [--clear-all]
                                     [--no-prefs]
                                     ID
```

Add a new local or remote repository.

positional arguments:
:   ID:
    :   The repository identifier.

options:
:   `-h, --help`
    :   show this help message and exit

    `--name NAME`
    :   The name to display in the interface (optional).

    `--directory DIRECTORY`
    :   The directory where the repository stores local files (optional).
        When omitted a directory in the users directory is automatically selected.

    `--url URL`
    :   The URL, for remote repositories (optional).
        When omitted the repository is considered “local”
        as it is not connected to an external repository,
        where packages may be installed by file or managed manually.

    `--access-token ACCESS_TOKEN`
    :   The access token to use for remote repositories which require a token.

    `--source SOURCE`
    :   The type of source in (‘USER’, ‘SYSTEM’).
        System repositories are managed outside of Blender and are considered read-only.

    `--cache BOOLEAN`
    :   Use package cache (default=1).

    `--clear-all`
    :   Clear all repositories before adding, simplifies test setup.

    `--no-prefs`
    :   Treat the user-preferences as read-only,
        preventing updates for operations that would otherwise modify them.
        This means removing extensions or repositories for example, wont update the user-preferences.

### Subcommand: `repo-remove`

usage:

```
blender --command extension repo-remove [-h] [--no-prefs] ID
```

Remove a repository.

positional arguments:
:   ID:
    :   The repository identifier.

options:
:   `-h, --help`
    :   show this help message and exit

    `--no-prefs`
    :   Treat the user-preferences as read-only,
        preventing updates for operations that would otherwise modify them.
        This means removing extensions or repositories for example, wont update the user-preferences.
user: How do I use Limit Location Constraint in Blender? Include parameters, examples, warnings and best practices.

assistant: # Limit Location Constraint

The *Limit Location* constraint forces an object or bone to stay above a coordinate,
below a coordinate, or between two coordinates along one or more axes.

Like other constraints, *Limit Location* only looks at the [origin](../../../scene_layout/object/origin.xhtml)
for objects; their geometry is not taken into account. This means that, if a cube’s origin
is at its center and a *Limit Location* constraint is added for the coordinates of a
floor plane, the cube will still be able to sink halfway into the plane.
user: How do I use Average Tracks in Blender? Include parameters, examples, warnings and best practices.

assistant: The Average Tracks operator creates a new tracking marker by averaging the data from the selected tracks.
This can be used to improve stability of tracking on blurry or non-very-sharp feature shapes.
The operator takes into account all [Marker properties](../sidebar/track/marker.html)
however, disabled markers do not affect the averaging.

Gaps in the original tracks will be linearly interpolated, to reduce result track jump.
Note that this only applies to gaps “in between”.
This means that if a track does not have markers in the beginning or end of it,
there is nothing to interpolate with and the resulting track will jump.

Keep Original
:   When enabled, the selected tracks are *not* deleted.
user: Describe Retime Node from the Blender manual or Python API, including usage steps and snippets.

assistant: # Retime Node

[image reference removed]

The *Retime* node controls the timing of input sequences, animations, or time-based effects
by offsetting, skipping, or repeating frames.
It can be used to create time remapping effects such as slow motion, fast-forward, looping,
or rhythmic stutter effects within a compositing setup.
user: Describe Recalculate Roll from the Blender manual or Python API, including usage steps and snippets.

assistant: Automatically align the roll of all selected bones to various points of reference.

Axis Orientation
:   Local (X, Z, -X, -Z) Tangent
    :   Align the roll of the selected bones relative to the axis defined by the bones and their parent.
        If a bone has no parent, use the first child as a point of reference instead,
        even if that child is not connected and another one is.
        For bones with no parent and no children, this option does nothing.

    Global (X, Y, Z, -X, -Y, -Z) Axis
    :   Align the roll of the selected bones such that their Z axis points towards the chosen global axis.

    Active Bone
    :   Align the roll of the selected bones such that their Z axis points where the active bone’s Z axis is currently
        pointing.

    View Axis
    :   Align the roll of the selected bones such that their Z axis points at the viewport’s forward/backward axis,
        basically the user’s eyes.

    Cursor
    :   Align the roll of the selected bones such that their Z axis points at the 3D cursor.

Flip Axis
:   Change the result by 180°.

Shortest Rotation
:   Change the result by 180° when needed in order to force the absolute roll value below 90°.
    For example, for an initial result of 160°, this option will instead flip that to -20°.
user: How do I use References in Blender? Include parameters, examples, warnings and best practices.

assistant: |  |  |
| --- | --- |
| - [`BevelModifier.custom_profile`](bpy.types.BevelModifier.html#bpy.types.BevelModifier.custom_profile "bpy.types.BevelModifier.custom_profile") - [`Curve.bevel_profile`](bpy.types.Curve.html#bpy.types.Curve.bevel_profile "bpy.types.Curve.bevel_profile") | - [`ToolSettings.custom_bevel_profile_preset`](bpy.types.ToolSettings.html#bpy.types.ToolSettings.custom_bevel_profile_preset "bpy.types.ToolSettings.custom_bevel_profile_preset") |
user: How do I use Examples in Blender? Include parameters, examples, warnings and best practices.

assistant: Below are some common curves you can use to achieve desired effects.

[image reference removed]

From left to right: 1. Lighten shadows 2. Negative 3. Decrease contrast 4. Posterize.

### Color Correction using Curves

[image reference removed]

Color correction with curves.

In this example, the image has too much red in it,
so we run it through an *RGB Curves* node and reduce the Red channel.

The documentation for the [Mix Color Node](../../../compositing/types/color/mix_color.xhtml) has an additional
example about fixing overexposure.

### Color Correction using Black/White Levels

[image reference removed]

Color correction with Black/White Levels.

Manually adjusting the RGB curves for color correction can be difficult.
Another option for color correction is to use the Black and White Levels instead,
which really might be their main purpose.

In this example,
the White Level is set to the color of a bright spot of the sand in the background,
and the Black Level to the color in the center of the fish’s eye.
To do this efficiently it is best to bring up the Image Editor showing the original input image.
You can then use the levels’ color picker to easily choose
the appropriate colors from the input image, zooming into pixel level if necessary.
The result can be fine-tuned with the R, G, and B curves like in the previous example.

The curve for C is used to compensate for the increased contrast that is a side effect of
setting Black and White Levels.

### Effects

[image reference removed]

Changing colors by inverting the red channel.
user: Explain Merge by Distance Node in complete detail according to the official Blender documentation.

assistant: # Merge by Distance Node

[image reference removed]

The *Merge by Distance* node merges selected mesh vertices or point cloud points within a given distance,
merging surrounding geometry where necessary. This operation is similar to the [Merge by Distance](../../../meshes/editing/mesh/cleanup.html#bpy-ops-mesh-remove-doubles)
operator or the [Weld Modifier](../../../modifiers/generate/weld.html).
user: Provide the full official documentation entry for Mesh Island Node, preserving all code examples.

assistant: # Mesh Island Node

[image reference removed]

The *Mesh Island* node outputs information about separate connected regions, or “islands” of a mesh.
Whenever two vertices are connected together by an edge, they are considered as part of the same island,
and will have the same *Island Index* output.

This node’s behavior is similar to the [Select Linked](../../../meshes/selecting/linked.html#bpy-ops-mesh-select-linked) operator
in edit mode, or the *Random per Island* output of the
[Geometry shader node](../../../../render/shader_nodes/input/geometry.html).
user: Give a detailed overview of Usage: syntax, arguments, return values, common patterns.

assistant: Even with a correct compositing setup with Image, Z and Speed nodes all linked to the appropriate passes,
there may still be artifacts. The 2D render passes does not contain 3D information,
and so the information what is behind a moving object or outside the camera view is lost.

Better results can be achieved by rendering the scene into multiple render layers,
applying vector blur to each render layer, and then compositing the results together.
Typically an animated character would be rendered in a separate render layer than the background set.
Especially if hair or transparency is involved this is important.

For other artifacts it can help to slightly blur the Speed pass or to set a Maximum Speed limit.
This helps to smoothen out the motion, but too much blurring leads to its own problems.
user: Show practical ways to work with Split in a Blender add-on or script – include code.

assistant: Selection `Y`
:   Splits (disconnects) the selection from the rest of the UV.
    The border edge to any non-selected elements are duplicated.

    Note that the “copy” is left exactly at the same position as the original,
    so you must move it to see it clearly.
user: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: Grease Pencil
:   Grease Pencil geometry input.

Selection
:   A boolean field that controls which stroke points are affected.
    Only elements where the selection is true will be modified.
    By default, all strokes are affected.

Softness
:   The softness value to assign. Higher values increase the fade at stroke edges.
    This input sets the value for the `softness` attribute.
user: Provide the full official documentation entry for Examples, preserving all code examples.

assistant: Combined with the [Index of Nearest](../modeling/geometry_nodes/geometry/sample/index_of_nearest.xhtml),
this can be used for a number of sphere-based simulations.

[image reference removed]

Index of Nearest sample file CC-BY Sean Christofferson.
user: Describe How to Bundle Wheels from the Blender manual or Python API, including usage steps and snippets.

assistant: Python wheels (`*.whl`) can be bundled using the following steps.

Downloading Wheels
:   Download the wheel to the directory `./wheels/`.

    For wheels that are platform independent this example downloads `jsmin`:

    ```
    pip wheel jsmin -w ./wheels
    ```

    For wheels that contain binary compiled files, wheels for all supported platforms should be included:

    This example downloads `pillow` - the popular image manipulation module.

    ```
    pip download pillow --dest ./wheels --only-binary=:all: --python-version=3.11 --platform=macosx_11_0_arm64
    pip download pillow --dest ./wheels --only-binary=:all: --python-version=3.11 --platform=manylinux_2_28_x86_64
    pip download pillow --dest ./wheels --only-binary=:all: --python-version=3.11 --platform=win_amd64
    ```

    The available platform identifiers are listed on
    [pillow’s download page](https://pypi.org/project/pillow/#files).

Update the Manifest
:   In `blender_manifest.toml` include the wheels as a list of paths, e.g.

    ```
    wheels = [
       "./wheels/pillow-10.3.0-cp311-cp311-macosx_11_0_arm64.whl",
       "./wheels/pillow-10.3.0-cp311-cp311-manylinux_2_28_x86_64.whl",
       "./wheels/pillow-10.3.0-cp311-cp311-win_amd64.whl",
    ]
    ```

    Now installing the package will extract the wheel into the extensions own `site-packages` directory.

Running
:   Once the extension has been installed you can check the module is being loaded by importing it in the
    Python console and printing it’s location:

    ```
    import PIL
    print(PIL.__file__)
    ```
user: Give a detailed overview of Position Offsetting: syntax, arguments, return values, common patterns.

assistant: The constraint uses its owner’s position and rotation in [World Space](../../../glossary/index.html#term-World-Space)
as offsets to the position and rotation on the Curve. If *Follow Curve*
is disabled, the offsets are added in the Curve’s [Local Space](../../../glossary/index.html#term-Local-Space).
If it’s enabled, the offsets are added in the space of the current curve point,
with the global Y axis corresponding to the tangent direction.

In both cases, the Curve’s scale acts as a multiplier for the position offset.

|  |  |  |
| --- | --- | --- |
| ../../../_images/animation_constraints_relationship_follow-path_offset-no-constraint.png   Before adding the constraint, the cone is offset along the world Y axis. | ../../../_images/animation_constraints_relationship_follow-path_offset-no-follow-curve.png   After adding the constraint, the cone is offset along the Curve’s local Y axis. | ../../../_images/animation_constraints_relationship_follow-path_offset-follow-curve.png   When enabling Follow Curve, the cone is offset along the curve point’s tangent. |

To have the owner perfectly positioned and aligned on the Curve, ensure its
world position and rotation are both zero. This can be done by pressing `Alt`-`G`
and `Alt`-`R` respectively.
user: Give a detailed overview of Render Layers Node: syntax, arguments, return values, common patterns.

assistant: # Render Layers Node

[image reference removed]

Renders a [View Layer](../../../../render/layers/introduction.xhtml) and reads its
[Passes](../../../../render/layers/passes.xhtml) into the compositing node graph.
user: Provide the full official documentation entry for Local Cache Directory, preserving all code examples.

assistant: The cache directory is used to store persistent caches locally. Currently it is only used for the indexing of
[Asset Libraries](../files/asset_libraries/introduction.xhtml#what-is-asset-library). The operating system is not expected to clear this automatically.

The following path will be used:

- Linux:
  :   `$XDG_CACHE_HOME/blender/` if `$XDG_CACHE_HOME` is set, otherwise `$HOME/.cache/blender/`
- macOS:
  :   `/Library/Caches/Blender/`
- Windows:
  :   `%USERPROFILE%\AppData\Local\Blender Foundation\Blender\Cache\`
user: Show practical ways to work with Release Checklist in a Blender add-on or script – include code.

assistant: - Create a release branch (`blender-3.2-release/`)
- Update the splash image: `interface_splash_current.png` in the release branch.
- Increase the `conf.py: blender_version` variable in the trunk version.
user: What is Tools for Scene Orientation and Stabilization and how is it used in Blender Python scripting?

assistant: After solve, you need to orient the real scene in the 3D scene for more convenient compositing.
There are tools to define the floor, the scene origin, and the X/Y axes to perform scene orientation.

Sometimes, the video footage includes spurious jumps and tilting movements, like e.g. when using a hand-held camera.
Based on some tracked image elements,
the [2D Stabilization](clip/sidebar/stabilization/index.xhtml)
is able to detect and compensate such movements to improve the quality of the final result.
user: Provide the full official documentation entry for Selecting Multiple Data-Blocks, preserving all code examples.

assistant: Extend the selection one data-block at a time using `Ctrl`-`LMB`.
Each data-block added to the selection this way will be made the active data-block.

Select a range of elements from the active element using `Shift`-`LMB`.
To select a range without deselecting the previous selection, use `Shift`-`Ctrl`-`LMB`.

Select all children of an item by double clicking the item’s icon.

A click and drag from any location in the Outliner other than a name or icon will begin a box selection.
Use `Shift` to add and `Ctrl` to subtract from existing selections with box select.
Box select can also be started with `B`.

To select all items use `A`; `Alt`-`A` will deselect all items.

The keyboard arrow keys can be used to navigate and select in the Outliner.
Keyboard selection and navigation starts from the active data-block.

|  |  |
| --- | --- |
| `Up` | Select the previous element in the list. |
| `Down` | Select the next element in the list. |
| `Shift`-`Up` | Select the previous element without deselecting. |
| `Shift`-`Down` | Select the next element without deselecting. |
| `Left` | Close the data-block or select the parent. |
| `Right` | Open the data-block to view children or select the first child. |
| `Shift`-`Left` | Close this and all child data-blocks. |
| `Shift`-`Right` | Open this and all child data-blocks. |
user: What is Face Set Node and how is it used in Blender Python scripting?

assistant: # Face Set Node

[image reference removed]

The *Face Set Node* outputs which [face set](../../../../sculpt_paint/sculpting/introduction/visibility_masking_face_sets.xhtml#face-sets) a face is in,
and whether or not face sets exist in the mesh at all.

The corresponding data flow node is the [Set Face Set Node](../write/set_face_set.xhtml).
user: What is NODE_AST_compositor(AssetShelf) and how is it used in Blender Python scripting?

assistant: # NODE_AST_compositor(AssetShelf)

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

*class* bpy.types.NODE_AST_compositor(*AssetShelf*)
:   *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 Inputs: syntax, arguments, return values, common patterns.

assistant: Mesh
:   The input mesh to be converted into a density grid.
    The mesh defines the surface that will be voxelized.

Density
:   The scalar value assigned to voxels inside the mesh.
    Typically a value of `1.0` for full density and `0.0` for empty space,
    though any scalar range can be used to represent material thickness or opacity.

Voxel Size
:   The size of each voxel in object space units.
    Smaller values produce higher-resolution grids with more detail, while
    larger values reduce detail but improve performance and memory efficiency.

Gradient Width
:   The width of the gradient region inside the mesh.
    Controls how smoothly the density falls off from the interior toward the
    exterior. Larger values create a broader transition, while smaller values
    produce a sharper surface boundary.
user: Explain Inputs in complete detail according to the official Blender documentation.

assistant: Image
:   Standard color input.

Key Color
:   The background color usually selected using the color picker and the original image.

Minimum
:   An angle on the color wheel that represents how tolerant the keying color is. Larger angles allow for larger
    variation in the keying color to be considered background pixels.

Maximum
:   Controls the level that is considered the pure background. Higher cutoff levels mean more pixels will be
    100% transparent if they are within the angle tolerance.

Falloff
:   Increase to make nearby pixels partially transparent producing a smoother blend along the edges.
user: How do I use Tool Settings in Blender? Include parameters, examples, warnings and best practices.

assistant: Offset
:   How far items are shifted from their original location.

Axis
:   Defines one axis of the imaginary shearing plane.

Axis Orthographic
:   Defines the other axis of the imaginary shearing plane.

Orientation
:   See [Transform Orientations](../../../../../editors/3dview/controls/orientation.xhtml).

Proportional Editing
:   See [Proportional Editing](../../../../../editors/3dview/controls/proportional_editing.xhtml).