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

assistant: # Bevel Edges

The *Bevel* tool allows you to create chamfered or rounded corners on geometry.
A bevel is an effect that smooths out edges and corners.

Real world edges are very seldom exactly sharp.
Not even a knife blade edge can be considered perfectly sharp.
Most edges are intentionally beveled for mechanical and practical reasons.

Bevels are also useful for giving realism to non-organic models. In the real world,
the blunt edges on objects catch the light and change the shading around the edges.
This gives a solid, realistic look,
as opposed to unbeveled objects which can look too perfect.

[image reference removed]

Cubes with and without bevel.
user: Explain Beautify Faces in complete detail according to the official Blender documentation.

assistant: # Beautify Faces

*Beautify Faces* works only on selected existing faces.
It rearrange selected triangles to obtain more “balanced” ones (i.e. less long thin triangles).

Max Angle
:   An angle delimiter option to limit edge rotation to flat surfaces.

|  |  |
| --- | --- |
| ../../../../_images/modeling_meshes_editing_face_beautify-faces_before.png   Text converted to a mesh. | ../../../../_images/modeling_meshes_editing_face_beautify-faces_after.png   Result of Beautify Faces. |
user: Provide the full official documentation entry for Index Switch Node, preserving all code examples.

assistant: # Index Switch Node

[image reference removed]

The *Index Switch* node outputs one of its inputs based on an integer *Index* value.
Only the selected input is evaluated, making this node useful for switching between
multiple data inputs efficiently.
user: Give a detailed overview of EffectorWeights(bpy_struct): syntax, arguments, return values, common patterns.

assistant: # EffectorWeights(bpy_struct)

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

*class* bpy.types.EffectorWeights(*bpy_struct*)
:   Effector weights for physics simulation

    all
    :   All effector’s weight

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

    apply_to_hair_growing
    :   Use force fields when growing hair

        Type:
        :   boolean, default False

    boid
    :   Boid effector weight

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

    charge
    :   Charge effector weight

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

    collection
    :   Limit effectors to this collection

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

    curve_guide
    :   Curve guide effector weight

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

    drag
    :   Drag effector weight

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

    force
    :   Force effector weight

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

    gravity
    :   Global gravity weight

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

    harmonic
    :   Harmonic effector weight

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

    lennardjones
    :   Lennard-Jones effector weight

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

    magnetic
    :   Magnetic effector weight

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

    smokeflow
    :   Fluid Flow effector weight

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

    texture
    :   Texture effector weight

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

    turbulence
    :   Turbulence effector weight

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

    vortex
    :   Vortex effector weight

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

    wind
    :   Wind effector weight

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

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   type
user: What is Make Vertex Parent and how is it used in Blender Python scripting?

