> For the complete documentation index, see [llms.txt](https://docs.rayon.design/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rayon.design/documentation/design/parametric-blocks.md).

# Parametric blocks

How to use parametric blocks in Rayon.

Here is all you need to know about **using** and **creating `parametric` blocks.**

### What is a parametric block?

**`Parametric`** blocks make blocks in Rayon adaptable.\
Instead of creating multiple versions of the same object (different lengths, sizes, or repetitions), you can define a single block and adjust it, either by dragging its grips on the canvas or by typing its parameter values.

{% embed url="<https://player.vimeo.com/video/1247583472?autoplay=1&controls=0&loop=1&muted=1>" %}

### Interacting with a **parametric block**

We explain in this section where to find parametric blocks, and how to work with them.

#### Working with existing parametric blocks

Existing parametric blocks can be found in Rayon's libraries, in the **`Libraries`** tab of the block panel. Those already in your model sit under the **`My blocks`** tab. Spotting them is easy, as their card has a small hexagon icon, the **`Parametric`** badge.

<figure><img src="https://2112124689-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FngVHKyaUSSJPTFck3wkz%2Fuploads%2FES4MhS8428WiYwrlB2vt%2Fparametric-blocks-badge.png?alt=media" alt="The My blocks tab with a parametric block card showing the hexagon Parametric badge next to its instance count, beside a plain block card without the badge."><figcaption></figcaption></figure>

Once a parametric block is on the canvas, you can work with it by **interacting with its grips**. Let's dive in, step by step...

* Click on a **`parametric` block instance** on the canvas to select it.
* The block will now display **`grips`**, which are small handles corresponding to each **`parameter`**.
* Drag a grip along the **`parameter`** axis to adjust the block’s geometry.
* As you drag, the geometry updates in real time, based on the actions and parameters set up inside the block definition. The dragging motion will be affected by other settings too: minimum and maximum of the dragging distance, incremental or continuous dragging motion, etc.
* Clicking or dragging a length grip also shows the length as a purple dimension. Click that dimension to type a new length on the canvas. If the parameter's **`Type`** is **`List`**, you pick from a dropdown instead.

Another way to interact with a parametric block is through **the values of its parameters**, located in the **`Parametric properties`** section of the right panel...

* Select a **`Parametric` block instance** to **input a numeric value** directly in the right panel.
* Rayon immediately updates the **`parameter`** and all linked actions.
* When **`Type`** is set to **`Increment`**, entering a custom value rounds automatically to the **closest valid increment**.
* To return the instance to its starting state, click the reset icon next to **`Parametric properties`**. You can also right-click the instance and choose **`Reset block`**, or press **`OPT`** + **`B`**.

{% embed url="<https://player.vimeo.com/video/1246533737?autoplay=1&controls=0&loop=1&muted=1>" %}

### Creating a new parametric block

Parametric blocks can also be created; this requires a slightly more in-depth understanding of how parametric blocks work. This section will offer a deeper dive into parametric blocks.

In the **`AI`** panel, you can also ask the agent to add parameters and actions to a block.

#### Some definitions

We need to start by laying down **a few useful definitions.**\
A parametric block combines five elements that work together:

* An **action** transforms geometry,
* A **parameter** drives that transformation,
* **Parameter points** mark *how* and *where* the parameter is anchored on the canvas,
* A **selection set** decides what is impacted,
* An **active area** (Stretch only) defines *where* the transformation applies within the selection set.

| Element              | What it does                                                                                                 | Example                                                                                                                                                                                                                                                                                        |
| -------------------- | ------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Action**           | Defines *how* geometry changes when the parameter updates.                                                   | <p><strong><code>Stretch</code></strong>: moves parts of geometry.<br><strong><code>Array</code>:</strong> repeats geometry along a direction.<br><strong><code>Visibility</code></strong>: shows or hides geometry based on a state.</p>                                                      |
| **Parameter**        | Provides the numeric and directional input for the action.                                                   | A segment **`parameter`** between two points controlling distance or spacing.                                                                                                                                                                                                                  |
| **Parameter Points** | Define the start and end of a **`parameter`**. They anchor its axis and can be moved or snapped to geometry. | The two grips controlling a block’s **`stretch`** direction.                                                                                                                                                                                                                                   |
| **Selection Set**    | Defines which geometry is included in the transformation.                                                    | The elements that will move or repeat.                                                                                                                                                                                                                                                         |
| **Active Area**      | Refines the selection set by specifying which control points or portions of geometry are affected.           | <p>In a <strong><code>Stretch</code></strong> action, entities with control points inside the area stretch proportionally.<br>Lines and shapes with no control point inside stay in place, unless <strong><code>Obj. outside</code></strong> is set to <strong><code>Move</code></strong>.</p> |

<details>

<summary>So far, Rayon supports a handful of parameters and actions, detailed here.</summary>

| Type                        | Description                                                                                                                                                     | Used by                                        |
| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------- |
| **Segment `parameter`**     | Measures a distance between two points and provides both length and direction.                                                                                  | **`Stretch`**, **`Array`**, **`Move`**         |
| **Point `parameter`**       | Marks one position with a single grip. On an instance it exposes an X and a Y value.                                                                            | **`Stretch`**, **`Move`**                      |
| **Rotation `parameter`**    | Holds an angle around a center point. Its grip turns the linked geometry.                                                                                       | **`Rotation`**                                 |
| **Flip `parameter`**        | Defines a flip axis with two named states, Not Flipped and Flipped by default. Its grip switches between them.                                                  | **`Flip`**                                     |
| **Alignment `parameter`**   | Marks an alignment point and a direction on the block. A placed instance dragged by its grip snaps to nearby geometry and turns so the direction runs along it. | no action needed                               |
| **Visibility `parameter`**  | Holds a list of named states. Switching the active state determines which geometry is shown.                                                                    | **`Visibility`**                               |
| **`Stretch` Action**        | Moves geometry inside a defined selection set when the parameter value changes.                                                                                 | Point **`parameter`**, Segment **`parameter`** |
| **`Array` Action**          | Repeats selected geometry at a set spacing (the column offset) along the parameter axis. Two Array actions on two perpendicular Segment parameters make a grid. | Segment **`parameter`**                        |
| **`Move` Action**           | Translates the selection set by the parameter's displacement.                                                                                                   | Point **`parameter`**, Segment **`parameter`** |
| **`Rotation` Action**       | Rotates the selection set around the parameter's center by its angle.                                                                                           | Rotation **`parameter`**                       |
| **`Flip` Action**           | Mirrors the selection set across the parameter's axis when the parameter is flipped.                                                                            | Flip **`parameter`**                           |
| **`Visibility`** **Action** | Shows or hides geometry based on the active state of the linked Visibility **`parameter`**.                                                                     | Visibility **`parameter`**                     |

</details>

#### Creating your first parametric block

Let's go through a few steps to create a first block, and learn a few concepts along the way...

{% stepper %}
{% step %}

#### Enter edit in isolation mode

* Create a **`block`** definition. *More about* [*blocks*](https://docs.rayon.design/documentation/design/blocks.md)*.*
* Edit the block with **`Edit in isolation`** *(right-click > **`Edit in isolation`**, or **`CMD/CTRL`** + **`OPT`** + **`E`**)*.
  {% endstep %}

{% step %}

#### Choose an action

* In the bottom toolbar, find the **`Block actions`** group. **`Stretch action`** and **`Array action`** have their own icons. **`Alignment`**, **`Visibility`**, **`Flip action`**, **`Move action`** and **`Rotation action`** are in the dropdown next to them.
* Pick the action you want. **`Alignment`** is the exception: it creates a parameter that needs no action.
* Each action also has a shortcut: **`Stretch action`** (**`PS`**), **`Array action`** (**`PA`**), **`Alignment`** (**`PI`**), **`Visibility`** (**`PV`**), **`Flip action`** (**`PF`**), **`Move action`** (**`PM`**), **`Rotation action`** (**`PR`**).
* A block holds only one Visibility parameter, so **`Visibility`** is disabled in the dropdown once the block has one.
* Block actions work on 2D canvases only. A 3D canvas has no **`Block actions`** group, and an action cannot target a 3D solid.

<figure><img src="https://2112124689-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FngVHKyaUSSJPTFck3wkz%2Fuploads%2Fk4GV36xTPtQRgqlV1SoY%2Fparametric-blocks-actions-menu.png?alt=media" alt="The bottom toolbar in edit in isolation with the Block actions dropdown open, listing Stretch action, Array action, Alignment, Visibility, Flip action, Move action and Rotation action with their shortcuts."><figcaption></figcaption></figure>
{% endstep %}

{% step %}

#### Create or select a parameter

If the block already has a compatible parameter, Rayon asks you to click an existing parameter, or to click **`Done`** to create a new one. If it has none, you go straight to placing a new one.

* **To create a `parameter`**: pick two points to define a linear axis. For **`Stretch`** and **`Move`**, the command bar also offers **Point**, which needs a single click.
* **To reuse a `parameter`**: click one defined earlier in the same block.

What happens next depends on the action:

* For **`Stretch` actions** on a Segment **`parameter`**, Rayon asks which **end** of the parameter drives the action: click its **start** or its **end** point.
* For **`Array` actions**, Rayon does not ask for an end: the action uses the entire parameter direction and doesn’t depend on a specific point. For a grid, add a second **`Array`** action on a new Segment **`parameter`** perpendicular to the first.
* For **`Visibility` actions**, there is no parameter to pick. Click once on the canvas to place the Visibility **`parameter`** and its eye icon. Nothing is created until you click.
* For **`Move`**, **`Rotation`**, **`Flip`** and **`Alignment`**, follow the prompts in the command bar. Each one's section below lists them.

The parameter appears as a purple guideline with draggable grips.

{% embed url="<https://player.vimeo.com/video/1247583476?autoplay=1&controls=0&loop=1&muted=1>" %}
{% endstep %}

{% step %}

#### Define the selection set & active area

**For `Stretch` actions**

The Stretch action uses two definitions:

* **Selection Set**: which entities are eligible to move;
* **Active Area**: where deformation is detected. Crosses mark the points that will move.\
  • If selected entities have control points inside the Active Area, only those points move (deformation).\
  • If selected lines, shapes, linear dimensions, Segment parameters or Point parameters have **no** control points inside the Active Area, they stay in place. To translate them by the stretch delta instead, set **`Obj. outside`** to **`Move`** in the action's settings.\
  • Other selected entities, such as nested blocks, text and the other kinds of parameters, translate by the stretch delta either way.\
  • Images follow **`Obj. outside`** like lines and shapes: outside the Active Area they stay in place on **`Ignore`** and translate on **`Move`**.\
  • Entities not in the selection set do not move.

{% embed url="<https://player.vimeo.com/video/1247583471?autoplay=1&controls=0&loop=1&muted=1>" %}

**For `Array` actions**

* Select the geometry to repeat.
* Define the spacing between copies, the **column offset** (e.g., 600 mm). You can draw it or type it.

{% embed url="<https://player.vimeo.com/video/1247587244?autoplay=1&controls=0&loop=1&muted=1>" %}

**For `Visibility` actions**

**`Visibility`** has no selection set or active area. You build each state by choosing it in the state dropdown of the edit bar, then drawing or hiding geometry inside the block while in **`edit in isolation`**. A state only sets which contents of the block show, so one object can appear in several states.
{% endstep %}

{% step %}

#### Save the definition

Exit **`edit in isolation`** to save the block definition.\
All instances of this block now include interactive grips that control the parameter.
{% endstep %}
{% endstepper %}

#### Example scenarios

As it turns out, parameters and actions can be combined in many different ways to create various types of parametric blocks; we provide you here with a few examples...

| Use Case                     | Setup                                                | Result                                                          |
| ---------------------------- | ---------------------------------------------------- | --------------------------------------------------------------- |
| **Adjustable bench**         | Segment **`parameter`** + **`Stretch`** Action       | Drag to make the bench longer.                                  |
| **Row of chairs**            | Segment **`parameter`** + **`Array`** Action         | Drag to add or remove chairs at fixed spacing.                  |
| **Modular shelf**            | Segment **`parameter`** + **`Array`** Action         | Extend to automatically add shelf units.                        |
| **Door with swing variants** | Visibility **`parameter`** + **`Visibility`** Action | Switch between left, right, and double swing on the same block. |

### **Going deeper: parameters & actions**

Let's complete our understanding of parametric blocks by getting more familiar with parameters and actions.

#### **Segment `parameter`**

The **segment `parameter`** defines a linear distance and direction that actions can use to transform geometry. It’s the core driver behind **`Stretch`** or **`Array`** actions, providing both the *value* (length) and *axis* (orientation).

Each Segment parameter has two points: a **start** and an **end**.\
They appear directly on the canvas; the right panel sets the parameter's **`Length`** numerically.\
When the distance between these two points changes, every linked action updates automatically.

<figure><img src="https://2112124689-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FngVHKyaUSSJPTFck3wkz%2Fuploads%2FJT5Ju9yF6wuHQQmZPlvJ%2Fparametric-blocks-segment-panel.png?alt=media" alt="A Segment parameter selected in edit in isolation, with its right panel section showing Length, Type, Minimum, Maximum, Chain actions, Controls, Property and an Actions list holding a Stretch action."><figcaption></figcaption></figure>

<details>

<summary>Segment parameter panel</summary>

| Field                 | Description                                                                                                                                                                                                                                                                            |
| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Name**              | The name of the parameter (e.g., *Length*, *Spacing*, *Distance*). This helps identify it when linking actions.                                                                                                                                                                        |
| **Length**            | Displays the current measured distance between the two parameter points. You can also type a specific value to set it precisely. On a placed instance, the linked actions update the block to the new length.                                                                          |
| **Type**              | Defines how the parameter behaves. Choose **None**, **Increment** or **List**.                                                                                                                                                                                                         |
| **Minimum / Maximum** | Optional constraints for the parameter value. Use these to prevent the user from stretching or arraying beyond desired limits.                                                                                                                                                         |
| **Increment**         | Shows when **Type** is **Increment**. Sets the step between valid lengths.                                                                                                                                                                                                             |
| **Values**            | Shows when **Type** is **List**, in place of **Minimum** and **Maximum**. Click **Edit** to set the possible values.                                                                                                                                                                   |
| **Chain actions**     | <p>Decides what happens when another parameter's action moves this parameter:<br>• <strong>On</strong>: this parameter's actions run too.<br>• <strong>Off</strong> (the default): they do not run.<br>Dragging an end or setting the length always runs this parameter's actions.</p> |
| **Controls**          | Which ends show a grip on a placed instance: **None**, **End** or **End and start**. An end shows a grip only when an action is driven from it. On a Point or Rotation parameter, this row is **Control**, with **Show** or **Hide**.                                                  |
| **Property**          | Shows or hides this parameter's value under **Parametric properties** when a placed instance is selected.                                                                                                                                                                              |
| **Actions**           | The actions this parameter drives. Click **+** to add one, **Edit** to open its settings, or the minus icon to remove it.                                                                                                                                                              |

</details>

<details>

<summary>Segment parameter behavior</summary>

* The **Segment `parameter`** establishes a **direction** (from its start to end point) and a **length**.
* When its value changes (by dragging the grip or editing numerically), all linked actions recalculate their transformation.
* You can reuse the same parameter across multiple actions to synchronize behavior (e.g., stretching and arraying in the same direction).
* Constraints (minimum / maximum) are enforced visually on the canvas: the **`parameter`** grip stops at the limit.
* When the **`Type`** is **`Increment`**, any value typed **on a placed instance** is automatically adjusted to the **closest valid increment**, ensuring consistent, precise behavior across all instances. With **`List`**, an instance offers a dropdown with the listed values and the parameter's original length.

</details>

<details>

<summary>Segment parameter example</summary>

Imagine a **shelf module** with a Stretch and an Array action:

1. You create one **`stretch`** action with a **segment `parameter`** called *ModuleLength*.
2. You create an **`Array`** action linked to that same parameter.
3. Dragging one grip increases the shelf’s total length, stretching the side panels and adding extra shelves in between automatically.

This allows complex adaptive behaviors to remain easy to control with a single grip.

</details>

#### Actions

Rayon supports **stretch**, **array**, **move**, **rotation**, **flip** and **visibility** actions, plus an **alignment** parameter that needs no action; let's go through each of them.

**`Stretch` action**

To configure a **`Stretch` Action**, select its parameter, then click **`Edit`** on the action's row under **`Actions`** in the right panel.\
The popover that opens defines *what will move* and *how it will move* when the linked parameter changes.

<figure><img src="https://2112124689-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FngVHKyaUSSJPTFck3wkz%2Fuploads%2FHzSAd5AB5ccTn21a6Kxa%2Fparametric-blocks-stretch-popover.png?alt=media" alt="The Stretch action popover open beside the right panel with Obj. outside set to Ignore, and on the canvas the active area with crosses on the points that move."><figcaption></figcaption></figure>

<details>

<summary>Stretch action panel</summary>

| Field            | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Name**         | The name of the action, automatically set to “Stretch”. You can rename it if you have multiple actions in the same block.                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| **Area**         | Opens the editor to define the **Active Area**: the crossing zone that determines which parts of the geometry will deform when the **`parameter`** changes. Geometry with control points inside this area will stretch; **Obj. outside** decides what happens to geometry with no control point inside.                                                                                                                                                                                                                                                          |
| **Selection**    | Opens the editor to define the **Selection Set**: the geometry affected by this action. Only selected entities react to the stretch (either by deforming or moving). Click entities to add them, hold **`OPT`** to remove them.                                                                                                                                                                                                                                                                                                                                  |
| **Ang. offset**  | Rotates the stretch direction relative to the **`parameter`** axis, allowing for angled transformations. In most cases, this stays at **0°**.                                                                                                                                                                                                                                                                                                                                                                                                                    |
| **Dist. mult.**  | Defines a **distance multiplier** for the stretch effect. For example, `x1` applies the **`parameter`** value as-is; higher values amplify the displacement.                                                                                                                                                                                                                                                                                                                                                                                                     |
| **Insertion**    | <p>Controls whether the block’s insertion point is affected by the stretch:<br>• <strong>Include</strong>: insertion point moves with the stretch.<br>• <strong>Exclude</strong>: insertion point remains fixed in place.<br>On a block with an insertion segment, such as an opening, <strong>Include</strong> moves only the segment ends inside the active area.</p>                                                                                                                                                                                          |
| **Obj. outside** | <p>Decides what happens to selected lines, shapes, linear dimensions and Segment or Point parameters with no control point inside the <strong>Active Area</strong>:<br>• <strong>Ignore</strong>: they stay in place. This is the default on a new action.<br>• <strong>Move</strong>: they translate by the stretch delta.<br>Actions saved before this row existed keep <strong>Move</strong>. Other selected entities, such as nested blocks, text and the other kinds of parameters, translate either way; images follow this row like lines and shapes.</p> |

</details>

<details>

<summary>Stretch action behavior</summary>

* The **`Stretch` Action** is linked to a **`Parameter`**.
* The parameter’s **distance and direction** drive how far and in which direction the geometry moves. What moves can include **other `parameters`** as well as regular geometry, so several **`parameters`** can move together.
* The **Selection Set** defines which objects respond to the stretch.
* The **Active Area** defines which points of those objects move. **`Obj. outside`** decides whether objects with no point inside it move too.

</details>

<details>

<summary>Stretch action example</summary>

If you create a Stretch action on a table block:

1. The **Selection Set** includes the table top and its right leg.
2. The **Active Area** crosses the right side of the table.
3. When you drag the parameter grip, the right leg and that part of the top move, while the rest of the table stays fixed.

If the table had an object (like a decorative line) fully outside the Active Area but inside the Selection Set, it would stay in place with **`Obj. outside`** set to **`Ignore`**. With **`Move`**, it would translate as a whole rather than deform.

</details>

**`Array` action**

The **`Array` Action** creates repeated copies of selected geometry along a parameter’s direction.\
It’s used to distribute identical elements (like chairs, panels, or shelves) evenly along a distance that can be adjusted on the canvas.

The number of repeats, the original included, depends on the parameter’s total length and the **column offset** (the distance between copies).\
As you drag the parameter grip, Rayon automatically recalculates how many repeats fit along the axis and updates the geometry in real time.

**Arrays in two directions.** Two **`Array`** actions on two perpendicular Segment **`parameters`**, aimed at the same geometry, make a grid: the second array repeats every copy of the first. Each parameter drives its own count, so a 3 x 3 grid becomes 5 x 3 when you stretch the first parameter to five times the column offset, and 5 x 2 when you shorten the second.

<figure><img src="https://2112124689-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FngVHKyaUSSJPTFck3wkz%2Fuploads%2F9iMsJlzNnFGWJHBvKjPj%2Fpb-parametric-properties.png?alt=media" alt=""><figcaption></figcaption></figure>

<figure><img src="https://2112124689-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FngVHKyaUSSJPTFck3wkz%2Fuploads%2F3zwxVYAied0Fyflid4oW%2Fpb-array-action.png?alt=media" alt=""><figcaption></figcaption></figure>

<details>

<summary>Array action panel</summary>

| Field           | Description                                                                                                                                                                                                                                                                                                                                                                         |
| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Name**        | The name of the action, automatically set to “Array.” You can rename it to distinguish multiple array actions in the same block.                                                                                                                                                                                                                                                    |
| **Selection**   | Opens the editor to define the **Selection Set**: the geometry that will be repeated along the parameter’s axis. Only the selected entities will be duplicated.                                                                                                                                                                                                                     |
| **Col. offset** | The **column offset** defines the distance between copies. It is a length in the canvas unit (e.g., `600` on a millimeter canvas, `0.6` on a meter canvas); a value typed with another unit, like `0.6 m` on a millimeter canvas, is not accepted. The number of repeats, the original included, is calculated automatically based on this offset and the current parameter length. |

</details>

<details>

<summary>Array action behavior</summary>

* The **`Array` Action** is linked to a **`Parameter`**, which defines both the *axis* and the *total distance* available for repetition.
* As the parameter length increases, Rayon fills the space with copies spaced by the **column offset**.
* The selected geometry stays where you drew it, and moves only if the parameter’s start point moves.
* Copies step out from that geometry along the axis, one **column offset** apart. To start the run at the start point, draw the geometry there.
* The array updates dynamically as you drag grips on the canvas or modify the parameter value in the right panel.
* Copies are spaced by the **column offset** whatever the geometry’s width, so an offset smaller than the geometry makes them overlap.
* The number of repeats, the original included, is the parameter length divided by the offset, rounded down, counted from the selected geometry. The original always stays, even when the parameter is shorter than the offset. When the space becomes too small to fit another copy, Rayon automatically removes the extra copy. If you drew the geometry away from the start point, the copies can run past the end point.

</details>

<details>

<summary>Array action example</summary>

Imagine a **row of chairs** block:

* You define an **`Array` Action** associated with a **Segment `parameter`** along the row direction.
* You select one chair as the geometry to repeat.
* You set the **Col. offset** to `600 mm` (`0.6 m` if the canvas unit is meters).
* As you drag the parameter grip, Rayon automatically adds or removes chairs so they fill the distance evenly at 0.6 m intervals.

</details>

<details>

<summary>Array action tips</summary>

* Use logical values for the **column offset** (e.g., module widths, seat spacing, tile size).
* You can combine an **`Array`** and a **`Stretch`** on the same parameter: for example, stretch the base plane and array the elements on top of it.

</details>

**`Visibility` action**

The **`Visibility` Action** lets a block hold several visual states, where each state shows a different version of the block.

Unlike **`Stretch`** and **`Array`**, the **`Visibility`** action and its Visibility **`parameter`** are created together and share one section of the right panel. You build each state by drawing or hiding geometry inside the block in **`edit in isolation`**.

An eye icon appears on the canvas when the action is created. The icon has no geometric relationship to the block, so you can place it anywhere. Clicking the icon allows for easy switching between states.

<figure><img src="https://2112124689-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FngVHKyaUSSJPTFck3wkz%2Fuploads%2FkZG9BVE8k0lS5xUuc7Gk%2Fpb-visibility-parameter.png?alt=media" alt=""><figcaption></figcaption></figure>

<details>

<summary>Visibility action panel</summary>

| Field         | Description                                                                                                                                                                               |
| ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Name**      | The name of the parameter, automatically set to "Visibility". Rename it directly in the field. A block can hold only one Visibility parameter.                                            |
| **States**    | The list of states the block can switch between. Click **+** and choose **New empty state** or **Copy active state**. Click a state's name to rename it.                                  |
| **State row** | Each row shows the state name, an **ellipsis menu**, and a drag handle. The ellipsis menu offers **Set active** (switch to this state) and **Remove**. The drag handle reorders the list. |

</details>

<details>

<summary>Visibility action behavior</summary>

* Each state sets which contents of the block show. Switching the active state changes which geometry renders.
* Geometry common to several states (e.g., a door frame across swing variants) can stay one object. **`Copy active state`** makes a new state showing the same objects.
* Hiding an object (**`CMD/CTRL`** + **`H`**, or the eye in the **`Status`** row) hides it in the active state only. Anything you draw or paste is added to the active state only.
* In **`edit in isolation`**, the purple edit bar has a state dropdown that switches the active state. The bar's ellipsis menu (**`Manage states`**) offers **`New empty state`**, **`Copy active state`**, **`Delete state`** and **`Rename state`**.
* The state at the **top of the list** is the one shown when a fresh instance is placed on canvas. Drag a state to the top to make it the default for new instances.
* On a placed instance you can switch states in two ways:
  * clicking the eye icon on the canvas,
  * or using the state dropdown under **`Parametric properties`** in the right panel.
* **`Visibility`** combines freely with **`Stretch`** and **`Array`** on the same block.

</details>

<details>

<summary>Visibility action example</summary>

Imagine a **door** block with multiple swing variants:

1. In **`edit in isolation`**, draw the frame, then add a **`Visibility`** action and click once to place it. A "Default" state appears, showing the frame.
2. Rename "Default" to "Left swing" and draw the left-swing arc inside it.
3. In the purple edit bar, open the ellipsis menu, choose **`Copy active state`** and name the new state "Right swing". Select the left-swing arc, hide it with **`CMD/CTRL`** + **`H`**, and draw the right-swing arc.
4. Switch back to "Left swing" with the state dropdown in the purple edit bar. Choose **`Copy active state`** again, name the third state "Double swing", and draw the right-swing arc inside it.
5. Save the block by exiting **`edit in isolation`**. Every instance can now switch between the three swings.

</details>

<details>

<summary>Visibility action tips</summary>

* **Share geometry across states.** If a frame appears in every state, keep it as one object: use **`Copy active state`**, then hide what the new state should not show.
* **Reorder to set the default.** The top state in the list is the one that shows on a fresh instance.

</details>

**`Move` action**

The **`Move` Action** translates the geometry in its selection set when the linked parameter moves. It is driven by a **Point `parameter`** (one grip that drags freely and exposes an X and a Y value on the instance) or by a **Segment `parameter`** (a drag along the segment's axis).

When you add the action, the command bar asks you, in this order:

1. Whether to reuse a compatible parameter, if the block already has one.
2. Where to place a new parameter. Choose **Point** or **Segment** in the command bar while you place it.
3. On a **Segment**, which end of the parameter drives the action.
4. Which geometry moves.

<figure><img src="https://2112124689-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FngVHKyaUSSJPTFck3wkz%2Fuploads%2FE3m1ryC2f98QXFZOnjWv%2Fparam-move.png?alt=media" alt="The Move action popover open beside the Point parameter section of the right panel, with its Angular offset and Distance multiplier rows; the block with its point grip on the canvas"><figcaption></figcaption></figure>

<details>

<summary>Move action panel</summary>

| Field           | Description                                                                                                                                |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| **Name**        | The name of the action, automatically set to “Move”. Rename it to tell several actions apart.                                              |
| **Selection**   | Opens the editor to define the **Selection Set**: the geometry that moves. Click entities to add them, hold **Alt/Option** to remove them. |
| **Ang. offset** | Turns the move direction relative to the parameter's own direction. At **0°** the geometry moves exactly as the grip moves.                |
| **Dist. mult.** | A **distance multiplier**: `x1` moves the geometry as far as the parameter, `x2` twice as far.                                             |
| **Insertion**   | Whether the block's insertion point moves with the action: **Include** or **Exclude**.                                                     |

</details>

<details>

<summary>Move action behavior</summary>

* With a **Point `parameter`**, the grip can be dragged anywhere; the selection set follows by the same displacement, turned by the angular offset and scaled by the distance multiplier.
* With a **Segment `parameter`**, the displacement runs along the segment's axis. The whole selection set translates, and there is no active area.
* Geometry outside the selection set does not move. Other parameters can be part of the selection set, so their grips move along.

</details>

<details>

<summary>Move action example</summary>

Imagine a **desk with a lamp** block: a Point `parameter` on the lamp and a `Move` action whose selection set is the lamp. Drag the grip and the lamp slides across the desk; the desk stays.

</details>

**`Rotation` action**

The **`Rotation` Action** turns the geometry in its selection set around a center. It is driven by a **Rotation `parameter`**: a center point and an angle, with a grip that turns around the center. When you add the action, the command bar asks where the center sits, what the initial angle is, then which geometry rotates.

<figure><img src="https://2112124689-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FngVHKyaUSSJPTFck3wkz%2Fuploads%2FTRjc4rj71MG4dapr7GH5%2Fparam-rotation.png?alt=media" alt="The Rotation parameter section of the right panel with its Rotation action, the Rotate action popover open beside it; the block with its rotation grip on the canvas"><figcaption></figcaption></figure>

<details>

<summary>Rotation action panel</summary>

| Field         | Description                                                                                     |
| ------------- | ----------------------------------------------------------------------------------------------- |
| **Name**      | The name of the action, automatically set to “Rotate”. Rename it to tell several actions apart. |
| **Selection** | Opens the editor to define the **Selection Set**: the geometry that rotates.                    |

</details>

<details>

<summary>Rotation action behavior</summary>

* Drag the grip on an instance to turn the selection set around the center; type a value in the instance's **Angle** property for an exact angle (the definition's Angle field sets the starting angle).
* Geometry outside the selection set stays where it is.

</details>

<details>

<summary>Rotation action example</summary>

Imagine a **swivel chair** block: the center at the base, the seat as the selection set. Drag the grip to turn the seat; the base stays.

</details>

**`Flip` action**

The **`Flip` Action** mirrors the geometry in its selection set across an axis. It is driven by a **Flip `parameter`**: a point and an orientation that define the flip axis, and two named states, the **Base state** (“Not Flipped”) and the **Flipped state** (“Flipped”). When you add the action, the command bar asks where the axis sits, its orientation, then which geometry flips.

<figure><img src="https://2112124689-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FngVHKyaUSSJPTFck3wkz%2Fuploads%2F78ZHCEpGX393Xb4e83Tv%2Fparam-flip.png?alt=media" alt="The Flip parameter section of the right panel with its Flip action, the Flip action popover open beside it; the block with its flip grip on the canvas"><figcaption></figcaption></figure>

<details>

<summary>Flip action panel</summary>

| Field         | Description                                                                |
| ------------- | -------------------------------------------------------------------------- |
| **Name**      | The name of the action, automatically set to “Flip”.                       |
| **Selection** | Opens the editor to define the **Selection Set**: the geometry that flips. |

</details>

<details>

<summary>Flip action behavior</summary>

* Click the grip on an instance to switch between the two states; the selection set mirrors across the axis, the rest stays.
* The state names are what the instance shows for this parameter; rename them in the parameter's **Base state** and **Flipped state** fields.

</details>

<details>

<summary>Flip action example</summary>

Imagine a **door** block: the leaf and the swing arc as the selection set, the axis along the wall line. Flip the swing to the other side without a second block.

</details>

**`Alignment` parameter**

The **Alignment `parameter`** needs no action: it makes the whole block instance align to other geometry. In **`edit in isolation`**, run the **`Alignment`** command (**`PI`**) and click where the alignment point sits. Then click to set its direction: point it **along the edge** that should sit on the geometry, so that the block's front is on your right when you look in that direction. On a placed instance, drag the alignment grip onto a line or a wall: the block snaps to it and turns so that direction runs along the geometry.

<figure><img src="https://2112124689-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FngVHKyaUSSJPTFck3wkz%2Fuploads%2FHudZ1JrkhUsinXBOHBMl%2Fparam-alignment.png?alt=media" alt="A placed block dragged by its alignment grip onto a line and turned with it, the Alignment parameter&#x27;s grip on the line; the instance&#x27;s panel on the right"><figcaption></figcaption></figure>

<details>

<summary>Alignment parameter panel</summary>

| Field           | Description                                                                                                                                                                                                    |
| --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Orientation** | How the alignment grip is drawn on the instance: **Perpendicular** (the default) draws it square to the alignment direction, **Tangent** draws it along the direction. It does not change how the block turns. |

</details>

<details>

<summary>Alignment parameter example</summary>

Imagine a **sink** block. Its alignment point sits on the middle of its back edge, and its direction runs along that edge, pointing so that the sink's front is on your right when you look in that direction. Drag the alignment grip onto a wall: the back edge sits on the wall face you drag from, and the sink faces the room. If the direction points the other way, the sink lands on the far side of the wall.

</details>

***

### We are always available

Book a demo with our team, [right here](https://b1kzip68v9f.typeform.com/to/Hgr0eQ4k#source=docs).\
To get some support, reach out to us through our **in-app support chat**.\
More about [our support policy right here](https://docs.rayon.design/other-resources/others/support-policy.md).