assistant: Creates a [parent-child relationship](../../../scene_layout/object/editing/parent.xhtml#object-parenting) that makes a particular object
follow the selected control point(s).

While in Edit Mode, select another object by either clicking it with `Ctrl`-`LMB` in the
3D Viewport or by selecting it the [Outliner](../../../editors/outliner/introduction.xhtml).
Then, select one or three control points of the surface and press `Ctrl`-`P`.
Parenting an object to three control points will make it follow their averaged position.
user: Give a detailed overview of Extrude: syntax, arguments, return values, common patterns.

assistant: # Extrude

This operators shown in this menu are dependent of what part of a mesh is currently selected.
Many of the operators are also available in the [Vertex](../vertex/index.xhtml),
[Edge](../edge/index.xhtml), and [Face](../face/index.xhtml) menus.
user: Show practical ways to work with Python Scripting in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| `Ctrl`-`C` | When pressed while hovering over an [operator button](../controls/buttons/buttons.html#ui-operator-buttons), copies its Python command to the clipboard. This command can then be used in the [Python Console](../../editors/python_console.html) or in the [Text Editor](../../editors/text_editor.html) when writing scripts. |
| `Shift`-`Ctrl`-`C` | When pressed while hovering over a field, copies its relative data path (also available from the context menu). Useful when writing drivers or scripts. |
| `Shift`-`Ctrl`-`Alt`-`C` | When pressed while hovering over a field, copies its full data path. |
user: What is Useful Constructs and how is it used in Blender Python scripting?

assistant: - `|BLENDER_VERSION|`:
  Inserts the current Blender version number automatically. e.g. “4.5”.
- `|BLENDER_VERSION_LABEL|`:
  Inserts the current Blender version label automatically. e.g. “4.5 LTS”.
- `` :abbr:`SSAO (Screen Space Ambient Occlusion)` ``:
  Abbreviation displays the full text on hover.
- `` :term:`Manifold` ``:
  Links to the corresponding entry in the [Glossary](../../../glossary/index.xhtml).
- `` :bl-icon:`icon_name` ``:
  Include Blender icons as inline text, see the full list at [Icons](icons.xhtml).
user: Provide the full official documentation entry for Conventions Used in This Manual, preserving all code examples.

assistant: ### Keyboard

Hotkeys are shown in this manual as they appear on a keyboard. For example:

|  |  |
| --- | --- |
| `G` | The “G” key by itself (as though you were typing a lowercase “g”). |
| `Shift`, `Ctrl`, `Alt` | Modifier keys. |
| `Ctrl`-`W`, `Shift`-`Alt`-`A` | Keys pressed simultaneously. |
| `0` to `9` | The number keys on the row above the letters. |
| `Numpad0` to `Numpad9`, `NumpadPlus` | The keys on the separate numeric keypad. |

Other keys are referred to by name, such as `Esc`, `Tab`,
and `F1` through `F12`.
Arrow keys are written as `Left`, `Right`, and so on.

### Mouse

Mouse buttons and wheel actions are referred to as:

|  |  |
| --- | --- |
| `LMB` | Left Mouse Button |
| `RMB` | Right Mouse Button |
| `MMB` | Middle Mouse Button |
| `Wheel`, `WheelUp`, `WheelDown` | Scrolling the mouse wheel. |
user: What is Goal and how is it used in Blender Python scripting?

assistant: A “goal” is a shape that a soft body object tries to conform to.
It acts like a pin on a chosen set of vertices, controlling how much of an effect soft body has on them.

Enabling *Soft Body Goal* tells Blender to use the position (or animated position) of a vertex in the simulation.
Animating the vertices can be done in all the usual ways (F-Curves, armatures, parents, lattices, etc.)
before the soft body simulation is applied. The “goal” is the desired end position for vertices.
How a soft body tries to achieve this goal can be defined using stiffness forces and damping.

See the [Goal Settings](../settings/goal.xhtml) for details.

### Goal Strength

The *Goal Strength* defines how much motion from an animation system gets applied.

A *Goal* value of 1.0 means no soft body simulation,
the object act like any regular animated object (i.e. the vertex is kept at its original position).
When setting *Goal* to 0.0 (or no goal), the vertex is only influenced by physical laws
according to soft body simulation.

By setting goal values between 0.0 and 1.0,
you can blend between having the object affected only by the animation system,
and having the object affected only by the soft body effect.

Goal also serves as a memory, to make sure soft objects don’t deform too much,
ending up in the non-soft animated shape. Using the *Vertex Group* weight system,
you can define a *Goal* weight per vertex. To make this look more natural,
spring forces can be defined to control how far vertices can move from their original position.

Often [Weight Paint](../../../sculpt_paint/weight_paint/index.xhtml#painting-weight-index) is used to adjust the weight comfortably.
For non-mesh objects the *Weight* parameter of their vertices/control points is used instead;
Use the Context menu in Edit Mode or the *Transform* panel in the Sidebar region.
The weight of *Hair* particles can also be painted in [Particle Edit Mode](../../particles/mode.xhtml).
user: Describe MetaElement(bpy_struct) from the Blender manual or Python API, including usage steps and snippets.

assistant: # MetaElement(bpy_struct)

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

*class* bpy.types.MetaElement(*bpy_struct*)
:   Blobby element in a metaball data-block

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

    hide
    :   Hide element

        Type:
        :   boolean, default False

    radius
    :   Type:
        :   float in [0, inf], default 0.0

    rotation
    :   Normalized quaternion rotation

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

    select
    :   Select element

        Type:
        :   boolean, default False

    size_x
    :   Size of element, use of components depends on element type

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

    size_y
    :   Size of element, use of components depends on element type

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

    size_z
    :   Size of element, use of components depends on element type

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

    stiffness
    :   Stiffness defines how much of the element to fill

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

    type
    :   Metaball type

        Type:
        :   enum in [Metaelem Type Items](bpy_types_enum_items/metaelem_type_items.html#rna-enum-metaelem-type-items), default `'BALL'`

    use_negative
    :   Set metaball as negative one

        Type:
        :   boolean, default False

    use_scale_stiffness
    :   Scale stiffness instead of radius

        Type:
        :   boolean, default False

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

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

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

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

        Returns:
        :   The class or default when not found.

        Return type:
        :   [type](#bpy.types.MetaElement.type "bpy.types.MetaElement.type")
user: How do I use Example in Blender? Include parameters, examples, warnings and best practices.

assistant: The example below creates a cone at each vertex of a “cube,” aligned to the neighboring edge
that’s the most vertical.

First, we calculate a “verticality score” for each of the cube’s edges. To do this, we subtract the
positions of its vertices to get its direction vector, which we normalize and use to calculate
the dot product with the Z axis. The absolute value of that gives us a number between 0 and 1,
where 0 means fully horizontal and 1 means fully vertical.

Because the edges will be sorted by ascending weight, we set weight = 1 - verticality.
This way, the most vertical connected edge of each vertex will have the lowest weight
and come first in the list.

Next, in the point domain, we need to calculate the rotation of each cone.
By using the [Align Rotation to Vector Node](../../utilities/rotation/align_rotation_to_vector.xhtml),
the problem gets simplified and we only need to calculate a direction vector.

The direction vector of each cone is the centerpoint of the most vertical neighboring edge
minus the position of the vertex. Finding that most vertical neighboring edge is where the
*Edges of Vertex* node comes in: for each vertex, it sorts the connected edges by their
weight and pick the first one (because the Sort Index is 0). Once we have the edge’s index,
we use the [Evaluate at Index Node](../../utilities/field/evaluate_at_index.xhtml) to retrieve its
centerpoint.

With the rotations of the cones calculated, we use the
[Instance on Points Node](../../instances/instance_on_points.xhtml) to create them.

[image reference removed]

Example node setup. (Right-click and choose “Open image in new tab” to see a larger version.)

[image reference removed]

The resulting geometry.
user: What is GeometryNodeSDFGridMeanCurvature(GeometryNode) and how is it used in Blender Python scripting?

assistant: # GeometryNodeSDFGridMeanCurvature(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.GeometryNodeSDFGridMeanCurvature(*GeometryNode*)
:   Apply mean curvature flow smoothing to a signed distance field. Evolves the surface based on its mean curvature, naturally smoothing high-curvature regions more than flat areas

    *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 Your First Armature and how is it used in Blender Python scripting?

assistant: In order to see what we are talking about, let us try to add the default armature in Blender.

(Note that armature editing details are explained in
the [armatures editing section](bones/editing/index.xhtml).)

Open a default scene, then:

1. Delete all objects in the scene.
2. Make sure the cursor is in the world origin with `Shift`-`C`.
3. Press `Numpad1` to see the world in Front view.
4. Add a *Single Bone* (Add ‣ Armature).
5. Press `NumpadPeriod` to see the armature at maximum zoom.

[image reference removed]

The default armature.
user: Provide the full official documentation entry for Quick Start, preserving all code examples.

assistant: Open the terminal application,
and run the executable within the app bundle, with commands like this:

```
cd /Applications/Blender.app/Contents/MacOS
./Blender
```

If you need to do this often, you can add this directory to your `PATH`.

For that you can run the following procedure:

1. Open up a Terminal.
2. Run the following command: `sudo nano /etc/paths`.
3. Enter your password, when prompted.
4. Go to the bottom of the file, and enter `/Applications/Blender.app/Contents/MacOS`.
5. Enter `Ctrl`-`X` to quit.
6. Enter `Y` to save the modified buffer.

If you then open a new terminal, the following command will work:

```
Blender
```
user: Show practical ways to work with Inputs in a Blender add-on or script – include code.

assistant: A
:   The first integer input. Used by all operations.

B
:   The second integer input. Only used by operations that require two inputs (*And*, *Or*, *Exclusive Or*).

Shift
:   The number of bits to shift or rotate. Used only for *Shift* and *Rotate* operations.
user: Give a detailed overview of Color Key Node: syntax, arguments, return values, common patterns.

assistant: # Color Key Node

[image reference removed]

The *Color Key* node is used for chroma keying—removing parts of an image based on color.
It is commonly used to remove backgrounds like green screens or blue screens from footage,
creating a matte where selected colors become transparent.
user: How do I use Inputs in Blender? Include parameters, examples, warnings and best practices.

assistant: Geometry
:   The input geometry containing the hair curves to be attached to the surface.

Surface Input Type
:   Defines how the surface geometry is provided for attachment.
    The geometry input takes priority if both are connected.

    Object:
    :   Use an object reference as the target surface.

    Geometry:
    :   Use a geometry input directly connected to the surface mesh.

Surface
:   The surface object or geometry used as the attachment target.
    Its transforms must match the modifier object for proper alignment.

Surface UV Map
:   The UV map used to determine the attachment points on the surface mesh.
    These coordinates are stored per curve to maintain attachment consistency.

Surface Rest Position
:   When enabled, sets the surface mesh into its rest position before attachment.
    This ensures consistency when later deforming curves along the same surface.

Sample Attachment UV
:   Samples the *Surface UV Map* at the attachment point and stores the UV coordinates
    for each curve.
    This allows later nodes to access or reuse the attachment data.

Snap to Surface
:   Projects the root of each curve onto the closest point of the surface mesh,
    ensuring that all roots lie directly on the surface.

Align to Surface Normal
:   Rotates each curve so that its root direction aligns with the surface normal.
    This typically requires guide data or consistent curve orientation to produce
    stable results.

Blend along Curve
:   Blends the deformation or alignment effect gradually along each curve,
    from root to tip, instead of applying it uniformly.
user: How do I use TextureNodeCompose(TextureNode) in Blender? Include parameters, examples, warnings and best practices.

assistant: # TextureNodeCompose(TextureNode)

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

*class* bpy.types.TextureNodeCompose(*TextureNode*)
:   *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: Describe Inputs from the Blender manual or Python API, including usage steps and snippets.

assistant: The inputs are dynamic, they become available if needed depending on the node properties.

Vector
:   Texture coordinate to evaluate the noise at;
    defaults to *Generated* texture coordinates if the socket is left unconnected.

W
:   Texture coordinate to evaluate the noise at.

Scale
:   Scale of the base noise octave.

Detail
:   Number of noise octaves.
    The fractional part of the input is multiplied by the magnitude of the highest octave.
    Higher number of octaves corresponds to a higher render time.

Roughness
:   Blend between a smoother noise pattern, and rougher with sharper peaks.

Lacunarity
:   The difference between the scale of each two consecutive octaves.
    Larger values corresponds to larger scale for higher octaves.

Offset
:   An added offset to each octave, determines the level where the highest octave will appear.

Gain
:   An extra multiplier to tune the magnitude of octaves.

Distortion
:   Amount of distortion.
user: Provide the full official documentation entry for Subdivide, preserving all code examples.

assistant: # Subdivide

You can subdivide bones, to get two or more bones where there was just one bone.
The tool will subdivide all selected bones, preserving the existing relationships:
the bones created from a subdivision always form a connected chain of bones.

To create an arbitrary number of bones from each selected bone
in the Subdivide Multi [Adjust Last Operation](../../../../interface/undo_redo.xhtml#bpy-ops-screen-redo-last) panel.

Number of Cuts
:   Specifies the number of cuts. As in mesh editing,
    if you set *n* cuts, you will get *n* + 1 bones for each selected bone.

Subdivision example.

|  |  |
| --- | --- |
| ../../../../_images/animation_armatures_bones_editing_subdivide_example-1.png   An armature with one selected bone, just before multi-subdivision. | ../../../../_images/animation_armatures_bones_editing_subdivide_example-2.png   The selected bone has been “cut” two times, giving three sub-bones. |
user: Describe Start Tweaking Strips Actions (Lower Stack) from the Blender manual or Python API, including usage steps and snippets.

assistant: Enters Tweak Mode for the selected strip’s action, making its keyframes available for editing.
Mutes any tracks above the current one so that they don’t influence the animation while making changes.

When you’re done, click Strip ‣ Stop Tweaking Strips Actions or press `Tab`.
user: How do I use Set Instance Transform Node in Blender? Include parameters, examples, warnings and best practices.

assistant: # Set Instance Transform Node

[image reference removed]

The *Set Instance Transform* node [Transforms](../../../glossary/index.xhtml#term-Transform) geometry instances
using a [Transformation Matrix](../../../glossary/index.xhtml#term-Transformation-Matrix).

The [Instances](../instances.xhtml) page contains more information about geometry instances.
user: What is Options and how is it used in Blender Python scripting?

assistant: Limits
:   X Axis
    :   Enables/disables limit translation around X axis.

        Lower
        :   Lower limit of X axis translation.

        Upper
        :   Upper limit of X axis translation.

    X Angle
    :   Enables/disables limit rotation around X axis.

        Lower
        :   Lower limit of X axis rotation.

        Upper
        :   Upper limit of X axis rotation.
user: How do I use Laptops in Blender? Include parameters, examples, warnings and best practices.

assistant: Laptops often have two GPUs for power saving purposes. One slower onboard GPU integrated into the main CPU (typically
Intel or AMD) that uses lower power, and one faster dedicated GPU for better performance (AMD or NVIDIA) that uses
more power.

For the best performance, the dedicated GPU should be used for Blender. Which GPU to use for which application can be
configured in your graphics driver or operating system settings.

If there is a graphics glitch or crash specific to the onboard GPU, then using the dedicated GPU can help avoid that.
Or vice versa, if the dedicated GPU causes issues, then using the onboard graphics can help.
user: Explain Example in complete detail according to the official Blender documentation.

assistant: [image reference removed]

The above example generates a pyramid with a configurable number of levels.
Each iteration creates a cube, brings it into position, and
[joins](../geometry/join_geometry.xhtml) it with the result of
the previous iteration.
user: Give a detailed overview of Attribute Domain Items: syntax, arguments, return values, common patterns.

assistant: # Attribute Domain Items

POINT:
:   Point.

    Attribute on point.

EDGE:
:   Edge.

    Attribute on mesh edge.

FACE:
:   Face.

    Attribute on mesh faces.

CORNER:
:   Face Corner.

    Attribute on mesh face corner.

CURVE:
:   Spline.

    Attribute on spline.

INSTANCE:
:   Instance.

    Attribute on instance.

LAYER:
:   Layer.

    Attribute on Grease Pencil layer.
user: What is Inputs and how is it used in Blender Python scripting?

assistant: Rotation
:   The [Euler](../../../../glossary/index.xhtml#term-Euler) rotation to align.

Factor
:   Determines how much the points are rotated towards the vector.
    Zero effectively disables the node and one means that the points are aligned with the vector perfectly.

Vector
:   The direction vector that points should be rotated to.
    The vector is in the local space of the object that is being modified.
    When it is all zeros for a point, it is not rotated at all.
user: How do I use Rip Vertices and Extend in Blender? Include parameters, examples, warnings and best practices.

assistant: # Rip Vertices and Extend

This tool takes any number of selected vertices and duplicate-drags them along the closest edge to the mouse.
When extending an edge loop, it extends the vertices at the endpoints of the loop.
The behavior is similar to the *Extrude* tool, but it creates an n-gon.

It helps to easily add details to existing edges.
user: Explain FunctionNodeBitMath(FunctionNode) in complete detail according to the official Blender documentation.

assistant: # FunctionNodeBitMath(FunctionNode)

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

*class* bpy.types.FunctionNodeBitMath(*FunctionNode*)
:   Perform bitwise operations on 32-bit integers

    operation
    :   - `AND`
          And – Returns a value where the bits of A and B are both set.
        - `OR`
          Or – Returns a value where the bits of either A or B are set.
        - `XOR`
          Exclusive Or – Returns a value where only one bit from A and B is set.
        - `NOT`
          Not – Returns the opposite bit value of A, in decimal it is equivalent of A = -A - 1.
        - `SHIFT`
          Shift – Shifts the bit values of A by the specified Shift amount. Positive values shift left, negative values shift right..
        - `ROTATE`
          Rotate – Rotates the bit values of A by the specified Shift amount. Positive values rotate left, negative values rotate right..

        Type:
        :   enum in [`'AND'`, `'OR'`, `'XOR'`, `'NOT'`, `'SHIFT'`, `'ROTATE'`], default `'AND'`

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

        Returns:
        :   Result

        Return type:
        :   boolean

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

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

        Returns:
        :   result

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

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

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

        Returns:
        :   result

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

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

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

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

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

        Returns:
        :   The class or default when not found.

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

assistant: Arguments are executed in the order they are given. eg:

```
blender --background test.blend --render-frame 1 --render-output "/tmp"
```

…will not render to `/tmp` because `--render-frame 1` renders before the output path is set.

```
blender --background --render-output /tmp test.blend --render-frame 1
```

…will not render to `/tmp` because loading the blend-file overwrites the render output that was set.

```
blender --background test.blend --render-output /tmp --render-frame 1
```

…works as expected.
user: Give a detailed overview of Options: syntax, arguments, return values, common patterns.

assistant: [image reference removed]

The Mesh Deform modifier.

Object
:   The name of the mesh object to be used as the deforming cage.

Vertex Group
:   An optional vertex group of the object’s mesh to restrict the vertices that
    will be affected by this modifier.
    Vertices not in this group will not be deformed.

    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.

Precision
:   Controls the accuracy with which the deform mesh cage alters the deformed object,
    when the points on the cage are moved.
    Raising this value higher can greatly increase the time it takes
    to complete the binding calculations,
    but it will get more accurate cage mapping to the deformed object.

    This setting becomes unavailable once a cage has been bound.

Dynamic
:   When activated, other mesh altering features (such as other modifiers and shape keys)
    are taken into account when binding, increasing deformation quality.

    The setting is deactivated by default to save memory and processing time when binding.
    Like with *Precision*, this setting is unavailable once a cage has been bound.

Bind
:   Links the current vertex positions of both the modified geometry and the deforming *Object* chosen together.
    An unbound *Mesh Deform* modifier has no effect,
    it must be bound so that altering the shape of the deform mesh cage
    actually alters the shape of the modified object.

Unbind
:   When a deformed object has been associated to a deform mesh cage,
    it can later be disassociated by clicking the *Unbind* button which replaced the *Bind* one.

    When *Unbind* is clicked, the *deforming mesh cage* will keep its current shape,
    it will not reset itself back to its initial shape.
    If you need this original shape, you will have to save a copy of it before you alter it.

    The deformed object will, however, reset back to its original shape that it had
    before it was bound to the deform mesh cage.
user: Explain Relative or Absolute Shape Keys in complete detail according to the official Blender documentation.

assistant: Every object with shape keys maintains a stack of keys.
This stack may be of *Relative* or *Absolute* type.

### Relative

Relative shape keys are mainly used for muscles, limb joints, and facial animation.
Each shape is defined relative to the *Basis* or to another specified shape key.

The final result visible in the 3D Viewport, also called the *Mix*,
is the cumulative effect of each shape key with its current value.
Starting from the *Basis* shape, Blender applies each shape’s weighted offset
relative to its reference key.

Value
:   Controls the blend between a shape key and its reference key.

    - `0.0` = 100% influence of the reference key
    - `1.0` = 100% influence of the shape key

    Blender can extrapolate blends above 1.0 and below 0.0,
    which may amplify or invert the deformation.

Basis
:   The *Basis* is the first (top-most) key in the stack.

    - Represents the object’s vertices in their original positions.
    - Has no weight value and cannot be keyed.
    - Serves as the default *Reference Key* when creating new shape keys.

### Absolute

Absolute shape keys are mainly used to deform an object into different shapes *over time*.
Instead of being blended together, each key corresponds to a specific *Evaluation Time*.

The resulting shape, or *Mix*, is computed by interpolating between the previous and next keys
according to the current *Evaluation Time*.

Value
:   Represents the *Evaluation Time* (in frames) at which the shape key will be active.

Basis
:   The *Basis* is the first (top-most) key in the stack.

    - Represents the object’s vertices in their original positions.
    - Defines the starting shape for the absolute sequence.
user: Describe Duplicate Linked from the Blender manual or Python API, including usage steps and snippets.

assistant: # Duplicate Linked

You also have the choice of creating a *Linked Duplicate* rather than a *Duplicate*;
this is called a deep link. This will create a new object with **all** of its data linked to
the original object. If you modify one of the linked objects in *Edit Mode*,
all linked copies are modified. Transform properties (object data-blocks) still remain copies,
not links, so you still can rotate, scale, and move freely without affecting the other copies.
Reference the [Examples](#examples) for the discussions below.

If the original object was animated, the duplicate will link to the same [Action](../../../animation/actions.html#bpy-types-action).
This means that, even though each object has separate transform properties,
they will be set to the same values by the animation system.
If this is not desired, make the action a single-user copy in the
[Action](../../../editors/dope_sheet/modes/action.html) or
[NLA Editor](../../../editors/nla/introduction.html).

Linked
:   In the *Duplicate Objects* [Adjust Last Operation](../../../interface/undo_redo.html#bpy-ops-screen-redo-last) panel the *Linked* checkbox is checked
    unlike with *Duplicate*.
user: What is GPU Options and how is it used in Blender Python scripting?

assistant: `--gpu-backend`
:   Force to use a specific GPU backend. Valid options: `vulkan`, `metal`, `opengl`.

`--gpu-vsync`
:   Set the VSync.
    Valid options are: `on`, `off` & `auto` for adaptive sync.

    - The default settings depend on the GPU driver.
    - Disabling VSync can be useful for testing performance.
    - `auto` is only supported by the OpenGL backend.

`--gpu-compilation-subprocesses`
:   Override the Max Compilation Subprocesses setting (OpenGL only).

`--profile-gpu`
:   Enable CPU & GPU performance profiling for GPU debug groups
    (Outputs a profile.json file in the Trace Event Format to the current directory)
user: What is Vertex Paint Tools and how is it used in Blender Python scripting?

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

assistant: # GeometryNodeSubdivisionSurface(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.GeometryNodeSubdivisionSurface(*GeometryNode*)
:   Divide mesh faces to form a smooth surface, using the Catmull-Clark subdivision method

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

assistant: # CompositorNodeRGB(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.CompositorNodeRGB(*CompositorNode*)
:   A color picker

    *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: What is Math Types & Utilities (mathutils) and how is it used in Blender Python scripting?

assistant:  :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzxz
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzy
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzyw
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzyx
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzyy
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzyz
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzz
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzzw
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzzx
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzzy
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")

    zzzz
    :   Type:
        :   [`Vector`](#mathutils.Vector "mathutils.Vector")
user: Explain Regions in complete detail according to the official Blender documentation.

assistant: # Regions

Every Editor in Blender is divided into Regions.
Regions can have smaller structuring elements like
[tabs and panels](tabs_panels.xhtml)
with buttons, controls and widgets placed within them.

[image reference removed]

The regions of the 3D Viewport showing the Sidebar and
the Adjust Last Operation panel after adding a Cube.

Header (green), Main region (yellow), Toolbar (blue),
Sidebar (red) and Adjust Last Operation panel (pink).
user: Provide the full official documentation entry for Target Selection, preserving all code examples.

assistant: Sets more detailed snapping options. The available options depend on the mode
(Object/Edit) as well as the [Snap Target](#bpy-types-toolsettings-snap-elements-base).

Include Active Edit Mode
:   Snap to other mesh elements of the active object.

    This checkbox is ignored if
    [Proportional Editing](proportional_editing.xhtml)
    is enabled.

Include Edited Edit Mode
:   Snap to other objects that are also in Edit Mode.

Include Non-Edited Edit Mode
:   Snap to other objects that are not in Edit Mode.

Exclude Non-Selectable
:   Snap only to objects that are selectable.

Align Rotation to Target
:   Rotates the selection so that its Z axis gets aligned to the normal of the target.

Backface Culling
:   Exclude back-facing geometry from snapping.

Snap to Same Target Face Nearest
:   Snap only to the object which the selection was nearest to before starting
    the transformation.

Face Nearest Steps Face Nearest Edit Mode
:   Breaks the overall transformation into multiple steps, performing a snap each time.
    This can give better results in certain cases.

Snap Peel Object Volume
:   If the target object is composed of several disconnected mesh islands that
    intersect each other, “Snap To Volume” will normally snap to the island which the
    mouse is hovering over, ignoring the other islands. By enabling “Snap Peel Object,”
    you can instead treat the target object as one connected whole.
user: Show practical ways to work with Tools in a Blender add-on or script – include code.

assistant: |  |  |
| --- | --- |
| `W`, `E`, `R` | Move, Rotate, Scale |
| `Q` | [Selection Tools](../selecting.xhtml) |
| `D` | [Annotate Tool](../annotate_tool.xhtml) |
| `C` | [Cursor Tool](../../editors/3dview/3d_cursor.xhtml) |
user: How do I use Assigning Materials in Blender? Include parameters, examples, warnings and best practices.

assistant: Each character can have a different *Material index* in order to have different materials
on different characters.

You can assign indices either as you type, or after by selecting blocks of text and
clicking on the *Assign* button in the *Materials* panel.

[image reference removed]

Red Green Blue text example.
user: Provide the full official documentation entry for Bpy.Types.Property, preserving all code examples.

assistant: erties_ensure bpy_struct.id_properties_ui bpy_struct.is_property_hidden bpy_struct.is_property_overridable_library bpy_struct.is_property_readonly bpy_struct.is_property_set bpy_struct.items bpy_struct.keyframe_delete bpy_struct.keyframe_insert bpy_struct.keys bpy_struct.path_from_id bpy_struct.path_from_module bpy_struct.path_resolve bpy_struct.pop bpy_struct.property_overridable_library_set bpy_struct.property_unset bpy_struct.rna_ancestors bpy_struct.type_recast bpy_struct.values References ¶ bpy.context.texture_user_property Function.parameters Struct.properties Next PropertyGroup(bpy_struct) Previous PrimitiveString(bpy_struct) Copyright &#169; Blender Authors Made with Furo Report issue on this page On this page Property(bpy_struct) Property Property.deprecated_note Property.deprecated_removal_version Property.deprecated_version Property.description Property.icon Property.identifier Property.is_animatable Property.is_argument_optional Property.is_deprecated Property.is_enum_flag Property.is_hidden Property.is_library_editable Property.is_never_none Property.is_output Property.is_overridable Property.is_path_output Property.is_path_supports_blend_relative Property.is_path_supports_templates Property.is_readonly Property.is_registered Property.is_registered_optional Property.is_required Property.is_runtime Property.is_skip_preset Property.is_skip_save Property.name Property.srna Property.subtype Property.tags Property.translation_context Property.type Property.unit Property.bl_rna_get_subclass() Property.bl_rna_get_subclass_py() Inherited Properties Inherited Functions References