Datasets:
source stringlengths 33 118 | github_path stringlengths 22 104 | source_type stringclasses 2
values | crawled_at stringdate 2026-03-29 11:46:36 2026-03-29 11:48:37 | content stringlengths 81 142k | tokens int64 23 44.3k | content_hash stringlengths 64 64 |
|---|---|---|---|---|---|---|
https://create.roblox.com/docs/animation/events | content/en-us/animation/events.md | guide | 2026-03-29T11:46:36.702744+00:00 | # Events
You can define animation **event markers** across the timeline span and use
`Class.AnimationTrack:GetMarkerReachedSignal()|GetMarkerReachedSignal()`
to detect those markers as the animation runs.
## Show events
By default, the event track isn't visible. To show the event track:
1. Navigate to the right of the **timeline**, then click the **Gear** icon.
A pop-up menu displays.
<img
src="../assets/animation/animation-editor/Timeline-Options-Menu.png"
width="330" />
2. Select **Show Animation Events**. This opens the **Animation Events** bar directly below the media and
playback controls.
<img
src="../assets/animation/animation-editor/Animation-Events-Bar.png"
width="600" />
You can now [create](#create-events), [detect](#detect-events), and
[duplicate](#duplicate-events) events.
## Create events
Event markers are visual indicators of where an animation event begins. After you create an event
marker, you can move it to any frame position on the timeline.
To create a new event marker:
1. Navigate to the **timeline**, then click-and-drag the **scrubber** to the
frame position where the event should occur.
2. Navigate to the **event track**, then click the **Edit Animation Events**
button. The **Edit Animation Events** dialog displays.
<img
src="../assets/animation/animation-editor/Animation-Events-Edit-Button.png"
width="600" />
3. In the **Edit Animation Events** dialog, click **+ Add Event**, then enter an
event name.
<img
src="../assets/animation/animation-editor/Animation-Events-Add-Event.png"
width="507" />
4. **(Optional)** In the **Parameter** field, enter a parameter string for the event.
5. Click the **Save** button. In the events bar within the timeline, a new
marker symbol displays at the frame position.
<img
src="../assets/animation/animation-editor/Animation-Events-Marker-In-Timeline.png"
width="700" />
## Detect events
To detect animation events in a `Class.LocalScript`,
connect a function to the `Class.AnimationTrack:GetMarkerReachedSignal()|GetMarkerReachedSignal()` function of `Class.AnimationTrack`. For example:
```lua
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
-- Create new "Animation" instance
local walkAnim = Instance.new("Animation")
-- Set its "AnimationId" to the corresponding animation asset ID
walkAnim.AnimationId = "rbxassetid://5432167890"
-- Load animation onto the animator
local walkAnimTrack = animator:LoadAnimation(walkAnim)
-- Connect "GetMarkerReachedSignal" event to a specific named keyframe
walkAnimTrack:GetMarkerReachedSignal("FootStep"):Connect(function(paramString)
print(paramString)
end)
```
You can specify a <b>Parameter</b> value for any event
marker within the **Animation Editor**. This lets you pass a custom <b>string</b>
(single value, comma-separated string, etc.) to the `Class.AnimationTrack:GetMarkerReachedSignal()|GetMarkerReachedSignal()` function, as illustrated by the <b>paramString</b> argument in the code example above. This string can then be parsed or converted, if necessary, and used for whatever action you wish to perform in the event.
## Duplicate events
As you create events, they become available for usage throughout the whole
animation, not only at the frame position where you originally created them. For
instance, you can create a "FootStep" event marker at the point where a
character's **left** foot touches down, then use the same event when the
character's **right** foot touches down.
To duplicate an event:
1. Navigate to the **timeline**, then click an **event marker** in the **event bar**.
<img
src="../assets/animation/animation-editor/Animation-Events-Marker-Selected.png"
width="700" />
2. Press <kbd>Ctrl</kbd><kbd>C</kbd> (<kbd>⌘</kbd><kbd>C</kbd> on Mac).
3. Click-and-drag the **scrubber** to the frame position where you want to
duplicate the event.
4. Press <kbd>Ctrl</kbd><kbd>V</kbd> (<kbd>⌘</kbd><kbd>V</kbd> on Mac).
<img
src="../assets/animation/animation-editor/Animation-Events-Marker-Pasted.png"
width="700" />
If the original event uses a parameter
but the duplicated event should use a modified parameter, perform the following
steps:
1. Right-click the duplicated event marker. A pop-up menu displays.
2. Select **Edit Animation** Event. The **Edit Animation Events** dialog
displays.
3. Make your changes, then click the **Save** button.
You can also duplicate events by clicking the <b>Edit Animation Events</b> button (just as if you were <a href="#create-events">creating a new event</a>), clicking <b>Add Event</b> in the pop-up menu, selecting the desired event from the dropdown, and clicking <b>Save</b>. | 1,171 | 518685e9f78015cbd1e85eff86d2a24d11c5049abb3f5b78df2db5719429ca23 |
https://create.roblox.com/docs/animation/capture | content/en-us/animation/capture.md | guide | 2026-03-29T11:46:36.704704+00:00 | # Capture
You can record or upload video content to the [Animation Editor](../animation/editor.md) to quickly capture movement and expressions as animation keyframes. These tools can create unique and realistic animations within minutes while providing access to the animation keyframes for additional adjustments.
The animation capture tools allow you to:
- [Record your face](#face) with a webcam to puppeteer characters with [animation compatible heads](../art/characters/facial-animation/index.md).
- [Upload full-body video content](#body) to generate high quality realistic animations for an entire character.
## Face
**Animation Capture - Face** allows you to use your webcam to puppeteer rigs with [animation compatible heads](../art/characters/facial-animation/index.md) and generate corresponding keyframes to your movement. With the ability to record up to 60‑second animations, you can quickly provide both your playable and nonplayable characters the means to realistically grin, raise their eyebrows, drop their jaw, or any other expression necessary for your experience.
Before you begin to record your face, ensure that you're in a well lit room close enough to your camera so that your face is in the center of your camera's recording frame. This increases your camera's ability to distinguish you from your surroundings so that you can accurately puppeteer your avatar and create high-quality animations.
1. From the toolbar's **Avatar** tab, click **Animation**. The [Animation Editor](../animation/editor.md) window displays.
2. In the 3D viewport or the [Explorer](../studio/explorer.md) hierarchy, select the rig you want your video to animate. Enter a new animation name in the dialog window and click the **Create** button.
3. Navigate to the **track list** and click the **Face Capture** button. A popup displays asking you to acknowledge that you consent to the collection of your facial movements to enable the feature and camera access.
<img src="../assets/animation/face-recorder/Face-Recorder-Button.jpg"
width="80%" />
4.
If you have multiple cameras, choose which camera you want to use to record.
5. In the controls widget in the 3D viewport, click the red circle. Your camera begins recording your facial movements.
<img src="../assets/animation/face-recorder/Ready-Button.jpg" width="150" />
6. When you finish your recording, click either the red square or countdown timer. Keyframes that correspond to your facial movement display within the timeline.
<img src="../assets/animation/face-recorder/Countdown-Button.jpg" width="150" />
7.
If you'd like to delete the recording and try again, click **Re‑Record**.
After you finish your recording, you can [fine-tune](../animation/editor.md#keyframes) the keyframes, [save](../animation/editor.md#save-an-animation) your animation, then [export](../animation/editor.md#export-an-animation) it to use across all of your experiences.
## Body
The **Animation Capture - Body** allows you to quickly generate high-quality, realistic full-body animations for your R15 rigs by uploading videos to use to track the body's movement and generate corresponding keyframes. This significantly speeds up the manual process of creating animations, and allows you to personalize your avatars and NPCs with life-like mannerisms in a few minutes.
Before you import a video to the **Animation Editor**, ensure the `.mp4` or `.mov` file meets the following requirements:
- It includes just one person who is well-lit and visible throughout the video.
- It only contains a continuous single shot that's less than 15 seconds from a stable camera.
- It adheres to Roblox's [Community Rules](https://en.help.roblox.com/hc/articles/203313410) and [Terms of Use](https://en.help.roblox.com/hc/articles/115004647846).
To import a video to create an animation:
1. From the toolbar's **Avatar** tab, click **Animation**. The [Animation Editor](../animation/editor.md) window displays.
2. In the 3D viewport or the [Explorer](../studio/explorer.md) hierarchy, select the R15 rig you want your video to animate. Enter a new animation name in the dialog window and click the **Create** button.
3. Navigate to the **media and playback controls** and click the **⋯** button, then navigate to **Import** ⟩ **Live Animation Creator**.
<img src="../assets/animation/live-animation-creator/Media-Playback-Controls.jpg"width="330" />
4. In the popup dialog, click the **Choose Video** button.
5. Select the video you want to import from your local machine, then click the **Open** button. After about a minute, keyframes that correspond to movement in your video display within the timeline.
After your import is successful, you can [save](../animation/editor.md#save-an-animation) and [export](../animation/editor.md#export-an-animation) your animation to use across all of your experiences. | 1,066 | c97942967410729b8be1f1574a4698b45b8c54d897bc222d2a3d9fbaf40fd396 |
https://create.roblox.com/docs/animation/inverse-kinematics | content/en-us/animation/inverse-kinematics.md | guide | 2026-03-29T11:46:36.705256+00:00 | # Inverse Kinematics
[Inverse Kinematics](https://en.wikipedia.org/wiki/Inverse_kinematics) (IK) is a common technique in computer animation to efficiently make characters move and interact realistically with their environment. The process of creating a realistic movement for a character often requires many iterations and minor adjustments of the various joints. With IK, you can pose and animate multiple character parts by posing or adjusting a single object.
This animation technique can provide solutions to the following examples:
<figure>
<video controls src="../assets/animation/inverse-kinematics/IK-Place-Hand.mp4" width="90%"></video>
<figcaption>Grab and pose a character's hand while automatically adjusting the related limbs, such as the wrist, elbow, and shoulder.</figcaption>
</figure>
<figure>
<video controls src="../assets/animation/inverse-kinematics/IK-Uneven-Surfaces.mp4" width="90%"></video>
<figcaption>Make a character's feet interact realistically on different surfaces and slopes.</figcaption>
</figure>
<figure>
<video controls src="../assets/animation/inverse-kinematics/IK-Drag-Accessory.mp4" width="90%"></video>
<figcaption>Grab and move a single target object to quickly create realistic interactions with your character and props.</figcaption>
</figure>
## IKControl
You can use an `Class.IKControl` to procedurally add IK to your character rigs outside of the **Animation Editor**. Studio allows you to programmatically apply IK to all characters, such as R15, Rthro, and custom imported skinned characters, to create realistic movement and interactions in your experience.
When adding an `Class.IKControl`, set the [required properties](#required-properties) correctly to avoid unexpected and unnatural animation results. As with all animation, [test your IKControls](#test-ikcontrols) to ensure that you achieve the desired behavior.
### Required properties
When adding a `Class.IKControl` to your character's `Class.Humanoid` or `Class.AnimationController`, you must set the following required properties to enable IK:
<table>
<thead>
<tr>
<th>Property</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>`Class.IKControl.Type|Type`</td>
<td>Specifies the behavior type of the IK control. See `Enum.IKControlType` for the list of behavior options. Common behavior types are `Position` or `Transform`.</td>
</tr>
<tr>
<td>`Class.IKControl.EndEffector|EndEffector`</td>
<td>A `Class.BasePart` or `Class.Bone` in your character rig that tracks toward the `Class.IKControl.Target|Target`. For example, you can set a **LeftHand** bone as a `Class.IKControl.EndEffector|EndEffector` to reach a doorknob object set as the `Class.IKControl.Target|Target`.</td>
</tr>
<tr>
<td>`Class.IKControl.Target|Target`</td>
<td>The object the `Class.IKControl.EndEffector|EndEffector` reaches or points toward. A `Class.IKControl.Target|Target` can be any object with a world position.</td>
</tr>
<tr>
<td>`Class.IKControl.ChainRoot|ChainRoot`</td>
<td>Defines the chain of `Class.BasePart|BaseParts` or `Class.Bone|Bones` that the `Class.IKControl` affects. All connected parts between the `Class.IKControl.ChainRoot|ChainRoot` and the `Class.IKControl.EndEffector|EndEffector` are affected by the `Class.IKControl` using the behavior type defined. <br /><br /> For example, if your character's **LeftHand** is set as the `Class.IKControl.Target|Target`, you can apply IK to the entire left arm by setting `Class.IKControl.ChainRoot|ChainRoot` to the **LeftUpperArm**. To apply IK just to the parts below the elbow, set `Class.IKControl.ChainRoot|ChainRoot` to the **LeftLowerArm**.</td>
</tr>
</tbody>
</table>
### Test IKControls
You can add and edit `Class.IKControl` programmatically or directly through the **Explorer**. You can even add and make changes to `Class.IKControl` during a Play test to quickly check how various properties affect a character's movements.
To quickly test your `Class.IKControl` using an `Class.Attachment` as a target:
1. From Studio's mezzanine, [initiate a playtest](../studio/testing-modes.md#playtesting).
2. In the **Explorer**, navigate to **Workspace** → your user's `Class.Model`. This `Class.Model` instance is named as your current Roblox account.
3. Click the **⊕** icon next to your character model's `HumanoidRootPart` and add an **Attachment**.
<img src="../assets/animation/inverse-kinematics/IK-Add-Attachment.png"
width="40%" />
4. Select the **Attachment** and use the **Move** tool to position the object in front of your character in the viewport.
<img src="../assets/animation/inverse-kinematics/IK-Move-Attachment.png"
width="40%" />
5. In the **Explorer** window, select the **⊕** icon next to your character's `Class.Humanoid` and add an **IKControl**.
<img src="../assets/animation/inverse-kinematics/IK-Humanoid-Add.png"
width="40%" />
6. Select the `Class.IKControl` and set the following property values in the **Properties** window:
1. **Type**: Select `Transform` from the dropdown.
2. **EndEffector**: Select your model's **LeftHand** `Class.MeshPart` in the **Explorer**.
3. **Target**: Select the newly created **Attachment** object in the **Explorer**.
4. **ChainRoot**: Select your model's **LeftUpperArm** `Class.MeshPart` in the **Explorer**.
<figure>
<img src="../assets/animation/inverse-kinematics/IK-IKControl-Property.png" width="80%" />
<figcaption>IKControl Properties</figcaption>
</figure>
<figure>
<img src="../assets/animation/inverse-kinematics/IK-Explorer-Humanoid.png" width="67%" />
<figcaption>Explorer - Character Model</figcaption>
</figure>
Your character's left arm should now reach for the target `Class.Attachment`. You can experiment with moving the `Class.Attachment` or editing the `Class.IKControl` properties to achieve different results.
<video controls src="../assets/animation/inverse-kinematics/IK-Drag-Hand.mp4" width="40%"></video>
### Add constraints
You can use `Class.Constraint|Constraints` to restrict how joints can move when reaching its target. Constraints can ensure joints like the elbows and knees bend naturally, or to make the mechanical joints rotate in a specific orientation.
<figure>
<img src="../assets/animation/inverse-kinematics/elbow-unnatural-pose.png"/>
<figcaption>Elbow bending unnaturally</figcaption>
</figure>
<figure>
<img src="../assets/animation/inverse-kinematics/elbow-natural-pose.png"/>
<figcaption>Elbow bending correctly</figcaption>
</figure>
To add constraints to your character using `Class.IKControl`, your `Class.IKControl` and constraint must meet the following conditions:
- The attachments referenced in the constraint's `Class.Constraint.Attachment0|Attachment0`/`Class.Constraint.Attachment1|Attachment1` properties attaches to the same parts as the `Class.Motor6D` `Class.Motor6D.Part0|Part0`/`Class.Motor6D.Part1|Part1`.
- The relative positions of `Class.Constraint.Attachment0|Attachment0`/`Class.Constraint.Attachment1|Attachment1` must equal the corresponding positions of the `Class.Motor6D` `Class.Motor6D.C0|C0`/`Class.Motor6D.C1|C1` CFrames.
- The constraint and the IKControl share the same parent `Class.Model`.
The following instructions describe the process of adding a `Class.HingeConstraint` to restrict the rotation of a character's elbow and adding a `Class.BallSocketConstraint` to the wrist to limit the rotation angle.
#### Elbow
Roblox R15 characters already include attachments in their joints that you can use to apply the elbow constraint. For the elbow, both the LeftUpperArm and the LeftLowerArm include a `LeftElbowRigAttachment`. Along with adding a constraint, you also need to add additional child attachments to each part's `LeftElbowRigAttachment` to specify which axis the elbow can rotate about.
To add the `Class.HingeConstraint` and child attachments:
1. In the **Explorer**, locate your model's **LeftLowerArm** and click the **⊕ button**.
2. Add a **HingeConstraint** with the name `LeftElbowConstraint`.
3. In the **Explorer**, navigate to the **LeftUpperArm.LeftElbowRigAttachment** and add an attachment:
1. Click the **⊕ button** to add an **Attachment** with the name `LeftElbowConstraintAttachment0`.
2. In the viewport, select the attachment and use the **Rotate tool** to rotate the attachment so the yellow **PrimaryAxis** is the axis of your elbow's expected rotation.
<img src="../assets/animation/inverse-kinematics/elbow-primary-axis.png" width = "40%"/>
3. Set the **LeftElbowConstraint.Attachment0** property to this new attachment.
4. In the **Explorer**, navigate to your model's **LeftLowerArm.LeftElbowRigAttachment** add an attachment:
1. Click the **⊕ button** and add an **Attachment** with the name `LeftElbowConstraintAttachment1`.
2. Set the **LeftUpperArm.LeftElbowConstraint.Attachment1** property to this new attachment.
3. Copy the **LeftElbowConstraintAttachment0.CFrameOrientation** property and paste it as the **LeftElbowConstraint.Attachment1.CFrameOrientation** value.
<img src="../assets/animation/inverse-kinematics/elbow-natural-pose.png"/>
If you see a red arrow on the constraint's visualization, that means your attachment orientations are violating the hinge constraint. Go back and make sure the **LeftElbowConstraintAttachment1** has the same orientation as the **LeftElbowConstraintAttachment0**.
Test your IKControl to verify the elbow only rotates about its hinge axis:
<video controls src="../assets/animation/inverse-kinematics/hinge-constraint.mp4" width="100%"></video>
#### Wrists
Even with the elbow constraint, the IKControl can still produce unrealistic poses with the wrists.
<figure>
<img src="../assets/animation/inverse-kinematics/wrist-unnatural-pose.png" width = "40%"/>
<figcaption>The wrist bends unnaturally at certain orientations</figcaption>
</figure>
You can improve this by adding a `Class.BallSocketConstraint` to limit the rotation of the wrist. While this is similar to the process for adding a `Class.HingeConstraint` to the elbow, you can use the `Class.BallSocketConstraint.LimitsEnabled|LimitsEnabled` property on this constraint to further control the range of motion of the wrist.
To add a `Class.BallSocketConstraint` for the wrist:
1. In the **Explorer**, locate your model's **LeftHand** and click the **⊕ button**.
1. Add a **BallSocketConstraint** with the name `LeftWristConstraint`.
2. Locate your model's **LeftLowerArm.LeftWristRigAttachment** and add an attachment:
1. Click the **⊕ button** and add an **Attachment** with the name `LeftWristConstraintAttachment0`.
2. In the viewport, select the attachment and use the **Rotate tool** to rotate the attachment so the yellow PrimaryAxis points toward the model's fingertips.
<img src="../assets/animation/inverse-kinematics/wrist-primary-axis.png" width = "40%"/>
3. Set the **LeftWristConstraint.Attachment0** property to the new `LeftWristConstraintAttachment0`.
3. Locate your model's **LeftHand.LeftWristRigAttachment** and add an attachment:
1. Click the **⊕ button** and add an **Attachment** with the name `LeftWristConstraintAttachment1`.
2. Copy the **LeftWristConstraintAttachment0.CFrameOrientation** property and paste it as the **LeftWristConstraintAttachment1.CFrameOrientation** property.
3. Set the **LeftWristConstraint.Attachment1** property to this new **LeftWristConstraintAttachment1**.
4. In the **Explorer**, select the **LeftWristConstraint**.
5. In the **Properties** window, set the following:
1. Enable **LimitsEnabled**.
2. Set **UpperAngle** to `80`. This controls how much the constraint's axis can rotate, and 80 degrees is approximately how much the wrist should be able to bend.
6. Depending on your character you may want to tweak the direction the cone is pointing in. You can do this by using the **Rotate tool** to rotate the constraint's **Attachment0**.
When selecting the **LeftWristConstraint**, a green cone appears visualizing the wrist's range of motion.
<img src="../assets/animation/inverse-kinematics/wrist-cone.png" width = "40%"/>
With the constraint set up, test the IKControl with the hand pointing down in front of the character and the wrist should rotate and bend more realistically.
<video controls src="../assets/animation/inverse-kinematics/ball-socket-constraint.mp4" width="100%"></video> | 3,054 | 6524592d5403facb4291a24edbc4b417c647fee136f4d3c31774e373f53ddc75 |
https://create.roblox.com/docs/animation/curve-editor | content/en-us/animation/curve-editor.md | guide | 2026-03-29T11:46:36.705766+00:00 | # Curve Editor
The **Curve Editor** is a curve-based animation editing interface within the [Animation Editor](../animation/editor.md) that allows you to see and modify how a rig's position and orientation changes between keyframes through color‑coded curve graphs. It allows you to define independent tracks for the **X**, **Y** and **Z** angles, providing additional levels of control to make your animations more fluid and realistic.
<figure>
<img src="../assets/animation/curve-editor/Dope-Sheet-Editor.png" />
<figcaption>Dope Sheet Editor</figcaption>
</figure>
<figure>
<img src="../assets/animation/curve-editor/Curve-Editor-Example.png" />
<figcaption>Curve Editor</figcaption>
</figure>
Instead of using the default dope sheet editor's method of manually moving the scrubber from one frame to another to see how a rig's position and orientation change over time, the Curve Editor lets you quickly reference position and orientation values of your selected tracks through the **position ruler** on the left side of the timeline and the **rotation ruler** on the right side of the timeline.
<img
alt="Curve Editor Overview"
src="../assets/animation/curve-editor/UI-Overview.png"
width="780" />
## Open the Curve Editor
You can switch the editor's timeline between the dope sheet editor and the Curve Editor at any time.
1. Open the [Animation Editor](./editor.md) from Studio's **Avatar** tab or the **Window** ⟩ **Avatar** menu.
<img src="../assets/studio/general/Toolbar-Animation.png" width="800" alt="Animation Editor indicated in Studio's toolbar" />
2.
Studio automatically converts [quaternions](https://en.wikipedia.org/wiki/Quaternion) to [Euler angles](https://en.wikipedia.org/wiki/Euler_angles) when you open the Curve Editor, so it's important that you verify your rotation type **before** you switch to the Curve Editor. Once you convert quaternions to Euler angle tracks, it's impossible to convert them back into quaternions.
1. In the top-right corner of the editor window, click the gear icon. A contextual menu displays.
<img alt="Gear Icon" src="../assets/animation/curve-editor/Gear-Icon.png" width="600" />
2. Hover over **Default Rotation Type**, then select either **Euler Angles** or **Quaternions**. Your rotation type sets to your choice and becomes the default rotation type for future projects.
3. In the top-left corner of the **timeline**, click the **Curve Animation** icon. A popup window displays to confirm that your `Class.KeyframeSequence` clip will convert to a `Class.CurveAnimation` clip.
<img alt="Opening Curve Editor" src="../assets/animation/curve-editor/Opening-Curve-Editor.png" width="800" />
If you kept the default rotation type of Euler angles, Studio automatically converts any pre-existing quaternions to Euler angles following the [Euler angles order](#euler-angles-order) setting. Because `Class.KeyframeSequence|KeyframeSequences` work with quaternions and curve animations work with Euler angles by default, your animation might appear slightly different between keyframes, especially if any of your Euler angles approach [Gimbal lock](https://en.wikipedia.org/wiki/Gimbal_lock).
<img alt="Convert Euler Angles" src="../assets/animation/curve-editor/Convert-Euler-Angles.png" width="600" />
If you set the rotation type to quaternions, the conversion to curves preserves the quaternions and the animation remains the same.
<img alt="Curve Editor Overview" src="../assets/animation/curve-editor/Convert-Quaternion-Angles.png" width="600" />
## Interpolation
Interpolation is Studio's process of "filling in" position and orientation values between your keyframes. This allows the rig to seamlessly animate from one orientation or position to another instead of disjointedly jumping between keyframes. While Euler angle curves interpolate between the values of each keyframe, quaternion curves interpolate from `0` to `1` over a set time. To illustrate this, the following images display the same `Class.KeyframeSequence` after you open the Curve Editor with either a Euler angle or a quaternion rotation type:
<figure>
<img src="../assets/animation/curve-editor/Euler-Angle-Curve.png" />
<figcaption>Euler Angle Curve</figcaption>
</figure>
<figure>
<img src="../assets/animation/curve-editor/Quaternion-Curve-Interpolation.png" />
<figcaption>Quaternion Curve</figcaption>
</figure>
For **Euler angle curves**, the height of each keyframe represents its orientation value over time. For example, the highest keyframe represents a rotation of about 120 degrees around the **X** axis, and the lowest keyframe represents a rotation of about -10 degrees. For **quaternion curves**, each segment represents orientation changing between keyframes, and the line displays the interpolation between them. In the previous example, the animation starts from orientation A, then interpolates linearly to orientation B. Once it is at B, the interpolation starts again from orientation B to orientation C, then continues with this pattern until the rig reaches its final orientation.
You can modify how the Curve Editor handles interpolation for both Euler angle curves and quaternion curves by [setting tangents](#set), [changing the interpolation mode](#interpolation-mode), or by [generating interpolation curves](#generate-interpolation-curves) between two or more keyframes.
### Tangents
The Curve Editor provides **tangents**, or handles, that let you quickly adjust the interpolation either before or after a keyframe. Euler angle curves have a tangent both before and after the keyframe while quaternion curves have one tangent at the beginning and another at the end of a segment. The initial tangent controls the interpolation after the keyframe and the secondary tangent controls the interpolation before the keyframe. For example:
<figure>
<img src="../assets/animation/curve-editor/Euler-Angle-Curve-Tangents.png" />
<figcaption>Euler Angle Curve Tangents</figcaption>
</figure>
<figure>
<img src="../assets/animation/curve-editor/Quaternion-Curve-Tangents.png" />
<figcaption>Quaternion Curve Tangents</figcaption>
</figure>
For quaternion curve tangents, no matter how much you adjust each tangent, each segment always begins at `0` and ends at `1`. Although each segment of a quaternion curve graph is disconnected from subsequent segments, the two keyframes within the same frame always represent the same orientation.
Tangents change appearance when you set them to a new position. For example, when you manually set a tangent, the handle displays as a white circle, otherwise an unset tangent displays as a clear circle. For keyframes with two tangents, you can manually set either one or both tangents, and their appearance changes accordingly.
Tangents change appearance when you set them to a new position; an unset tangent displays as a clear circle, and a set tangent displays as a white circle. Studio automatically calculates the position for unset tangents based on the position of any set tangents. For instance, if you only set one tangent and leave the other unset, the unset tangent aligns with its opposite tangent:
<img
alt="Tangent Image"
src="../assets/animation/curve-editor/Tangent.png"
width="320" />
#### Set
To set a tangent:
1. Click and drag the tangent in the direction you want to pull the curve. The curve adjusts based on the location of your cursor.
2. Release the tangent. The interpolation between keyframes adjusts accordingly.
3.
If you set one tangent and want to align the unset tangent horizontally, right-click the unset tangent and select **Set Tangent to Zero** from the contextual menu.
#### Reset
If you ever set a tangent to a new position and the resulting interpolation is undesirable, you can always use "auto‑tangent mode" to clear a tangent's value and reset it back to its default interpolation behavior.
1. Right-click on a tangent. A contextual menu displays.
2. Select **Set Tangent To Zero**. The tangent resets to its default interpolation behavior.
### Interpolation mode
Interpolation mode is the rate at which an animation moves between different keyframe positions within the animation. There are three interpolation modes available for curve animations:
- **Linear** (default) — Moves at a constant speed from one keyframe to another.
- **Constant** — Removes interpolation between the selected keyframe and next keyframe, causing the animation to "snap" from keyframe to keyframe.
- **Cubic** — Eases in and/or out of the animation. Cubic is the only mode that allows you to define tangents.
To change interpolation mode:
1. Right-click a keyframe. A contextual menu displays.
2. Hover over **Interpolation Mode**, then select either **Linear**, **Constant**, or **Cubic**. The interpolation mode changes the curve following the keyframe.
<img
alt="Interpolation Mode"
src="../assets/animation/curve-editor/Interpolation-Mode.png"
width="600" />
### Generate interpolation curves
For curve animations, bounce and elastic easing styles are not available as standard interpolations like they are for `Class.KeyframeSequence|KeyframeSequences`. However, when you convert a `Class.KeyframeSequence` to a curve animation, Studio automatically adds additional keyframes to your animation to keep the animation intact, and you can select two or more keyframes and generate an **interpolation curve** that removes and replaces any of their intermediate keyframes to mimic bounce and elastic easing behavior.
To generate interpolation curves:
1. Select two or more keyframes. Each keyframe you select highlights.
2. Right-click one of these keyframes. A contextual menu displays.
3. Hover over **Generate Curve**, then over **Bounce** or **Elastic**, and then select either **Out**, **In**, or **InOut**. An interpolation curve between your selected keyframes generates according to your settings.
- **Out** — The motion is faster at the beginning and slower toward the end of the keyframe range.
- **In** — The motion is slower at the beginning and faster toward the end of the keyframe range.
- **InOut** — **In** and **Out** on the same tween, with **In** at the beginning and **Out** taking effect halfway through the keyframe range.
## Euler angles order
When you're working with Euler angles, Studio represents the **X**, **Y**, and **Z** axes through three channel values that follow a specific order to move your rig from its starting orientation to its next orientation. Each order is named after the [matrix multiplications](https://en.wikipedia.org/wiki/Matrix_multiplication) to get to the final orientation. For example, an **XYZ** order (**X**×**Y**×**Z**) means that the rig moves starting on the **Z** axis, then the **Y** axis, then the **X** axis.
How an animation changes when you set Euler angles order is dependent on **when** you change the order:
- If you load a `Class.KeyframeSequence` or a `Class.CurveAnimation` with a set quaternion rotation type then change the order, the new order doesn't affect the animation. This is because Studio uses quaternions to configure changes in your rig's orientation using the shortest path possible between its starting orientation to its next orientation. However, this method does affect how the quaternions of each keyframe transform into **X**, **Y**, and **Z** angles in the track list, which might visually affect the values within the timeline without affecting the animation itself.
- If you change the order of an existing Euler angle track, the animation might change since Studio preserves the values of each keyframe. This means that the ordered path Studio takes to change your rig's orientation from its starting orientation to its next orientation changes with the Euler angles order.
To set the Euler angles order:
1. In the top-right corner of the editor window, click the gear icon. A contextual menu displays.
<img alt="Gear Icon" src="../assets/animation/curve-editor/Gear-Icon.png" width="600" />
2. Hover over **Default Euler's Angles Order**, then select either **XYZ**, **XZY**, **YXZ**, **YZX**, **ZXY**, or **ZYX**. Your Euler angles order changes accordingly. | 2,650 | 03304e5e45f7cc7c50ce80308cbb19d135c4b0b3d21e603a9d4ac369ca9e39d7 |
https://create.roblox.com/docs/animation | content/en-us/animation/index.md | guide | 2026-03-29T11:46:36.719618+00:00 | # Animation
**Animation** is the process of applying motion to your characters, objects, and environments to create an engaging and dynamic experience. While there are many ways to make objects move and interact, animation in Roblox typically refers to customizing an expressive movement of a specific character, or group of parts, using the **Animation Editor** or **animation-related APIs**.
Animation can apply to any Roblox part or group of parts. Different types of objects can utilize various animation features. The following are the general categories of animatable objects:
- **Simple objects**, such as a basic part, can only animate changes across the part's single position or rotation property.
- **Rigs**, or parts connected by joints like `Class.Bone` or `Class.Motor6D`, can articulate positional and rotational movement between their joints, like elbows and wrists. Rigged models can take advantage of animation features like [inverse kinematics](#inverse-kinematics) to quickly and programmatically apply movement in response to environments and events.
- **R15 rigs**, rigs that incorporate the standardized [avatar character model](../characters/index.md#avatar-character-components), can use animations from Roblox's character animation library and other movement features, even if it's a player or non-player character model.
## Animation Editor
The [Animation Editor](../animation/editor.md) allows you to design and publish custom animations on rigs. You can move the joints that connect individual sections of a rig to create poses, and the **Animation Editor** smoothly animates the rig from pose-to-pose. As long as all moving parts are connected with `Class.Motor6D` objects, you can use the editor for both human and non-human rigs.
<video src="../assets/animation/inverse-kinematics/IK-Body-Part.mp4" controls width="80%"></video>
When creating animations, Studio provides the following features to animate effectively:
- Instantly create face and body animations through the [Animation Capture](../animation/capture.md) tool.
- Switch to the [Curve Editor](../animation/curve-editor.md) to access the curve-based animation UI and more control over your animation tracks.
- Make realistic animations by posing and animating `Class.Bone|Bones` of a [rigged mesh](../art/modeling/rigging.md).
## Inverse kinematics
You can use [inverse kinematics](../animation/inverse-kinematics.md) APIs to automatically create animations and poses based on environmental and external events. With inverse kinematics, you can procedurally generate various animation events, such as having a character's head track a bird flying in the sky, or making a character's arm automatically reach for a door knob when nearby.
## Animation events
An [animation event](../animation/events.md) is a specific point in an animation that triggers an action. You can define animation event markers across the **Animation Editor** timeline span, then use `Class.AnimationTrack:GetMarkerReachedSignal()` to detect those markers as the animation runs to perform specific actions, such as playing a sound effect whenever the user's foot touches the ground. | 637 | 898d115db3e02fd98ea3b193d3c87695a2e29d2bca03990aff7b747d7ebec9f8 |
https://create.roblox.com/docs/ai-data-sharing | content/en-us/ai-data-sharing.md | guide | 2026-03-29T11:46:36.741146+00:00 | # Ai Data Sharing
Roblox has a suite of AI-powered solutions, including [Code Assist](studio/script-editor.md#code-assist), [Material Generator](studio/material-generator.md), [Assistant](assistant/guide.md), in-experience chat translation, [Texture Generator](studio/texture-generator.md), and [Avatar Setup](/avatar-setup/index.md). These tools help you quickly find information, accelerate the creation process, and complement your existing skillset.
To improve these tools and build new ones, Roblox uses data to train its generative AI models.
When you publish an experience in Studio, upload an avatar item, or upload a **paid** asset to the [Creator Store](production/creator-store.md), you have the option to share your data. The default choice in the user interface is based on a setting in the [Creator Hub](https://create.roblox.com/).
<img src="assets/misc/Data-Share-Dialog.png" alt="An image of the publish experience dialog showing the data sharing toggle." width="70%" />
- The data sharing setting is **off by default** for experiences, avatar items, and paid assets published prior to July 10, 2024.
- The data sharing setting is **on by default** for experiences, avatar items, and paid assets published on or after July 10, 2024.
You can change your default choice at any time and override it as desired whenever you publish.
Because they're distributed with the intent of others using them, **free** [Creator Store](production/creator-store.md) assets are shared by default, with no ability to disable sharing.
## Manage data sharing preferences
To set your global data sharing preferences:
1. On the [Creator Hub](https://create.roblox.com/), click your user name and **Settings**.
1. Select **Data Sharing**.
1. Enable or disable **Make sharing data the default option when publishing experiences**.
1. (Optional) Choose individual experiences, avatar items, and paid Creator Store assets to share or not share.
## How Roblox uses data
All data shared with Roblox is for AI-enhancement purposes only and is not shared with third parties. Data is processed and stored in accordance with strict security protocols, contains no personal information, is split into tokens (small snippets) for further anonymization, and is retained for only as long as it is beneficial for model improvement. Roblox regularly reviews and purges shared data.
If you share something and then later stop sharing it, Roblox will remove it from the training dataset within 30 days. Any AI models that were trained using your data will be updated within 365 days.
<h5 style=}>Sources and ownership of the datasets</h5>
Roblox's generative AI systems made available to the public are trained on the following, with particular data sources varying for each system:
- Data from publicly accessible repositories under permissive licenses or released in the public domain
- Non-public data obtained from third-party providers via commercial arrangements
- Data from user activity on our platform and from our creators who have not opted-out from model training
- Data generated internally, including synthetic data
- Data provided by annotation services and other contractors
<h5 style=}>Purpose and methodology of data collection, cleaning, processing, or modification</h5>
Roblox uses training data to develop or enhance its AI offerings to its creators. Data enables contextual understanding and generation with respect to language capabilities, as well as within virtual, 3D environments, including with respect to materials, textures, geometry, and structures, to enhance details, interactions, and relevance among objects.
Data is retained for only as long as it is beneficial for model improvement. Roblox regularly reviews and purges data.
<h5 style=}>Data points included in the datasets, such as types, labels, and counters</h5>
Training data incorporates various types of (a) written and audio text including in a variety of languages; (b) visual content; and (c) annotations, rating, and preference data. The size of datasets varies by system type and version, but the amount of training can range up to over 3 million distinct assets.
<h5 style=}>Licensing status, indicating whether datasets are copyright-protected, purchased, licensed, or in the public domain</h5>
Training data may include data subject to third party intellectual property rights. Third party data is derived from data repositories under (a) permissive licenses or released in the public domain; (b) third-party providers via commercial arrangements; and (c) our creators on our platform who have not opted-out from model training. Roblox conducts diligence on training data, including from third-party sources.
<h5 style=}>Inclusion of personal or aggregate consumer information, as defined by the California Consumer Privacy Act</h5>
Roblox implements processes including filtering to exclude personal information from training generative AI systems available for public use. Creator data is also tokenized to ensure it is not associated with an individual. To the extent data may contain aggregate consumer information, Roblox does not use it to identify or target individuals. Creators on our platform can control their data sharing preferences, including opting-out of their content being used for training, and all users may request deletion of personal information generally.
<h5 style=}>Cleaning, processing, or other modification of datasets by the developer and the respective purpose for each modification</h5>
Roblox employs various data processing techniques to enhance efficiency, quality, and safety, and to protect sensitive information, including deduplication, classification, and safety and privacy filtering.
<h5 style=}>Use of synthetic data in development and/or training of the system</h5>
Generated synthetic data is included in datasets used in development and training.
<h5 style=}>Dates when datasets were first used and the time frame during which the data was collected</h5>
Roblox started compiling and using datasets for generative AI systems in 2023. Such use is ongoing.
<h5 style=}>Additional information</h5>
For additional information, refer to our model cards and research papers related to our published models.
This information is provided pursuant to California Civil Code Section 3111 (AB 2013) and is subject to update.
## Public Luau
Previously, Roblox launched a program that allowed you to share your scripts with Roblox, a public Luau dataset, or both. Roblox no longer uses the script data that was shared only with Roblox. Instead, you now decide if you want to share entire experiences, including their scripts.
The Luau public dataset is not affected by this change. You can set your sharing preferences on the Creator Hub in the **Public Luau** tab. For more details on the public dataset, see [Empower Luau creation](https://create.roblox.com/data-collection). | 1,403 | 566b429aef1510a736da81ba3505d53ec4863f4042be3cff19256e1149451541 |
https://create.roblox.com/docs/affiliates | content/en-us/affiliates.md | guide | 2026-03-29T11:46:36.769193+00:00 | # Affiliates
Effective July 24, 2025, the Creator Affiliate program is deprecated and has been replaced by the [Creator Rewards](./creator-rewards.md) program.
The [Creator Affiliate Program](https://create.roblox.com/affiliate) is a pilot program that lets you earn Robux using affiliate links. With it, you can:
- Generate affiliate share links for any Roblox experience, including other developers' experiences, through the Creator Hub.
- Promote your affiliate links off-platform on social media channels.
- Earn revenue in Robux whenever new users create a Roblox account and purchase Robux using your affiliate link. A new user is someone who doesn't already have an alternative Roblox account.
- Exchange your Robux earnings for real-world money using the Developer Exchange program.
When a user creates a Roblox account using your affiliate link and then buys Robux, you can receive up to 50% of the value of their Robux purchases during their first six months on the platform, for a maximum revenue of \$100 USD per new user. For example, if a new user joins Roblox and purchases \$100 USD of Robux, you can earn up to \$50 USD, minus certain fees like taxes and VAT.
You receive your revenue in Robux, which you can exchange for real-world money through Developer Exchange. | 275 | 8a4cbb1a4f3f01acc8e4845839282648750c1cc664e7bbbc271108067a5ae8d4 |
https://create.roblox.com/docs/animation/editor | content/en-us/animation/editor.md | guide | 2026-03-29T11:46:36.912940+00:00 | # Editor
The **Animation Editor**, accessible from Studio's **Avatar** tab or **Window** ⟩ **Avatar** menu, allows you to design and publish custom animations on rigs. A rig is an object with individual sections connected by joints. You can move these joints to [create poses](#create-poses) and then smoothly animate the rig from pose to pose.
<img src="../assets/studio/general/Toolbar-Animation.png" width="800" alt="Animation Editor indicated in Studio's toolbar" />
## Interface
<img src="../assets/animation/animation-editor/Editor-Sections-Labeled.png"
width="80%" />
### Media and playback controls
<table>
<tr>
<td><img src="../assets/animation/animation-editor/Controls-Animation-Name.png"
width="100%" /></td>
<td>The name of the animation.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Controls-File-Menu.png"
width="100%" /></td>
<td>
Opens a contextual menu with the following menu items:
<ul>
<li>**Load**</li>
<li>**Save**</li>
<li>**Save As**</li>
<li>**Import**</li>
<li>**Export**</li>
<li>**Create New**</li>
<li>**Set Animation Priority**</li>
</ul>
</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Controls-First-Key.png"
width="100%" /></td>
<td>Moves the scrubber to the first key.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Controls-Previous-Key.png"
width="100%" /></td>
<td>Moves the scrubber to the previous key.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Controls-Preview-Reverse.png"
width="100%" /></td>
<td>Previews the animation in reverse.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Controls-Pause.png"
width="100%" /></td>
<td>Pauses the animation.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Controls-Preview.png"
width="100%" /></td>
<td>Previews the animation.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Controls-Next-Key.png"
width="100%" /></td>
<td>Moves the scrubber to the next key.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Controls-Last-Key.png"
width="100%" /></td>
<td>Moves the scrubber to the last key.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Controls-Looping.png"
width="100%" /></td>
<td>Toggles looping for the animation.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Controls-Position-Indicator.png"
width="100%" /></td>
<td>The **position indicator** that displays the timeline unit for the position of the scrubber in **seconds:frames**.</td>
</tr>
</table>
### Timeline
<table>
<tr>
<td><img src="../assets/animation/animation-editor/Timeline-Scrubber-Bar.png"
width="100%" /></td>
<td>A scrubber that marks the current frame position.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Timeline-Time-Units.png"
width="100%" /></td>
<td>Time units that allow you to move the scrubber to a precise time unit.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Timeline-Keyframe.png"
width="100%" /></td>
<td>A keyframe that marks the change in position or orientation of a part.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Timeline-Expand-Contract.png"
width="100%" /></td>
<td>Either expands or contracts the time unit marks.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Timeline-Options-Menu.png"
width="100%" /></td>
<td>
Opens a contextual menu with the following menu items:
<ul>
<li>**Timeline Unit**</li>
<li>**Frame Rate: 30fps**</li>
<li>**Show <a href="../animation/events.md">Animation Events</a>**</li>
<li>**Snap To Keys**</li>
</ul>
</td>
</tr>
</table>
### Track list
<table>
<tr>
<td><img src="../assets/animation/animation-editor/Track-List-Rig-Name.png"
width="100%" /></td>
<td>The name of the rig.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Track-List-IK-Button.png"
width="100%" /></td>
<td>Opens the **Manage IK** window.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Track-List-Add-Tracks.png"
width="100%" /></td>
<td>Opens a contextual menu of additional tracks you can add to the track list. </td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Track-List-Track-Name.png"
width="100%" /></td>
<td>The track displaying the name, position, and rotation of the part that
has been moved or rotated to a new position or orientation.</td>
</tr>
<tr>
<td><img src="../assets/animation/animation-editor/Track-List-Track-Options.png"
width="100%" /></td>
<td>
Opens a contextual menu with the following menu items:
<ul>
<li>**Add Keyframe**</li>
<li>**Delete Track**</li>
</ul>
</td>
</tr>
</table>
## Create an animation
You can only create animations using rigs. If you don't have a rig available, insert a pre-built rig using the [Rig Generator](../studio/rig-builder.md) tool. The pre-built rigs have all of the basic parts and mechanisms to
build a character animation.
If you have a rig, you can create a new animation for it using the following steps:
1. From the toolbar's **Avatar** tab, click **Animation**.
2. Select the rig you want to create an animation for to display the creation dialog.
<img src="../assets/animation/animation-editor/Create-Animation-Dialog.png" width="380" />
3. In the **Animation Name** field, enter a new animation name, then
click the **Create** button. The **Animation Editor** window displays
the [media and playback controls](#media-and-playback-controls), [timeline](#timeline), and [track list](#track-list).
From here, you can begin [creating poses](#create-poses)
for your rig and modifying the animation settings, such as [looping
the animation](#loop-an-animation) or [setting its
priority](#set-a-priority).
### Create poses
An animation consists of different **poses**, or specific positions and orientations of `Class.Bone` or `Class.MeshPart` objects within a rig. You can create poses by moving or rotating bones or meshes, such as the rig's hands, feet, or torso. After you create multiple poses on different positions of the timeline, the **Animation Editor** runs between them with your [easing settings](#easing) to smoothly animate the rig from pose-to-pose.
For example, a simple animation where a humanoid character turns
to look 45° to the left has two poses:
- The initial position looking forward.
- The turned position looking left.
<video src="../assets/animation/animation-editor/Animation-Poses.mp4" controls width="80%"></video>
To create a pose:
1. In the **Explorer** window, select the rig and expand its child instances to access the bones or meshes.
2. In the **Animation Editor** window, navigate to the timeline, then
click-and-move the **scrubber** to the frame position where you
want to set the pose. By default, Roblox represents timeline units as
**seconds:frames** and animations run at 30 frames per second. For example, 0:15 indicates ½ second.
<img src="../assets/animation/animation-editor/Scrubber-0-15.png" width="60%" />
3. In the **viewport**, hover your mouse over **rig** and select a bone or mesh. You can also select the ⊕ icon on the timeline and click **Add All** to add all bones or meshes to the animation.
<img src="../assets/modeling/skinned-meshes/Animation-Editor-Add-Tracks.png" width="60%" />
4. Move or rotate the bone or mesh to a new orientation. For bones, you can rotate them to pose the rig along the created bone joints.
<video controls src="../assets/modeling/skinned-meshes/Transform-Demo-Skinned.mp4" width="100%"></video>
When creating poses, you can toggle between **Move** and **Rotate**
modes by pressing <kbd>R</kbd>. These modes work exactly like moving and rotating base objects, including the snap settings and incremental values located in Studio's toolbar.
5. Continue moving or rotating bones or meshes until you get the desired pose.
Whenever you adjust a specific bone or mesh, a **new track** displays in the track list, and a **new keyframe** displays on the **timeline** for that bone more mesh at that specific frame position.
<img src="../assets/animation/animation-editor/Track-Keyframe-Added.png" width="80%" />
6. When you're ready to preview the animation, you can either:
- Navigate to the **Media and Playback Controls**, then click the
**Play** button.
<img src="../assets/animation/animation-editor/Controls-Preview.png"width="330" />
- Or press the **Spacebar**.
By default, the timeline displays a duration of 1 second (30 frames), but the final keyframe determines the animation's actual duration. To
add more time to the timeline, enter a new value in the right-side box of
the position indicator.
## Keyframes
Once you [create basic poses](#create-poses) for a rig,
fine-tuning individual keyframes can significantly improve the final
animation.
### Add keyframes
Whenever you change a part's position or orientation, a new keyframe
displays on the timeline. You can also add keyframes to a timeline
through the following methods.
To add a keyframe for a single part of the rig:
1. Navigate to the **timeline**, then move the **scrubber** to a new
position.
2. In the **track list**, navigate to the part's **track** and click
the **⋯** button. A contextual menu displays.
<img
src="../assets/animation/animation-editor/Track-List-Track-Options.png"
width="330" />
3. Select **Add Keyframe**.
To add a keyframe for multiple parts of the rig:
1. Navigate to the **timeline**, then right-click in the dark region
above the tracks. A pop-up menu displays.
<img
src="../assets/animation/animation-editor/Add-Multiple-Keyframes.png"
width="500" />
2. Select **Add Keyframe Here**.
Note that the keyframes insert at the frame position closest to where you click,
not at the position of the scrubber.
### Move keyframes
You can increase or decrease the amount of time between keyframes by moving
either individual keyframes or every keyframe in a frame position.
To move a single keyframe:
1. Navigate to the **timeline** and click on any **gray keyframe**.
Both the **gray keyframe** and the **white keyframe** are now
surrounded with a blue border.
<img
src="../assets/animation/animation-editor/Select-Single-Keyframe.png"
width="500" />
2. Click-and-drag it to a new frame position.
To move every keyframe in a frame position:
1. Navigate to the **timeline** and click on the **white keyframe** in
the dark region above the tracks. Every keyframe in the frame
position is now surrounded with a blue border.
<img
src="../assets/animation/animation-editor/Select-Multiple-Keyframes.png"
width="500" />
2. Click-and-drag it to a new frame position.
### Duplicate keyframes
You can duplicate either a specific keyframe or multiple keyframes for
multiple parts into a new position in the timeline. This is particularly
useful for when you want to
To duplicate one or more keyframes:
1. Navigate to the **timeline** and select one or more keyframes. Every selected keyframe is now surrounded by a blue border.
1. Press <kbd>Ctrl</kbd><kbd>C</kbd> (<kbd>⌘</kbd><kbd>C</kbd>). Every selected keyframe copies to your clipboard.
1. Move the **scrubber** to a new frame position.
1. Press <kbd>Ctrl</kbd><kbd>V</kbd> (<kbd>⌘</kbd><kbd>V</kbd>). The keyframe(s) paste into the new frame position.
### Delete keyframes
To delete one or more keyframes, select the keyframe(s), then press
**Delete** or **Backspace**.
### Optimize keyframes
Animators can often generate many keyframes during the course of animation, especially when using various animation tools and features. To help reduce the number of unnecessary keyframes and make it easier to animate on the timeline, the **Animation Editor** provides tools for [automatic](#automatic-optimization) and [on-demand](#on-demand-optimization) keyframe optimization.
#### Automatic optimization
The **Animation Editor** automatically detects and removes unnecessary keyframes when creating [facial animations](../art/characters/facial-animation/animate-heads.md) and when [promoting a keyframe animation to a curve animation](../animation/curve-editor.md#open-the-curve-editor).
If 3 or more consecutive keyframes have the same value in a track, the **Animation Editor** removes the intermediary keyframes and keeps only the first and last keyframes.
If the track only contains keyframes with default values, such as an `Datatype.CFrame.identity|Identity Cframe`, or a `0` value for a curve animation, the entire track is removed from the animation.
#### On-demand optimization
<img
alt="Optimize Keyframes"
src="../assets/animation/animation-editor/Optimization-Preview.png"
width="90%" />
During animating, you can use the editor's **Keyframe Optimization** tool to quickly reduce the number of unnecessary keyframes. Keyframe Optimization prioritizes the least impactful keyframes first. You can adjust the number of keyframes using the slider.
While using the slider, you can preview the animation and scrub through the timeline to check your animation but you can not perform editing operations, such as changing keyframe values or adding tracks.
To access the **Optimize Keyframes** tool:
1. In the **Animation Editor**, click \***\*⋯\*\*** button and select **Optimize Keyframes**. A dialog box with a slider displays.
<img
alt="Optimize Keyframes"
src="../assets/animation/animation-editor/Optimize-Keyframes.png"
width="20%" />
2. Move the slider to the desired number of keyframes. You can preview and playback the animation to verify the optimization.
<img
alt="Optimize Keyframes"
src="../assets/animation/animation-editor/Optimization-Slider.png"
width="40%" />
3. Click **OK** when complete.
### Easing
For each keyframe in the [Animation Editor](../animation/editor.md), you can choose both an
[easing style](#easing-style) and an [easing direction](#easing-direction).
#### Easing style
**Easing style** is the rate at which an animation moves between different frame
positions within the animation. By default, a part will move and/or rotate from
one keyframe to the next in an even, steady motion known as **linear easing**.
In the following video, linear easing makes the character's turning animation
appear stiff and robotic.
<figure>
<video src="../assets/animation/animation-editor/Easing-Linear.mp4" controls width="100%"></video>
<figcaption>Linear easing</figcaption>
</figure>
While that may look appropriate for some motions, compare the following video
where **cubic easing** makes the animation of the character's motion appear more
natural.
<figure>
<video src="../assets/animation/animation-editor/Easing-Cubic.mp4" controls width="100%"></video>
<figcaption>Cubic easing</figcaption>
</figure>
To change the easing style for one or more keyframes:
1. Navigate to the **timeline** and select one or more keyframes. Every selected
keyframe is now surrounded by a blue border.
2. Right-click on a **keyframe with a border**. A pop-up menu displays.
3. Hover over **Easing Style**, then choose from the following options:
- **Linear** - Moves at a constant speed.
- **Constant** - Removes interpolation between the selected keyframe and
next keyframe. The animation will "snap" from keyframe to keyframe.
- **Cubic** - Eases in or out with cubic interpolation.
- **Elastic** - Moves as if the object is attached to a rubber band.
- **Bounce** - Moves as if the start or end position of the tween is bouncy.
#### Easing direction
**Easing direction** defines which end of the animation movement is affected by
the [easing style](#easing-style). By default, the motion is slower at the
beginning and faster toward the end of the animation.
To change the easing direction for one or more keyframes:
1. Navigate to the **timeline** and select one or more keyframes. Every selected
keyframe is now surrounded by a blue border.
1. Right-click on a **keyframe with a border**. A pop-up menu displays.
1. Hover over **Easing Direction**, then choose from the following options:
- **Out** - The motion will be faster at the beginning and slower toward the
end.
- **InOut** - **In** and **Out** on the same tween, with **In** at the
beginning and **Out** taking effect halfway through.
- **In** - The motion will be slower at the beginning and faster toward the
end.
## Loop an animation
To make an animation automatically loop, navigate to the [Media and
Playback Controls](#media-and-playback-controls) and click
the **Looping** button.
<img src="../assets/animation/animation-editor/Controls-Looping.png"
width="330" />
A looping animation doesn't interpolate between the final
keyframes and first keyframes. To make the animation loop smoothly,
<a href="#duplicating-keyframes">duplicate</a> the first
keyframes and use them as the final keyframes.
## Set a priority
An animation's **priority** (`Enum.AnimationPriority`) dictates when it will play in an
experience. For example, if you play an animation with a higher priority
than another animation that's already playing, the new animation will
override the old. For example, a "jump" animation should take priority over an "idle" animation so that a character doesn't perform both at the same time.
Roblox uses seven levels of priority, ordered here from highest to lowest:
<img src="../assets/misc/Arrow-Highest.png" width="50" style=} />
**Action4**
<img src="../assets/misc/Arrow-Higher.png" width="50" style=} />
**Action3**
<img src="../assets/misc/Arrow-High.png" width="50" style=} />
**Action2**
<img src="../assets/misc/Arrow-Neutral.png" width="50" style=} />
**Action**
<img src="../assets/misc/Arrow-Low.png" width="50" style=} />
**Movement**
<img src="../assets/misc/Arrow-Lower.png" width="50" style=} />
**Idle**
<img src="../assets/misc/Arrow-Lowest.png" width="50" style=} />
**Core**
<br />
To set an animation to a different priority:
1. Navigate to the [Media and Playback Controls](#media-and-playback-controls)
and click the **⋯** button. A
contextual menu displays.
1. Hover over **Set Animation Priority**, then choose your desired
priority setting.
## Save an animation
When you save an animation, Studio saves it as a
`Class.KeyframeSequence` object in `Class.ServerStorage` and adds a reference to your rig object. Saving your animation is meant to preserve your animation progress and work. If you intend to use an animation, [export it](#export-an-animation) before referencing the published animation in your experience.
To save an animation:
1. Navigate to the [Media and Playback Controls](#media-and-playback-controls)
and click the **⋯** button. A
contextual menu displays.
<img src="../assets/animation/animation-editor/Controls-File-Menu.png"
width="330" />
2. Select **Save** or **Save As** to save the animation with a reference added to the **AnimSaves** object.
<img src="../assets/animation/animation-editor/Saved-Animation.png"
width="320" />
### Access local data
Roblox saves animation data locally to `Class.ServerStorage` to preserve your animation work. In most cases, your experience shouldn't directly access this local data and instead should reference a published animation.
In the rare cases that your experience requires accessing local data, reference the value of the `Class.ObjectValue` in your rig's AnimSaves folder rather than directly accessing the `Class.ServerStorage`. See the following examples:
```lua title="Access local animation data"
local myAnim = myRig.AnimSaves.Value.myAnimation
-- Accesses your local animation data with the value reference in your rig
```
```lua title="Incorrectly access local data"
local myAnim = ServerStorage.RBX_ANIMSAVES.myRig.myAnimation
-- Can conflict with other rigs sharing the same name
```
Since local data is stored in `Class.ServerStorage`, it doesn't replicate and isn't available from clients. If your clients need access to that data, you must move the `Class.KeyframeSequence` or `Class.CurveAnimation` objects and their descendants to `Class.ReplicatedStorage`.
### Migrate legacy data
The **Animation Editor** previously stored animation objects directly within a rig, not within `Class.ServerStorage`. If your experience references legacy animation objects in a rig, you can migrate this data to `Class.ServerStorage` using the animation migration tool, allowing you to [access local animation data](#access-local-data) in the same way.
To migrate your legacy animation data:
1. With the **Animation Editor**, select a rig with older animations that aren't saved in `Class.ServerStorage`. A migration window displays.
<img src="../assets/animation/animation-editor/Migrate-Animations.png" width = "65%" />
2. Select **Delete**, **Migrate**, or **Ignore** for each detected animation.
- **Delete**: Delete animations that are already published or no longer being used.
- **Migrate**: Migrate animations that are still in progress or that haven't yet been published.
- **Ignore**: Ignore animations if you have yet to update your experience's code to [access local data](#access-local-data) from `Class.ServerStorage`. Once updated, migrate these animations.
3. Press **OK** when complete.
## Export an animation
When you export an animation to Studio, it becomes available for use in
all experiences. This means that you only need to create an animation
once, then you can reuse it as many times as you want.
If your animation will be used for a **default** Roblox character animation like jumping or running, ensure that you rename the final keyframe as outlined in the first step below.
To export an animation:
1. **(Important)** If the animation will be used to [replace a default character animation](../animation/using.md#replace-default-animations) like running or jumping, rename the final keyframe **End** as follows:
1. Right-click the final white keyframe symbol in the upper bar region and choose **Rename Key Keyframe** from the
contextual menu.
<img src="../assets/animation/animation-editor/Select-Final-Keyframe.png" width="500" />
2. Type **End** (case-sensitive) into the input field.
3. Click the **Save** button.
2. Navigate to the [Media and Playback Controls](#media-and-playback-controls)
and click the **⋯** button.
<img src="../assets/animation/animation-editor/Controls-File-Menu.png"
width="330" />
3. Select **Publish to Roblox** from the contextual menu.
4. In the **Asset Configuration** window, enter an animation title and optional description.
5. **(Important)** If the animation will be used in any [group-owned](../projects/groups.md) experience, select the group from the **Creator** field.
6. Click the **Submit** button.
Once the upload is complete, you can copy the animation's asset ID
from the [Toolbox](../projects/assets/toolbox.md) for scripting custom animations or to replace default character animations, as outlined in [Use animations](../animation/using.md).
1. Click the **Creations** tab and select **Animations** from the dropdown menu.
2. Right-click the desired animation and select **Copy Asset ID** from the contextual menu.
3. See [Use animations](../animation/using.md) for instructions on how to play the animation from a script or use the animation as a default character animation. | 5,835 | 9ef2ac748490d9dfdd19f33862a42d031e7b7e87ad36c589624348fd5b289da2 |
https://create.roblox.com/docs/animation/using | content/en-us/animation/using.md | guide | 2026-03-29T11:46:37.078730+00:00 | # Using
Once you have [created an animation](../animation/editor.md), you need to use scripts to include them in your experience. You can either [play animations manually](#play-animations-from-scripts) from scripts or [replace default animations](#replace-default-animations) for player characters.
## Play animations from scripts
In some cases, you'll need to play an animation directly from inside a script, such as when a user presses a certain key or picks up a special item.
### Humanoids
To play an animation on a rig containing a `Class.Humanoid`
object, such as typical playable characters, follow this basic pattern:
1. Ensure that the local player's `Class.Humanoid` contains an `Class.Animator` object.
2. Create a new `Class.Animation` instance with the proper `Class.Animation.AnimationId|AnimationId`.
3. Load the animation via `Class.Animator:LoadAnimation()` to create an `Class.AnimationTrack`.
4. Play the track with `Class.AnimationTrack:Play()`.
For example, the following `Class.LocalScript`, when placed in
`Class.StarterPlayerScripts`, loads a "kick" animation onto the player's character and plays it. The script also utilizes the `Class.AnimationTrack:GetMarkerReachedSignal()|GetMarkerReachedSignal()` method to detect when a specific [animation event](../animation/events.md) occurs.
```lua title="LocalScript - Play Custom Animation on Player Character"
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
-- Ensure that the character's humanoid contains an "Animator" object
local humanoid = character:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
-- Create a new "Animation" instance and assign an animation asset ID
local kickAnimation = Instance.new("Animation")
kickAnimation.AnimationId = "rbxassetid://2515090838"
-- Load the animation onto the animator
local kickAnimationTrack = animator:LoadAnimation(kickAnimation)
-- If a named event was defined for the animation, connect it to "GetMarkerReachedSignal()"
kickAnimationTrack:GetMarkerReachedSignal("KickEnd"):Connect(function(paramString)
print(paramString)
end)
task.wait(4)
-- Play the animation track
kickAnimationTrack:Play()
```
### Non-humanoids
To play animations on rigs that do **not** contain a `Class.Humanoid`, you must create an `Class.AnimationController` with a child `Class.Animator`. For example, the following `Class.Script` (assumed to be a direct child of the rig) loads a "kick" animation and plays it.
```lua title="Script - Play Custom Animation on Character Rig"
local rig = script.Parent
-- Create a new "Animation" instance and assign an animation asset ID
local kickAnimation = Instance.new("Animation")
kickAnimation.AnimationId = "rbxassetid://2515090838"
-- Create a new "AnimationController" and "Animator"
local animationController = Instance.new("AnimationController")
animationController.Parent = rig
local animator = Instance.new("Animator")
animator.Parent = animationController
-- Load the animation onto the animator
local kickAnimationTrack = animator:LoadAnimation(kickAnimation)
-- If a named event was defined for the animation, connect it to "GetMarkerReachedSignal()"
kickAnimationTrack:GetMarkerReachedSignal("KickEnd"):Connect(function(paramString)
print(paramString)
end)
task.wait(4)
-- Play the animation track
kickAnimationTrack:Play()
```
## Replace default animations
By default, Roblox player characters include common animations like running,
climbing, swimming, and jumping. You can replace these [default animations](#default-character-animations) with animations from the [catalog](#catalog-animations) or with your own [custom](../animation/editor.md) animations.
1. Obtain the **asset ID** of the new animation as follows:
- For a custom animation built with the [Animation Editor](../animation/editor.md), follow the [export](../animation/editor.md#exporting-an-animation) instructions.
- Copy an appropriate ID from the [catalog animation reference](#catalog-animations) below. For example, to replace the default run animation with the <a href="https://www.roblox.com/catalog/658830056/Ninja-Run" target="_blank" rel="noopener">Ninja Run</a> variant, use `656118852`.
2. In the [Explorer](../studio/explorer.md) window, add a new `Class.Script` to **ServerScriptService**.
1. Hover over **ServerScriptService** and click the ⊕ button.
2. From the contextual menu, insert a **Script**.
3. In the new script, paste the following code:
```lua title="Script - Replace Default Character Animations"
local Players = game:GetService("Players")
local function onCharacterAdded(character)
-- Get animator on humanoid
local humanoid = character:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
-- Stop all animation tracks
for _, playingTrack in animator:GetPlayingAnimationTracks() do
playingTrack:Stop(0)
end
local animateScript = character:WaitForChild("Animate")
--animateScript.run.RunAnim.AnimationId = "rbxassetid://"
--animateScript.walk.WalkAnim.AnimationId = "rbxassetid://"
--animateScript.jump.JumpAnim.AnimationId = "rbxassetid://"
--animateScript.idle.Animation1.AnimationId = "rbxassetid://"
--animateScript.idle.Animation2.AnimationId = "rbxassetid://"
--animateScript.fall.FallAnim.AnimationId = "rbxassetid://"
--animateScript.swim.Swim.AnimationId = "rbxassetid://"
--animateScript.swimidle.SwimIdle.AnimationId = "rbxassetid://"
--animateScript.climb.ClimbAnim.AnimationId = "rbxassetid://"
end
local function onPlayerAdded(player)
player.CharacterAppearanceLoaded:Connect(onCharacterAdded)
end
Players.PlayerAdded:Connect(onPlayerAdded)
```
4. For each line that references a [default character animation](#default-character-animations), uncomment it and paste the replacement ID after `rbxassetid://`. For example, to change the default run animation to the <a href="https://www.roblox.com/catalog/658830056/Ninja-Run" target="_blank" rel="noopener">Ninja Run</a> variant:
```lua title="Script - Replace Default Character Animations" highlight="14"
local Players = game:GetService("Players")
local function onCharacterAdded(character)
-- Get animator on humanoid
local humanoid = character:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
-- Stop all animation tracks
for _, playingTrack in animator:GetPlayingAnimationTracks() do
playingTrack:Stop(0)
end
local animateScript = character:WaitForChild("Animate")
animateScript.run.RunAnim.AnimationId = "rbxassetid://656118852"
--animateScript.walk.WalkAnim.AnimationId = "rbxassetid://"
--animateScript.jump.JumpAnim.AnimationId = "rbxassetid://"
--animateScript.idle.Animation1.AnimationId = "rbxassetid://"
--animateScript.idle.Animation2.AnimationId = "rbxassetid://"
--animateScript.fall.FallAnim.AnimationId = "rbxassetid://"
--animateScript.swim.Swim.AnimationId = "rbxassetid://"
--animateScript.swimidle.SwimIdle.AnimationId = "rbxassetid://"
--animateScript.climb.ClimbAnim.AnimationId = "rbxassetid://"
end
local function onPlayerAdded(player)
player.CharacterAppearanceLoaded:Connect(onCharacterAdded)
end
Players.PlayerAdded:Connect(onPlayerAdded)
```
## Set animation weights
You can use multiple animations for the same action. For example, there
are two `idle` variations in the code sample for [replacing default animations](#replace-default-animations).
When multiple animations exist for a character state, the **Animate** script
randomly chooses which one to play, but you can influence the outcome by
setting the animation's `Weight` value under the following formula:
- **animation weight / total weight of all state animations**
In the following example, `idle.Animation1` will play ⅓ of the time the character is idle, while `idle.Animation2` will play ⅔ of the time.
```lua title="Script - Replace Default Character Animations" highlight="3,4"
animateScript.idle.Animation1.AnimationId = "rbxassetid://656117400"
animateScript.idle.Animation2.AnimationId = "rbxassetid://656118341"
animateScript.idle.Animation1.Weight.Value = 5
animateScript.idle.Animation2.Weight.Value = 10
```
## Animation references
### Default character animations
The following table contains all of the default character animations that you can [replace](#replace-default-animations) with [catalog](#catalog-animations) animations or your own [custom](../animation/editor.md) animations. Note that **Idle** has two variations which you can [weight](#set-animation-weights) to play more or less frequently.
<table>
<tbody>
<tr>
<th>Character action</th>
<th>Animate script reference</th>
</tr>
<tr>
<td>**Run**</td>
<td>`animateScript.run.RunAnim.AnimationId`</td>
</tr>
<tr>
<td>**Walk**</td>
<td>`animateScript.walk.WalkAnim.AnimationId`</td>
</tr>
<tr>
<td>**Jump**</td>
<td>`animateScript.jump.JumpAnim.AnimationId`</td>
</tr>
<tr>
<td>**Idle**</td>
<td>
`animateScript.idle.Animation1.AnimationId`<br />
`animateScript.idle.Animation2.AnimationId`
</td>
</tr>
<tr>
<td>**Fall**</td>
<td>`animateScript.fall.FallAnim.AnimationId`</td>
</tr>
<tr>
<td>**Swim**</td>
<td>
`animateScript.swim.Swim.AnimationId`
</td>
</tr>
<tr>
<td>**Swim (Idle)**</td>
<td>
`animateScript.swimidle.SwimIdle.AnimationId`
</td>
</tr>
<tr>
<td>**Climb**</td>
<td>`animateScript.climb.ClimbAnim.AnimationId`</td>
</tr>
</tbody>
</table>
### Catalog animations
When using avatar animation bundles to [replace default animations](#replace-default-animations), use the following references for the respective asset IDs. For example, if you want to apply the <a href="https://www.roblox.com/catalog/658832070/Ninja-Jump" target="_blank" rel="noopener">Ninja Jump</a> animation, use `656117878`. Note that **Idle** has multiple variations.
<table>
<tbody>
<tr>
<td>
<a href="https://www.roblox.com/bundles/34/Astronaut-Animation-Pack" target="_blank" rel="noopener">**Astronaut**</a>
</td>
<td>
**Run**<br />891636393
**Walk**<br />891636393
**Jump**<br />891627522
**Idle**<br />891621366, 891633237, 1047759695
**Fall**<br />891617961
**Swim**<br />891639666
**Swim (Idle)**<br />891663592
**Climb**<br />891609353
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/39/Bubbly-Animation-Package" target="_blank" rel="noopener">**Bubbly**</a>
</td>
<td>
**Run**<br />910025107
**Walk**<br />910034870
**Jump**<br />910016857
**Idle**<br />910004836, 910009958, 1018536639
**Fall**<br />910001910
**Swim**<br />910028158
**Swim (Idle)**<br />910030921
**Climb**<br />909997997
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/56/Cartoony-Animation-Package" target="_blank" rel="noopener">**Cartoony**</a>
</td>
<td>
**Run**<br />742638842
**Walk**<br />742640026
**Jump**<br />742637942
**Idle**<br />742637544, 742638445, 885477856
**Fall**<br />742637151
**Swim**<br />742639220
**Swim (Idle)**<br />742639812
**Climb**<br />742636889
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/48/Elder-Animation-Package" target="_blank" rel="noopener">**Elder**</a>
</td>
<td>
**Run**<br />845386501
**Walk**<br />845403856
**Jump**<br />845398858
**Idle**<br />845397899, 845400520, 901160519
**Fall**<br />845396048
**Swim**<br />845401742
**Swim (Idle)**<br />845403127
**Climb**<br />845392038
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/68/Knight-Animation-Package" target="_blank" rel="noopener">**Knight**</a>
</td>
<td>
**Run**<br />657564596
**Walk**<br />657552124
**Jump**<br />658409194
**Idle**<br />657595757, 657568135, 885499184
**Fall**<br />657600338
**Swim**<br />657560551
**Swim (Idle)**<br />657557095
**Climb**<br />658360781
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/79/Levitation-Animation-Pack" target="_blank" rel="noopener">**Levitation**</a>
</td>
<td>
**Run**<br />616010382
**Walk**<br />616013216
**Jump**<br />616008936
**Idle**<br />616006778, 616008087, 886862142
**Fall**<br />616005863
**Swim**<br />616011509
**Swim (Idle)**<br />616012453
**Climb**<br />616003713
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/63/Mage-Animation-Package" target="_blank" rel="noopener">**Mage**</a>
</td>
<td>
**Run**<br />707861613
**Walk**<br />707897309
**Jump**<br />707853694
**Idle**<br />707742142, 707855907, 885508740
**Fall**<br />707829716
**Swim**<br />707876443
**Swim (Idle)**<br />707894699
**Climb**<br />707826056
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/75/Ninja-Animation-Package" target="_blank" rel="noopener">**Ninja**</a>
</td>
<td>
**Run**<br />656118852
**Walk**<br />656121766
**Jump**<br />656117878
**Idle**<br />656117400, 656118341, 886742569
**Fall**<br />656115606
**Swim**<br />656119721
**Swim (Idle)**<br />656121397
**Climb**<br />656114359
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/55/Pirate-Animation-Package" target="_blank" rel="noopener">**Pirate**</a>
</td>
<td>
**Run**<br />750783738
**Walk**<br />750785693
**Jump**<br />750782230
**Idle**<br />750781874, 750782770, 885515365
**Fall**<br />750780242
**Swim**<br />750784579
**Swim (Idle)**<br />750785176
**Climb**<br />750779899
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/82/Robot-Animation-Pack" target="_blank" rel="noopener">**Robot**</a>
</td>
<td>
**Run**<br />616091570
**Walk**<br />616095330
**Jump**<br />616090535
**Idle**<br />616088211, 616089559, 885531463
**Fall**<br />616087089
**Swim**<br />616092998
**Swim (Idle)**<br />616094091
**Climb**<br />616086039
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/356/Rthro-Animation-Package" target="_blank" rel="noopener">**Rthro**</a>
</td>
<td>
**Run**<br />2510198475
**Walk**<br />2510202577
**Jump**<br />2510197830
**Idle**<br />2510197257, 2510196951, 3711062489
**Fall**<br />2510195892
**Swim**<br />2510199791
**Swim (Idle)**<br />2510201162
**Climb**<br />2510192778
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/83/Stylish-Animation-Pack" target="_blank" rel="noopener">**Stylish**</a>
</td>
<td>
**Run**<br />616140816
**Walk**<br />616146177
**Jump**<br />616139451
**Idle**<br />616136790, 616138447, 886888594
**Fall**<br />616134815
**Swim**<br />616143378
**Swim (Idle)**<br />616144772
**Climb**<br />616133594
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/81/Superhero-Animation-Pack" target="_blank" rel="noopener">**Superhero**</a>
</td>
<td>
**Run**<br />616117076
**Walk**<br />616122287
**Jump**<br />616115533
**Idle**<br />616111295, 616113536, 885535855
**Fall**<br />616108001
**Swim**<br />616119360
**Swim (Idle)**<br />616120861
**Climb**<br />616104706
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/43/Toy-Animation-Pack" target="_blank" rel="noopener">**Toy**</a>
</td>
<td>
**Run**<br />782842708
**Walk**<br />782843345
**Jump**<br />782847020
**Idle**<br />782841498, 782845736, 980952228
**Fall**<br />782846423
**Swim**<br />782844582
**Swim (Idle)**<br />782845186
**Climb**<br />782843869
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/33/Vampire-Animation-Pack" target="_blank" rel="noopener">**Vampire**</a>
</td>
<td>
**Run**<br />1083462077
**Walk**<br />1083473930
**Jump**<br />1083455352
**Idle**<br />1083445855, 1083450166, 1088037547
**Fall**<br />1083443587
**Swim**<br />1083464683
**Swim (Idle)**<br />1083467779
**Climb**<br />1083439238
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/32/Werewolf-Animation-Pack" target="_blank" rel="noopener">**Werewolf**</a>
</td>
<td>
**Run**<br />1083216690
**Walk**<br />1083178339
**Jump**<br />1083218792
**Idle**<br />1083195517, 1083214717, 1099492820
**Fall**<br />1083189019
**Swim**<br />1083222527
**Swim (Idle)**<br />1083225406
**Climb**<br />1083182000
</td>
</tr>
<tr>
<td>
<a href="https://www.roblox.com/bundles/80/Zombie-Animation-Pack" target="_blank" rel="noopener">**Zombie**</a>
</td>
<td>
**Run**<br />616163682
**Walk**<br />616168032
**Jump**<br />616161997
**Idle**<br />616158929, 616160636, 885545458
**Fall**<br />616157476
**Swim**<br />616165109
**Swim (Idle)**<br />616166655
**Climb**<br />616156119
</td>
</tr>
</tbody>
</table> | 5,207 | d15e60fefdd5755053c659468f7d6f973da273699c577354227067757c648c7f |
https://create.roblox.com/docs/art/accessories/body-scale | content/en-us/art/accessories/body-scale.md | guide | 2026-03-29T11:46:37.082063+00:00 | # Body Scale
Roblox supports three common avatar sizes, known as **Classic**, **Rthro**, and **Rthro Slender**. This standard sizing helps keep avatar characters consistent, allowing developers to create experiences and environments that can fit commonly sized character models.
When modeling rigid accessories, like a helmet that contours around a character's head, it's important to use a mannequin to help ensure your proportions fit. The asset provided in this tutorial example was originally modeled using **Rthro** proportions. Layered clothing, such as clothing, don't require body scale specification, since layered assets automatically stretch and deform over any body scale.
If you are modeling your asset, visit the [references resources](../../avatar/resources.md#references) to download any of the following mesh mannequin:
<figure>
<img src="../../assets/art/resources/Body-Scale-Classic.png" />
<figcaption>
Classic blocky body scale. <br /><br /> Roughly 4.75 studs tall.
</figcaption>
</figure>
<figure>
<img src="../../assets/art/resources/Body-Scale-Rthro-Normal.png" />
<figcaption>
Normal body scale. <br /><br /> Roughly 5.75-6.5 studs tall, with wider shoulders and narrower hips.
</figcaption>
</figure>
<figure>
<img src="../../assets/art/resources/Body-Scale-Rthro-Slender.png" />
<figcaption>
Slender body scale. <br /><br /> Roughly 5.25-6.25 studs tall, with narrower shoulders and wider hips.
</figcaption>
</figure>
See the [accessory apecifications](../../art/accessories/specifications.md#body-scale) and the [body specifications](../../art/characters/specifications.md#body-scale) for specific range values and other geometry requirements.
## AvatarPartScaleType
Roblox represents body scale in the engine by an `AvatarPartScaleType` `Class.StringValue` object within each avatar character part and associated accessory. In most cases, asset creators do not need to directly access or modify this value object since tools, such as the [Accessory Fitting Tool](../accessories/accessory-fitting-tool.md), automatically generate the appropriate value object on accessory creation.
In cases where you may need to identify the current body scale of a body part or accessory, the following table defines the `AvatarPartScaleType` value for each type of body size. When importing your model, use the 3D Importer's [Rig Scale](../modeling/3d-importer.md#rig-general) to automatically apply a scale to your icustom asset.
<table>
<thead>
<tr>
<th>Body Scale</th>
<th>AvatarPartScaleType value</th>
</tr>
</thead>
<tbody>
<tr>
<td>Classic</td>
<td>`Classic`</td>
</tr>
<tr>
<td>Normal</td>
<td>`ProportionsNormal`</td>
</tr>
<tr>
<td>Slender</td>
<td>`ProportionsSlender`</td>
</tr>
</tbody>
</table> | 670 | 6d4641fdae707ce1c9e34632a1fdbf2471bf339265b0f1a55332207a66437771 |
https://create.roblox.com/docs/art/accessories/clothing-export-settings | content/en-us/art/accessories/clothing-export-settings.md | guide | 2026-03-29T11:46:37.122630+00:00 | # Clothing Export Settings
Export your mesh or model as a `.fbx` or `.gltf` to take advantage of all of Studio's 3D import features. When rigging or skinning a layerable model, these file types contains all the mesh and texture data, including the rig and influence data, you need to later [import](../../art/modeling/3d-importer.md) into Studio.
If creating other types of 3D models:
<ul>
<li>For generic meshes, see [general mesh specifications](../modeling/specifications.md) and [general export settings](../modeling/export-requirements.md).</li> <br />
<li>For rigid accessories, see [accessory specifications](../accessories/specifications.md) and [accessory export settings](../accessories/export-settings.md).</li> <br />
<li>For avatar characters, see [avatar specifications](../characters/specifications.md) and [avatar export settings](../characters/export-settings.md).</li>
</ul>
## Before exporting
Before exporting, ensure that you are only exporting the Roblox supported objects related to your model. If you have any modifiers to your mesh or project objects, make sure to apply or delete them before export.
You can export layered clothing models with the following object structure:
<img src="../../assets/modeling/skinned-meshes/Clothing-Data-Model.png" width="60%" alt="Blender clothing data model example" />
- Armature parent
- Bones / joints
- Primary mesh object
- Cage parent object
- Inner cage mesh object
- Outer cage mesh object
You can also export shoes together. Even though left and right shoes are separate accessories, you can either export the left and right shoe individually, or export both shoes at the same time using the following structure:
<img src="../../assets/modeling/skinned-meshes/Shoe-Data-Model.png" width="60%" alt="Shoe clothing data model example"/>
- Armature parent
- Bones / joints
- Left shoe mesh object
- Right shoe mesh object
- Cage parent object
- Left shoe inner cage
- Left shoe outer cage
- Right shoe inner cage
- Right shoe outer cage
Each shoe must include their own inner and outer cage.
## Blender
Blender allows you to export in `.fbx` or `.gltf` as well as other formats. If you are using `.fbx` export, familiarize yourself with [Blender's FBX scaling](../blender.md#adjust-scale-fbx) to ensure that you successfully import the model into Studio at the correct scale.
### Export settings
To export the `.fbx` file in Blender:
1. In the topbar, click **File**. A pop-up menu displays.
2. Select **Export**, then **FBX (.fbx)**. The **Blender File View** window displays.
3. On the right-hand side, change the **Path Mode** property to **Copy**, then toggle the **Embed Textures** button.
<img src="../../assets/modeling/skinned-meshes/Blender-Export-Settings-1.png" width="320" />
4. If your project doesn't already have `.01` scene unit scaling, set the **Transform** > **Apply Scalings** to `FBX Unit Scale`. For more details, see [Blender FBX scaling](../blender.md#adjust-scale-fbx).
<img src="../../assets/modeling/skinned-meshes/Blender-Export-Settings-5.png" width="320" />
5. Under the **Armature** section, disable **Add Leaf Bones**.
<img src="../../assets/modeling/skinned-meshes/Blender-Export-Settings-3.png" width="320" />
6. Click the **Export FBX** button.
7. After exporting, use Studio's [3D Importer](../../art/modeling/3d-importer.md) to import your model and the [Accessory Fitting Tool](../../art/accessories/accessory-fitting-tool.md) to convert the model into an accessory.
## Maya export settings
To export a mesh in Maya as a `.fbx` file:
1. In the topbar, click **File**. A pop-up menu displays.
2. Select **Export All**. The **Export All** window displays.
3. Near the bottom of the window, click the **Files of type** dropdown, then select **FBX export**.
4. On the right-hand side of the window, navigate to the **Options...** section.
5. In the **Geometry** section, enable **Smooth Mesh** and **Referenced Asset Content**.
6. If you need to import textures as a `.png`, in the **Embed Media** section, enable **Embed Media**.
7. In the **Advanced Options** section,
- Navigate to **Units**, then enable **Automatic**.
- Navigate to **Axis Conversion**, then set the **Up Axis** property to **Y**.
8. Click the **Export All** button.
<img src="../../assets/accessories/lc-requirements-maya-settings-with-animation.png" />
9. After exporting, use Studio's [3D Importer](../../art/modeling/3d-importer.md) to import your model and the [Accessory Fitting Tool](../../art/accessories/accessory-fitting-tool.md) to convert the model into an accessory. | 1,147 | 9a02d6b58aef387b35b99e8635c765153748cde0d5ec47ee6994e409a4780a70 |
https://create.roblox.com/docs/art/accessories/clothing-specifications | content/en-us/art/accessories/clothing-specifications.md | guide | 2026-03-29T11:46:37.132298+00:00 | # Clothing Specifications
When creating clothing for Roblox, it's important to meet specific technical requirements to ensure compatibility and optimize for performance and quality. Many of these requirements must be applied when designing and modeling your asset in a third-party modeling application.
Although [rigid accessories](../../art/accessories/specifications.md) and layerable accessories share many technical requirements, layerable clothing accessories must include additional components to ensure the accessories deform and stretch appropriately on different body scales.
If you are intending to publish and sell these assets on the Marketplace, there are additional [Marketplace policy](../../marketplace/marketplace-policy.md) standards that you must follow for any accessory or clothing item.
When ready to export, see [export requirements](../../art/accessories/clothing-export-settings.md) for mesh export settings for Blender and Maya.
If creating other types of 3D models:
<ul>
<li>For generic meshes, see [general mesh specifications](../modeling/specifications.md) and [general export settings](../modeling/export-requirements.md).</li> <br />
<li>For rigid accessories, see [accessory specifications](../accessories/specifications.md) and [accessory export settings](../accessories/export-settings.md).</li> <br />
<li>For avatar characters, see [avatar specifications](../characters/specifications.md) and [avatar export settings](../characters/export-settings.md).</li>
</ul>
## Geometry and Budgets
- **Single Mesh** - Accessories must be a single mesh.
- **Budgets** - Accessories can't exceed **4k** triangles.
- **Watertight** - All geometry must be watertight without exposed holes or backfaces.
- Use **quads** whenever possible. Avoid faces with 5 or more sides.
- **Mesh Size** - Depending on the type of accessory asset, meshes must follow a standard size (in studs, centered on attachment point) depending on the [body scale](#size-requirements) it is designed for.
### Size Requirements
Depending on the type of layerable asset, the size requirements can't exceed the following maximum width, height, and depth (in studs).
<table>
<thead>
<tr>
<th>Asset Type</th>
<th>Width (X)</th>
<th>Height (Y)</th>
<th>Depth (Z)</th>
</tr>
</thead>
<tbody>
<tr>
<td>T-Shirt, Shirt, Sweater, Jacket, Pants, Shorts, Dress & Skirt</td>
<td>8</td>
<td>8</td>
<td>8</td>
</tr>
<tr>
<td>Eyebrow and Eyelashes</td>
<td>1.5</td>
<td>0.5</td>
<td>0.5</td>
</tr>
</tbody>
</table>
### Attachment Points
`Class.Attachment` objects indicate where an accessory model attaches to a point on a character body. Whether you are creating rigid or [layered](./layered-clothing.md) accessories, Studio's [Accessory Fitting Tool](../../art/accessories/accessory-fitting-tool.md) (AFT) automatically adds and configures the appropriate `Class.Attachment` with the following specifications:
- **One attachment** - Each accessory, including layered clothing, require at least one attachment point to its associated body part.
- **Naming Convention** - The `Class.Attachment` name must follow a specific naming convention depending on the `Class.Accessory.AccessoryType`. The AFT generates an appropriate `Class.Attachment` name automatically.
If setting attachment names manually in Studio, use the following `Class.Attachment` name for each accessory type:
<table>
<thead>
<tr>
<th>Accessory Type</th>
<th>Attachment Name</th>
</tr>
</thead>
<tbody>
<tr>
<td>Hat</td>
<td>`HatAttachment`</td>
</tr>
<tr>
<td>Back</td>
<td>`BodyBackAttachment`</td>
</tr>
<tr>
<td>Waist</td>
<td>`WaistFrontAttachment`, `WaistCenterAttachment`, `WaistBackAttachment`</td>
</tr>
<tr>
<td>Shoulder</td>
<td>`RightShoulderAttachment`, `RightCollarAttachment`, `NeckAttachment`, `LeftCollarAttachment`, `LeftShoulderAttachment`</td>
</tr>
<tr>
<td>Face, Eyelash, Eyebrow</td>
<td>`FaceFrontAttachment`, `FaceCenterAttachment`</td>
</tr>
<tr>
<td>Neck</td>
<td>`NeckAttachment`</td>
</tr>
<tr>
<td>Front</td>
<td>`BodyFrontAttachment`</td>
</tr>
<tr>
<td>Layered tops (Shirt, TShirt, Sweater, Jacket)</td>
<td>`BodyFrontAttachment`</td>
</tr>
<tr>
<td>Layered bottoms (Pants, Shorts, DressSkirt)</td>
<td>`WaistCenterAttachment`</td>
</tr>
</tbody>
</table>
The 3D Importer automatically recognizes mesh objects as attachment points if the objects include the affix `\_Att`. This only applies when importing meshes with caging data, such as clothing or bodies.
- **Shoulders and Collars** - Even though they are in similar locations, Shoulder and Collar attachment points interact with character rigs differently for rigid accessories.
- Items using `RightShoulderAttachment` or `LeftShoulderAttachment` move with the character's arm.
- Items using `RightCollarAttachment` or `LeftCollarAttachment` do not move with the character's arm.
### Face Accessories
Face accessories, such as hair, eyebrows, and eyelashes are unique accessories that you can bundle with an avatar body upload. At this time, eyebrows and eyelashes can not be uploaded as standalone accessories and must be bundled with avatar bodies. For more information on bundling your face accessories with avatar models, see [Publishing bodies with eyelashes and eyebrows](../accessories/publish-eyebrows-eyelashes.md).
- **Naming Convention when bundled** - When including these assets with an avatar body upload, the accessory objects must use the following name conventions:
- `EyebrowAccessory`
- `EyelashAccessory`
- `HairAccessory`
## Textures
- Textures for Marketplace assets can't exceed 2048x2048 resolution.
- Textures created for accessories must meet Roblox's [texture specifications](../../art/modeling/texture-specifications.md). High resolution textures are automatically converted to lower-resolution textures to optimize performance.
## Layerable Properties
Clothing and accessories that deform and fit around any characters and existing clothing items require additional configuration in a 3D modeling software such as [Blender](https://www.blender.org) or [Maya](https://www.autodesk.com/products/maya/overview).
To achieve the layering effect, your clothing must meet the following requirements:
- Asset must be [weighted and bound](#rigging-and-skinning) to an R15 skeleton (Maya) or armature (Blender).
- Asset must contain an [inner mesh cage](#inner-cage) and an [outer mesh cage](#outer-cage).
- Asset must continue to follow any applicable [custom mesh requirements](../../art/characters/specifications.md), such as best practices on watertightness, textures, and polycount budgets.
See [Creating Layered Models](../../art/accessories/creating/index.md) for a basic guide on applying these requirements on a reference asset in Blender. Once the `.fbx` file is [exported](../../art/accessories/export-settings.md), see [Accessory Fitting Tool](../../art/accessories/accessory-fitting-tool.md) for instructions on creating an accessory from your model.
### Rigging and Skinning
Rigging and skinning a layered accessory allows the accessory to move naturally with a character body. You can perform this manually through a modeling tool, or [use automatic skinning transfer](../../art/accessories/automatic-skinning-transfer.md) to generate an accessory's skinning data at run time.
If using modeling software to skin your accessories, keep in mind that **Joint Influences** (Maya) or **Bone Assignments** (Blender) per vertex should be limited to **4**.
For more information on basic skinning in third-party modeling software, such as Blender's [Automatic Weights](https://docs.blender.org/manual/en/latest/animation/armatures/skinning/parenting.html#with-automatic-weights), see [Skinning a Simple Mesh](../../art/modeling/skin-a-simple-mesh.md) for instructions on rigging, applying weights, and skinning a basic mesh.
### Cage Meshes
**Cage meshes**, or **cages**, are invisible meshes that define the inner and outer surfaces of your asset and are fundamental to the layerable properties of clothing items. The inner cage determines the inside surface of a clothing item while the outer cage determines the outside surface of a clothing item.
Assets with invalid cage configurations may fail validation and are subject to moderation. See [Caging best practices](./caging-best-practices.md) for examples and instructions.
For a basic overview on caging, see the [Basic Clothing Tutorial](../accessories/creating/caging-setup.md) and the relevant section of the tutorial video at [8:32](https://www.youtube.com/watch?v=C-DwGRBHvmE&t=512s):
<iframe width="800" height="450" src="https://www.youtube-nocookie.com/embed/C-DwGRBHvmE" title="YouTube video player" frameborder="0" allow="accelerometer; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>
#### Inner Cage
The inner cage is the inner surface of your model and defines how the layered asset fits over another layered model. As a best practice, the shape of the inner and outer cage should match each other before editing the outer cage to completely cover your asset.
The inner cage mesh object must have the same name as the accessory model appended with **\_InnerCage**.
<img src="../../assets/accessories/lc-requirements-innercage.png" width="60%" />
<img src="../../assets/accessories/lc-requirements-innercage-outliner.png" width="60%" />
#### Outer Cage
The outer cage defines the external surface that another item's inner cage would layer on top of. Avatar character models must have an outer cage included with its model in order to be compatible with layered clothing. All avatar models available on the [Marketplace](https://www.roblox.com/catalog) include a properly configured outer cage and are compatible with layered assets.
The outer cage of a layered clothing asset is a mesh that precisely covers the clothing item. The outer cage included in the template files is identical to the inner cage by default and must be the only cage adjusted to fit over an accessory.
The outer cage mesh object must have the same name as the accessory model appended with **\_OuterCage**.
<img src="../../assets/accessories/lc-requirements-outercage.png" width="60%" />
<img src="../../assets/accessories/lc-requirements-outercage-outliner.png" width="60%" />
The vertexes and UVs of the inner and outer cage meshes should not be deleted or removed, as they are used to match coordinates between other cages.
## Marketplace Requirements
Your items must meet the following requirements before you upload them to the Marketplace to sell:
- Ensure that your items adhere to the [Marketplace Program Guidelines](../../marketplace/marketplace-policy.md).
- Whenever applicable, ensure that your items adhere to Roblox's [custom mesh specifications](../../art/modeling/specifications.md) and [rigid accessory specifications](../../art/accessories/specifications.md).
- Object `Class.MeshPart.Material|Material` is set to `Plastic`.
- Object `Class.MeshPart.Transparency|Transparency` is set to 0.
- Object `Class.MeshPart.VertexColor|VertexColor` is the default `1, 1, 1`.
- Your `Class.Accessory` instance does not contain extraneous objects, like `Class.Script` or additional `Class.Part` instances. | 2,661 | 67920a37ca1b22018ee4a6e73375c46a110e3c9964c0a88a6de2ec4737e66db3 |
https://create.roblox.com/docs/art/accessories/caging-best-practices | content/en-us/art/accessories/caging-best-practices.md | guide | 2026-03-29T11:46:37.236899+00:00 | # Caging Best Practices
<iframe width="800" height="450" src="https://www.youtube-nocookie.com/embed/QwZaA9Gc-WQ" title="YouTube video player" frameborder="0" allow="accelerometer; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>
<br /><br />
Caging is a complex process required to define the inner and outer surface of a layered clothing item. Properly caged assets allow your clothing items to stretch and layer in combination with each other. Cages that are improperly configured can lead to cosmetic issues with the look and feel of your clothing item.
<figure>
<img src="../../assets/accessories/caging-best-practices/7-Typical-Caging-Example-D.png" width="100%" alt=""/>
<figcaption>A properly configured cage typically includes a tight layering of the inner cage, clothing mesh, and the outer cage.</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/caging-best-practices/7-Typical-Caging-Example-B.png" width="100%" alt=""/>
<figcaption>The t-shirt stretches and fits naturally over a base body.</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/caging-best-practices/7-Typical-Caging-Example-C.png" width="100%" alt=""/>
<figcaption>Other layered objects, such as a jacket, should stretch and fit naturally over a target body and any other caged assets.</figcaption>
</figure>
In extreme cases, improper cages may interfere with gameplay or social elements on Roblox. If your asset includes improper cages, Roblox may prevent you from uploading them to the Marketplace and may remove existing assets with improper cages from the catalog.
Roblox is enforcing a stricter set of validation rules to improve the overall quality of layered clothing accessories in the Marketplace.
The following [best practices](#best-practices) and [common issues](#common-issues) is useful for 3D clothing creators of all levels and can elevate the quality of your clothing creations and save time with troubleshooting.
## Best practices
Always start any caging work with one of Roblox's [provided caging templates](../../assets/modeling/meshes/reference-files/Clothing_Cage_Templates.zip). These templates include an inner cage and outer cage with properly set UVs.
You should not edit the cage UVs since this will introduce visual artifacts.
When caging your clothing items, use these important universal guidelines:
- Any clothing mesh positioned between the inner cage and outer cage will be deformed by the layering system. This is the typical configuration for nearly all layered clothing assets.
<figure>
<img src="../../assets/accessories/caging-best-practices/7-Typical-Caging-Example-D.png" width="80%" alt=""/>
<figcaption>The t-shirt mesh fits snugly between the inner and outer cage.</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/caging-best-practices/7-Typical-Caging-Example-B.png" width="80%" alt=""/>
<figcaption>The correctly configured t-shirt naturally stretches over a target body.</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/caging-best-practices/7-Typical-Caging-Example-C.png" width="80%" alt=""/>
<figcaption>Other layered assets should stretch and fit naturally over a target body and any equipped caged assets.</figcaption>
</figure>
- You must follow the [naming conventions](../../art/accessories/clothing-specifications.md#cage-meshes) for the clothing geometry and the cage.
- Many caging issues start from incorrect outer cage setup. See [working with outer cages](#working-with-outer-cages) for specific details.
- Do not modify areas of your cage that are unrelated to the clothing item you are caging. For example, do not modify the inner or outer cages of the lower leg areas when caging a t-shirt.
- Review any specific best practices for [form-fitting clothes](#caging-form-fitting-clothing), [bulky clothes](#caging-bulky-clothing-items), and [clothing with protrusions](#caging-protrusions).
- If troubleshooting any issues, review [common issues](#common-issues) to help identify problematic clothing items or specific validation errors.
### Working with outer cages
As long as the clothing mesh properly fits **over the inner cage** and **under the outer cage**, you can edit the outer cage in various ways depending on the final visual effect you intend to achieve.
When working with the outer cage, use the following guidelines when possible:
- Move vertices outwards in the normal's direction.
<img src="../../assets/accessories/caging-best-practices/8-Symmetry.png" width="60%" alt=""/>
- Keep the outer cage as close to the clothing as possible.
- Work symmetrically as much as possible to save time.
- Do not alter the UVs in any way.
- Do not stack your vertices.
<figure>
<img src="../../assets/accessories/caging-best-practices/9-Stacking-Vertices.png" width="100%" alt=""/>
<figcaption>Two vertices stacked directly over each other. This will introduce visual artifacts when layering other layered accessories on top.</figcaption>
</figure>
- Keep the vertex, edge, and face count exactly the same as when you started.
- Keep your cage's edge spacing as evenly as possible.
<figure>
<img src="../../assets/accessories/caging-best-practices/10-Even-Spacing-A.png" width="100%" alt=""/>
<figcaption>
Outer cage with even spacing whenever possible on the faces.
</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/caging-best-practices/10-Even-Spacing-B.png" width="100%" alt=""/>
<figcaption>
Outer cage with uneven spacing throughout the torso area. Uneven cages can create visual artifacts and uneven deformations.
</figcaption>
</figure>
- Keep your cage's break lines between body parts lined up to the joint's position as possible. For example, try to align the elbow to where the LowerArm joint is located.
<figure>
<img src="../../assets/accessories/caging-best-practices/11-Positioning-Along-Joints.png" width="50%" alt=""/>
<figcaption>Proportional changes can help improve animation and posing quality.</figcaption>
</figure>
### Caging form-fitting clothing
Form-fitting clothing, like t-shirts, yoga pants, shorts, sweaters and slim jackets, are the most common type of layered clothing.
In this case, the outer cage needs to completely envelop the clothing accessory with minimal gaps between inner cage, clothing, and outer cage.
- Move outer cage vertices outwards to completely cover the clothing item, while maintaining the silhouette of the clothing as much as possible.
- Do not move outer cage vertices that don't contribute to covering the clothing item. For example, don't move outer cage vertices in the lower leg when the clothing item is a t-shirt.
- The entire clothing item should be located in-between the outer and inner cages.
### Caging bulky clothing items
Bulky clothing items, like puffy jackets, sweat pants, and hoodies, require additional displacement of the outer cage vertices will be much larger to envelop the bulky asset. The outer cage should still completely wrap the external surface of a bulky item.
- Pay special attention to the direction neighboring outer cage vertices are moved.
- Move along vertex normal directions as much as possible.
- Move vertices nearby each other more or less along the same directions (smooth relative displacements).
- Avoid moving vertices that are not covered by the clothing item, such as moving vertices in the arm region if you are making pants.
### Caging protrusions
Some clothing items may have assets that may protrude or extend past the rest of the clothing. Examples include clothing with puffy hoods, shoulder pads, and spikes.
<figure>
<img src="../../assets/accessories/caging-best-practices/12-Protusions-A.png" width="100%" alt=""/>
<figcaption>Like all clothing, clothing with protrusions should fit over inner cages.</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/caging-best-practices/12-Protusions-B.png" width="100%" alt=""/>
<figcaption>
Setting the outer cage below the puffy hood allows the hood to be visible even when equipping other layered assets.
</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/caging-best-practices/12-Protusions-C.png" width="100%" alt=""/>
<figcaption>
Setting the outer cage above the puffy hood causes additional layered assets to stretch and cover the protrusion which is often undesired.
</figcaption>
</figure>
To ensure that the protruded region stays visible independent of the number of layers:
- Leave the protruded region outside the outer cage. Alternatively, edit the outer cage to pass under the regions that are meant to be visible and undeformed.
- Avoid moving vertices that are not covered by the clothing item
## Common issues
Improper caging can cause various rendering and deformation issues. The following common examples can help diagnose and troubleshoot any caging issues you may encounter.
### Uneven caging
Unexpected outer cage shapes causes issues when other layered assets are equipped. While the clothing may fit correctly on a target body, any additional layers will fail to stretch and deform appropriately.
<figure>
<img src="../../assets/accessories/caging-best-practices/1-Uneven-Cage-A.png" width="80%" alt=""/>
<figcaption>The outer cage of the black shirt is set up with uneven vertices producing an undulated caging surface.</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/caging-best-practices/1-Uneven-Cage-B.png" width="80%" alt=""/>
<figcaption>Any layered clothing accessory fit on top will have visual artifacts even if the clothing asset itself looks fine.</figcaption>
</figure>
### Identical inner and outer cage
If the inner cage and outer cage are exactly the same, the layered clothing system cannot properly determine the accessory and may not deform or deform unexpectedly.
<figure>
<img src="../../assets/accessories/caging-best-practices/2-Inner-Outer-Identical-A.png" width="80%" alt=""/>
<figcaption>An example of an identical inner and outer cages.</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/caging-best-practices/2-Inner-Outer-Identical-B.png" width="80%" alt=""/>
<figcaption>The tshirt deforms in an unexpected manner and fails to render in its original shape or placement.</figcaption>
</figure>
### Clothing inside inner cage
Any part of the clothing mesh positioned **inside** the **inner cage** will introduce visual artifacts when the clothing is layered on top of other clothing. You should always avoid this type of configuration.
<figure>
<img src="../../assets/accessories/caging-best-practices/3-Clothing-Under-Inner-A.png" width="80%" alt=""/>
<figcaption>The clothing mesh intersects and is positioned within the inner cage at the shoulders and abdomen areas.</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/caging-best-practices/3-Clothing-Under-Inner-B.png" width="80%" alt=""/>
<figcaption>When equipped, the t-shirt does not fit properly, exposing the problematic areas in the shoulders and abdomen.</figcaption>
</figure>
### Clothing partially outside outer cage
Any part of the clothing mesh positioned **outside** the **outer cage** will not be deformed by the layered system. This configuration can sometimes be intentional for effect, such as when [caging clothing assets that include protrusions](#caging-protrusions).
<figure>
<img src="../../assets/accessories/caging-best-practices/4-Outer-Not-Fully-Covering-A.png" width="80%" alt=""/>
<figcaption>The outer cage of the tshirt is positioned within the clothing mesh near the abdomen.</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/caging-best-practices/4-Outer-Not-Fully-Covering-B.png" width="80%" alt=""/>
<figcaption>When equipped, layered assets fail to fit properly at the affected areas.</figcaption>
</figure>
### Oversized outer cage
Ensure that the gap between the layered accessory and the outer cage is not too large. This can cause severe deformation issues when combined with other layered assets.
<img src="../../assets/accessories/caging-best-practices/6-Oversized-Cage.png" width="50%" alt=""/>
### Collapsed cage vertices
When cage vertices are collapsed into one vertex or a small region, any additional layer placed on top of your clothing item will have weird artifacts near the collapsed region.
<figure>
<img src="../../assets/accessories/caging-best-practices/9-Stacking-Vertices.png" width="100%" alt=""/>
<figcaption>Most 3D applications can indicate if vertices are directly overlapping</figcaption>
</figure>
This setup will be rejected during validation.
### Cages with missing limbs
<img src="../../assets/accessories/caging-best-practices/13-Cage-Missing-Parts.png" width="60%" alt=""/>
The cage is meant to match the shape of the template body used to model your clothing item. Cages without heads or missing limbs won't work properly with the layered clothing system.
This setup will be rejected during validation.
### Outer cage inside the inner cage
Setting the outer cage inside the inner cage creates a clothing item that can't properly layer with other assets.
<img src="../../assets/accessories/caging-best-practices/14-Outer-Inside-Inner.png" width="60%" alt=""/>
This setup will be rejected during validation.
### Mesh outside of outer cage
Layered assets placed outside their outer cages do not deform. If the item is completely outside then it will behave similar to a rigid accessory.
<figure>
<img src="../../assets/accessories/caging-best-practices/15-Orbitting-Accessory-B.png" width="80%" alt=""/>
<figcaption>Assets outside of the cage meshes are not supported.</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/caging-best-practices/15-Orbitting-Accessory-A.png" width="80%" alt=""/>
<figcaption>Even with a correct hierarchy, assets outside the cages will not deform.</figcaption>
</figure>
This setup will be rejected during validation. | 3,079 | b5161921b004374dc4e3f9df79b931a0d6c95c8bf27030522a2a0355e40f004d |
https://create.roblox.com/docs/art/accessories/accessory-fitting-tool | content/en-us/art/accessories/accessory-fitting-tool.md | guide | 2026-03-29T11:46:37.247220+00:00 | # Accessory Fitting Tool
The **Accessory Fitting Tool** (AFT) is a built-in Studio tool that allows you to test your custom models on multiple combinations of character bodies, animations, and accessories before generating the final `Class.Accessory` object. When testing your accessories, you can make minor fit and positional changes to ensure that you get the best result possible.
The AFT automatically handles the conversion of the custom `Class.Model` or `Class.MeshPart` based on the user menu selections, allowing you to create **layerable clothing accessories** or **rigid accessories**. After generating your accessory, the AFT creates the correct `Class.Accessory` object hierarchy with any updated fit edits, sets the appropriate `AccessoryType` property, and generates any required body attachment points.
<figure>
<img src="../../assets/accessories/accessory-fitting-tool/Layered-Example.png" />
<figcaption>Test and edit the cages of your layered clothing assets.</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/accessory-fitting-tool/Rigid-Example.png" />
<figcaption>Test and edit the orientation and placement of your rigid assets.</figcaption>
</figure>
If you are intending to sell your accessory on the Marketplace, make sure your accessory model design adheres to the [Marketplace Requirements](../../marketplace/marketplace-policy.md).
## Set up accessories
The first stage of the fitting workflow allows you to configure the type of accessory to correctly populate the correct fitting tools and generate the appropriate accessory object. When selecting the type of accessory, the following options are available:
- **Clothing**: Layerable accessories that use an inner and outer cage to stretch and wrap around a body and other clothing items.
- **Accessory**: Rigid accessories that attach to a specific attachment point of a character and remain static in that position and orientation.
Before using the tool, ensure that you have the `Class.MeshPart` or `Class.Model` you intend to create into an accessory selectable in your project. As a reference, you can test the AFT using a reference [clothing](../../assets/accessories/reference-files/Additional-FBX-assets.zip) or [rigid accessory](../../assets/accessories/reference-files/Bow-rigid.rbxm) custom model.
To setup your accessories:
1. Ensure that your custom asset is selectable in your project. See [3D Importer](../../art/modeling/3d-importer.md) for instructions on importing a custom model into your experience.
2. In the toolbar's **Avatar** tab, click **Accessory** to open the AFT.
3. Select the **Part** field and click on the `Class.MeshPart` or `Class.Model` in the viewport that you intend to preview. The text field populates with the name of the object selected.
<img src="../../assets/accessories/accessory-fitting-tool/MeshPart-Selected.png" />
4. Click **Next**. The Asset Type menu screen displays.
5. Select the correct Asset Type for your accessory. An additional dropdown displays for a specific `AssetType` selection.
<img src="../../assets/accessories/accessory-fitting-tool/Accessory-Setup-Menu.png" />
6. Use the dropdown to select the specific type of accessory to preview. This sets the correct `AssetType` and attachment points when creating the accessory.
<img src="../../assets/accessories/accessory-fitting-tool/Asset-Type-Dropdown.png" />
7. Select the expected scaling of an accessory. This only affects rigid accessories if the specific body part has a different `AvatarPartScaleType` `Class.StringValue` object. This does not affect clothing accessories.
1. **Classic**: Sets the scaling of the accessory to classic R15 proportions.
2. **Proportions Slender**: Sets the `AvatarPartScaleType` value to `ProportionsSlender`.
3. **Proportions Normal**: Sets the `AvatarPartScaleType` value to `ProportionsNormal`.
8. Click **Next** to continue. A preview panel and workspace tools display.
<img src="../../assets/accessories/accessory-fitting-tool/Preview-Display.png" />
## Test accessories
After you provide the initial accessory details, the tool displays a preview panel. With the preview panel, you can test how your accessory looks on different combinations of character bodies, clothing items, animations, or even custom assets in your experience.
At any point of the testing process, you can [initiate a playtest](../../studio/testing-modes.md#playtesting) to launch an instance of your experience where your avatar is replaced with the currently selected character body and accessories from the AFT.
If you notice any fitting issues with your accessory, you can use the [edit](#edit-accessory-fit) tools to make minor adjustments to your accessory.
### With different bodies
You can select different bodies to test the fit and wear of your accessories. The AFT supplies several default character models you can use to ensure your accessories fit as expected.
<figure>
<img src="../../assets/accessories/accessory-fitting-tool/Body-Example-1.png" />
<figcaption>Bazooka Bones character preview</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/accessory-fitting-tool/Body-Example-2.png" />
<figcaption>Goblin character preview</figcaption>
</figure>
To test your accessory with a different body:
1. In the tool's catalog, navigate to **Avatars** > **Default**.
2. Click one of the character model tiles. The preview loads with the selected character model.
1. If two character tiles are selected, click a selected tile to deselect it.
2. In the character preview, **click** and **drag** to rotate and **right-click** to pan to inspect your character.
### With different clothing
You can select different clothing accessories to test the fit and layering of your caged accessories. The AFT supplies several default character models you can use to ensure your accessories fit as expected.
<figure>
<img src="../../assets/accessories/accessory-fitting-tool/Clothing-Example-1.png" />
<figcaption>Goblin character preview with reference clothing</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/accessory-fitting-tool/Clothing-Example-2.png" />
<figcaption>Magma Fiend character preview with reference clothing</figcaption>
</figure>
To test your accessory with a different accessory:
1. In the tool's catalog, navigate to **Clothing** > **Default**.
2. Click one or more of the available catalog items. The character preview loads with the selected clothing accessory.
1. In the catalog, click an active tile to deselect the asset.
2. In the character preview, **drag** and **drop** the accessory boxes to change the layer order.
3. In the character preview, **click** and **drag** to rotate and **right-click** to pan to inspect your character.
### With animations
You can select different animations to test the movement of your accessory asset. The AFT supplies several default animation assets you can use to ensure your accessories fit as expected when a model is performing various movements.
<figure>
<img src="../../assets/accessories/accessory-fitting-tool/Animation-Example-1.png" />
<figcaption>Walking animation reference</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/accessory-fitting-tool/Animation-Example-2.png" />
<figcaption>Shy emote reference</figcaption>
</figure>
To test your accessory with different animations:
1. In the tool's catalog, navigate to **Animations** > **Default**.
2. Click one of the animation asset tiles.
1. In the catalog, press the play and pause icon to control the playback.
2. In the character preview, **click** and **drag** to rotate and **right-click** to pan to inspect your character.
### With custom assets
You can add custom character models, clothing accessories, and animations that are part of your workspace to the AFT preview catalog. Use this functionality to verify that your accessory works with any other custom models or accessories they may interact with in your experience.
To add custom assets:
1. Click the ⊕ icon next to the catalog search. A prompt appears, allowing you to choose a supported object.
<img src="../../assets/accessories/accessory-fitting-tool/Custom-Asset-Icon.png" />
2. Select any `Class.Accessory`, `Class.Model`, `Class.MeshPart`, `Class.Animation` or `Class.Folder` within the 3D viewport or **Explorer**. The asset displays in the corresponding **Custom** category.
1. If no selection is made, click the tool panel again to exit the prompt.
<img src="../../assets/accessories/accessory-fitting-tool/Custom-Asset.png" />
## Edit accessory fit
The AFT populates different fitting tools depending on the type of accessory being created.
### Layered clothing
When editing clothing items, the following tools populate in the viewport:
<table>
<thead>
<tr>
<th>Icon</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<th><img src="../../assets/accessories/accessory-fitting-tool/Cage-Editing-Icon.png"/></th>
<th>Toggles the [Cage Editing](#cage-editing) interface in the viewport for making minor inner or outer cage changes to your clothing. </th>
</tr>
<tr>
<td><img src="../../assets/accessories/accessory-fitting-tool/Autoskin-Icon.png"/></td>
<td>Toggles [auto-skinning](../../art/accessories/automatic-skinning-transfer.md#enabling-automatic-skinning-transfer) between `EnabledPreserved` and `EnabledOverride`. Depending on the asset and skinning quality, auto-skinning may provide better results.<br /><br />EnabledPreserved uses the asset's original skinning data applied in a modeling software. <br />`EnabledOverride` transfers skinning data from the avatar character instead of using the asset's original skinning data.<br /></td>
</tr>
<tr>
<td><img src="../../assets/accessories/accessory-fitting-tool/Expand-Button.png"/></td>
<td>Displays a button to **Bring Mannequin in View** which centers mannequin in front of the camera.</td>
</tr>
<tr>
<td><img src="../../assets/accessories/accessory-fitting-tool/Center-Mannequin.png" /></td>
<td>Centers the camera on the mannequin.</td>
</tr>
</tbody>
</table>
#### Cage editing
When the Cage Editing interface is enabled, additional tools display in the viewport. The viewport also displays the vertices of the selected cage over the mannequin, allowing you to make positional edits to the cage and change how a clothing item can fit on a body.
<img src="../../assets/accessories/accessory-fitting-tool/Cage-Editing-Example.png" />
You can use these Cage Editing tools for minor to moderate cage edits. If your asset requires major fit or sculpting changes, edit the cage meshes directly in a third-party modeling software, such as Blender or Maya, and import the updated model into Studio.
Use the following cage editing tools to help visualize and edit any cage vertices:
<table>
<thead>
<tr>
<th>Icon</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<th><img src="../../assets/accessories/accessory-fitting-tool/Cage-Editing-Icon.png"/></th>
<th>Toggles the selection for the inner and outer cage vertices. When selected, the vertices of that specific cage are available to edit. </th>
</tr>
<tr>
<td><img src="../../assets/accessories/accessory-fitting-tool/Autoskin-Icon.png"/></td>
<td>**Falloff Distance** sets the radius of influence when editing vertices of the cage mesh. When editing a cage vertex, nearby vertices follow the changes for efficient cage editing. <br /> <br />A higher Falloff Distance applies influence to vertices further away from the origin.</td>
</tr>
<tr>
<td><img src="../../assets/accessories/accessory-fitting-tool/Expand-Button.png"/></td>
<td>Displays additional buttons: <ul><li>Bring Mannequin in View - centers camera on the mannequin. </li><li>Reset Inner/Outer Cage - resets any changes made to the selected cage.</li></ul></td>
</tr>
<tr>
<td><img src="../../assets/accessories/accessory-fitting-tool/Center-Mannequin.png" /></td>
<td>Use the slider to set the opacity of the mesh or the cage vertices. Setting the opacity allows you to better see and access certain vertices and angles of your clothing item.</td>
</tr>
</tbody>
</table>
To make changes to the vertices of the currently selected cage:
1. In the Studio toolbar, disable **Move** snapping. This enables you to make detailed changes to a vertex's position.
2. Select a vertex and use the **Move** tool to reposition. Changes to the cage apply immediately and display in the preview panel.
1. Use the opacity sliders to better visualize the changes to your cage.
2. Set the **Falloff Distance** depending on the number of vertices being adjusted at once.
<img src="../../assets/accessories/accessory-fitting-tool/Edit-Vertex-Example.png" />
### Rigid accessories
When fitting rigid accessories, a bounding box appears around the mannequin indicating the possible placement of that specific type of accessory. You can **position**, **rotate**, and **scale** objects within this bounding box to ensure your accessory fits on different character models.
<figure>
<img src="../../assets/accessories/accessory-fitting-tool/Bounding-Box-Example-1.png" />
<figcaption>Adjust your rigid accessory fit within the bounding box.</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/accessory-fitting-tool/Bounding-Box-Example-2.png" />
<figcaption>If the accessory is outside the appropriate space, the bounding box turns red.</figcaption>
</figure>
### Create accessory
You can create the accessory at any time. The tool applies any fit changes and generates the appropriate Accessory instance in the workspace depending on the type of accessory selected and any configurations applied.
When you are ready to generate your accessory, select **Generate MeshPart Accessory**.
<figure>
<img src="../../assets/accessories/accessory-fitting-tool/LC-Hierarchy.png" />
<figcaption>Hierarchy generated for layered clothing.</figcaption>
</figure>
<figure>
<img src="../../assets/accessories/accessory-fitting-tool/Rigid-Hierarchy.png" />
<figcaption>Hierarchy generated for rigid accessories.</figcaption>
</figure>
With an accessory successfully created, you can now try the following:
- Equip the accessory on an avatar-ready character by drag and dropping the accessory on an existing model, or using [HumanoidDescription](../../characters/appearance.md#manually-modify-appearance).
- Save the accessory as an [avatar asset](../../projects/assets/index.md#for-avatars) for use in an experience later.
- If you meet certain account requirements, you can [upload your asset](../../marketplace/publish-to-marketplace.md) for moderation and start selling it on the Marketplace. | 3,310 | ec423edb220dbdc26f6e330c102968a00a24e0a311169e7c9d87a530b6d2ed0c |
https://create.roblox.com/docs/art/accessories/creating-rigid/exporting | content/en-us/art/accessories/creating-rigid/exporting.md | guide | 2026-03-29T11:46:37.493911+00:00 | # Exporting
<video controls src="../../../assets/art/accessories/creating-rigid/Exporting.mp4" width="100%"></video>
After modeling and texturing your asset, you can begin the process of **exporting** your Blender project as a `.fbx` or `.gltf`. For up-to-date settings, see [Export settings](../../modeling/export-requirements.md).
If you are creating your own accessory object, it's important to clean up your project, which can involve deleting or removing any extra objects, such as lights, cameras, or mannequins, to ensure you only export the accessory mesh, and applying any modifiers to your mesh object.
To export your model as a `.fbx`:
1. In the topbar, click **File**.
2. Select **Export**, then **FBX (.fbx)**.
3. On the right-hand side of the file view window, change the **Path Mode** property to **Copy**, then toggle the **Embed Textures** button.
<img src="../../../assets/modeling/skinned-meshes/Blender-Export-Settings-1.png" width="320" />
4. Set the **Transform** > **Scale** to `.01`. This is required to maintain scale size for `.fbx` exports.
<img src="../../../assets/modeling/skinned-meshes/Blender-Export-Settings-2.png" width="320" />
5. Click the **Export FBX** button.
You've completed the exporting section of this tutorial. If desired, download a [reference sample](../../../assets/art/accessories/creating-rigid/Rigid_Mask_Export.fbx) of this exported file for comparison. You can use this reference in the next importing step. | 367 | 65205bb6ab841002d78a509f1841a751ad063592f65dcf3677cf18ce73a8f75a |
https://create.roblox.com/docs/art/accessories/creating-rigid/modeling-setup | content/en-us/art/accessories/creating-rigid/modeling-setup.md | guide | 2026-03-29T11:46:37.506385+00:00 | # Modeling Setup
<img src="../../../assets/art/accessories/creating-rigid/Modeling-Complete.png" alt="A screenshot of blender showing the final 3d shape of a treasure chest in the viewport"/>
**Modeling** is the process of creating and shaping the 3D geometry of an object. **Box modeling** is a fundamental technique in 3D modeling combining basic shapes and steps to create a more complex object.
The following instructions are based off of the [Box Modeling 101 staff article](https://devforum.roblox.com/t/modeling-101-in-blender-box-modeling/2963814). The original article includes additional information, as well as Blender setup instructions, best practices, and advanced modeling examples that are not included in this accessory tutorial.
Whether you are using an existing shape or creating your own 3D object, it's important to consider [technical requirements](../../../art/accessories/specifications.md), such as keeping your geometry within a polycount budget, and [policy requirements](../../../marketplace/marketplace-policy.md), such as ensuring your design does not infringe on other creator's IP both within and outside of the Roblox ecosystem.
## General shape
<video controls src="../../../assets/art/accessories/creating-rigid/General-Shape.mp4" width="100%"></video>
In a new Blender file, delete everything except the starter cube, then create the basic shape of the treasure chest.
1. In a new project, select the non-cube objects and press <kbd>X</kbd> to delete.
2. Select the cube and press <kbd>S</kbd> for scale.
1. Press <kbd>Y</kbd> to lock scaling to the y-axis.
2. Drag with the mouse to create a rectangle.
3. Switch to Edit mode (<kbd>Tab</kbd>).
4. Near the Edit mode dropdown, select the Face selection.
5. Select the top face of the box and press <kbd>E</kbd> to extrude.
6. Drag your mouse to extrude the lid. Extend the lid to about half the height of the main body.
## Rounded lid
<video controls src="../../../assets/art/accessories/creating-rigid/Rounded-Lid.mp4" width="100%"></video>
Create the rounded lid shape using segmentation:
1. Near the Edit mode dropdown, select the Line selection.
2. Holding <kbd>Shift</kbd>, click the top front and back lines of your chest.
3. With both lines selected, press <kbd>Ctrl</kbd><kbd>B</kbd>/<kbd>⌘</kbd><kbd>B</kbd> to bevel.
4. In the context menu at the bottom right, set the number of segments to `6` and enable **Clamp Overlap**.
### Merge vertices
Sometimes tools like the **Bevel** tool may move vertices very close to each other without merging them. Use the Merge Vertices function to ensure that your object shares vertices wherever possible.
1. Near the Edit mode dropdown, select the Vertices selection.
2. Press <kbd>A</kbd> to select all vertices.
3. Right-click and select **Merge Vertices by Distance**.
4. In the pop-up modal, set the distance to `.01`.
## Side insets
<video controls src="../../../assets/art/accessories/creating-rigid/Side-Insets.mp4" width="100%"></video>
Create the left and right insets of your chest:
1. Near the Edit mode dropdown, select the Face selection.
2. Hold <kbd>Shift</kbd> and click both sides of your shape. This selects both the left and right faces.
3. Press <kbd>I</kbd> for inset. Drag the mouse to adjust the amount of inset for the new face.
1. Set the inset about the size of your bevel segmentations.
4. With your new insets selected, right-click and select **Extrude Along Normals**.
5. Use the mouse to drag and adjust the distance of extrusion into the chest.
## Front insets
Create the front and back insets of your chest by creating new lines and then extruding your faces between those lines.
### Vertical loop cuts
<video controls src="../../../assets/art/accessories/creating-rigid/Vertical-Loop-Cuts.mp4" width="100%"></video>
To create your vertical loop cuts:
1. Near the Edit mode dropdown, select the Line selection.
2. Press <kbd>A</kbd> to select the entire chest.
3. Use <kbd>Ctrl</kbd><kbd>R</kbd>/<kbd>⌘</kbd><kbd>R</kbd> to create a loop cut.
4. Using your mouse, hover over the object until the highlighted cut is vertical. Click to confirm.
5. In the context menu, set the number of cuts to `2`.
6. With the new lines selected, press <kbd>S</kbd> to scale and <kbd>Y</kbd> to scale within the y-axis.
7. Use the mouse to drag the lines until they nearly reach the edges of your chest. Click to confirm.
### Horizontal loop cuts
<video controls src="../../../assets/art/accessories/creating-rigid/Horizontal-Loop-Cuts.mp4" width="100%"></video>
To create your horizontal loop cuts:
1. Select the chest, and press <kbd>Ctrl</kbd><kbd>R</kbd>/<kbd>⌘</kbd><kbd>R</kbd> to loop cut.
2. Using the mouse, click to confirm a horizontal cut.
3. Using the context menu, set the number of cuts to `2`.
4. To straighten each line across your object, select the one of your new lines:
1. Press <kbd>S</kbd> for scale.
2. Press <kbd>Z</kbd> to scale within the z-axis.
3. Press <kbd>0</kbd> to set the scale value to `0` across the z-axis.
5. Repeat step 4 with the other line.
6. Position the top line near the top below the segmentations.
7. Position the bottom line near the bottom.
1. Enable **Magnet Snapping** so the bottom line merges with the existing vertices and lines from the side insets.
### Extrusions
Create the extrusions for the front, top, and back of the chest.
1. Near the Edit mode dropdown, select the Face selection.
2. Hold <kbd>Alt</kbd>/<kbd>⌥</kbd> and click on your front faces to select the front, top, and back faces.
3. With the faces selected, hold <kbd>Shift</kbd> and click on the metal borders to deselect them. The front and back faces, and the top segmentations, should remain selected.
4. Right click and select **Extrude Faces Along Normals**. Drag the mouse to extrude the faces about the same width as the metal borders.
## Complete border
<video controls src="../../../assets/art/accessories/creating-rigid/Complete-Border.mp4" width="100%"></video>
The chest is almost ready, but is still missing the continuous metal border across the top edge. Remove the existing faces and add new geometry to the treasure chest.
### Delete faces
Delete the faces of the top side metal borders:
1. Near the Edit mode dropdown, select the Face selection.
2. Starting on any side, shift click the three faces of the top metal border.
3. Press <kbd>X</kbd> to delete.
4. Repeat steps 2-3 on the other side.
### Add faces
Add new faces to the sides that complete the geometry of the treasure chest box.
1. Near the Edit mode dropdown, select the Line selection.
2. Starting with any side, Hold <kbd>Shift</kbd> and click the two top corner edges of the missing face.
3. Right click and select **New Face from Edges** to create a top face.
4. Repeat steps 2-3 with the bottom corner edges to create a bottom face.
5. On the other side of the chest, repeat steps 2-4 to complete the metal border.
You've completed the modeling section of this tutorial. If desired, download a [reference version](../../../assets/art/accessories/creating-rigid/Chest-Modeling-Complete.blend) of this stage of the project for comparison.
This tutorial represents an extremely basic overview of the 3D modeling process. Tools like Blender offer many features, workflows, and techniques to create unique and complex models. Check out Blender's official and community tutorials for additional instructional content. | 1,795 | 8fd220278cb1930487c4f974519b6c279d002e1ac7ae31d90c7e8d32e5594c6a |
https://create.roblox.com/docs/art/accessories/creating-rigid | content/en-us/art/accessories/creating-rigid/index.md | guide | 2026-03-29T11:46:37.539324+00:00 | # Creating Rigid
<iframe width="800" height="450" src="https://www.youtube-nocookie.com/embed/Eed29gV0hLA" title="YouTube video player" frameborder="0" allow="accelerometer; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>
<br /><br />
Rigid accessories are 3D objects that users can equip to their avatar characters in an experience or through Roblox's [Marketplace](https://www.roblox.com/catalog) and [Avatar Editor](https://www.roblox.com/my/avatar).
Unlike clothing or bodies, rigid accessories do not require additional configuration in a third-party application beyond modeling and texturing, rigid accessories are typically the most basic type of 3D avatar item to create.
This tutorial covers the basics of each step in the workflow to create your own simple 3D model in Blender and import it into Studio. From there, you can upload the accessory to the Marketplace to sell, save the asset to your toolbox, or use the asset in your experiences.
Creating, building, and sharing on Roblox is free. However, the last step of listing your item to sell requires a Premium Roblox account, an upload fee, and a publishing advance. For more information, see the [Marketplace policy](../../../marketplace/marketplace-policy.md#creator-requirements).
<figure>
<img src="../../../assets/art/accessories/creating-rigid/Chest-Blender.png" />
<figcaption>
3D mesh object created in Blender
</figcaption>
</figure>
<figure>
<img src="../../../assets/art/accessories/creating-rigid/Chest-Studio.png" />
<figcaption>
Mesh object equipped as an `Class.Accessory` in Studio
</figcaption>
</figure>
While this content covers the Blender workflow with a provided reference example, you can apply the same concepts to other third-party modeling applications and custom assets. | 403 | 6c0c59d2df1beb6871d81f648c97c2c519b7df6c90679e9c0bc769948320ad86 |
https://create.roblox.com/docs/art/accessories/creating-rigid/texturing | content/en-us/art/accessories/creating-rigid/texturing.md | guide | 2026-03-29T11:46:37.618397+00:00 | # Texturing
<img src="../../../assets/art/accessories/creating-rigid/Texturing-Complete.png" alt="A screenshot of blender showing the final 3d shape and color of a treasure chest in the viewport"/>
**Texturing** is the process of applying a surface appearance to a 3D object. **Texture painting** is a technique that allows you to digitally brush your surface colors onto your 3D object, or onto the 2D image that represents the surface of your object.
This tutorial covers basic texture painting in Blender. Common workflows in the industry utilize additional third-party tools to create textures, especially high-definition PBR textures that mimic realistic lighting and texture properties.
While PBR textures are not required for accessories and is not covered in this tutorial, adding PBR textures can add extra visual flair and realism to elevate your creations. This typically requires additional software. <br /> <br /> For more information, see [PBR textures](../../modeling/surface-appearance.md).
## UV projecting
<video controls src="../../../assets/art/accessories/creating-rigid/UV-Projecting.mp4" width="100%"></video>
Use Blender's automatic UV Project feature to "unwrap" your 3D object onto a 2D plane. This allows you to associate a 2D image to the 3D surface of your object.
1. In Edit mode, press <kbd>A</kbd> to select your object.
2. In the top UV menu, select **Smart UV Project**.
3. Set Island Margin to `.02`.
## Add new material
<video controls src="../../../assets/art/accessories/creating-rigid/Adding-New-Material.mp4" width="100%"></video>
Add a new material for Blender to associate this new texture, and assign it to a new blank 2D image.
1. In the bottom right panel, select the red **Materials** tab.
2. Select the **+ New** button. Additional material options display below.
3. In **Base Color**, select the dot. A dropdown appears.
1. Select **Image Texture**.
4. Under Base Color, select the **+ New** button.
1. Name the texture image file. Using an affix like "\_TXT" can help organize your files later.
2. Select the color and pick a color. This tutorial recommends using a metallic color for your metal borders to save time.
## Texture painting
Texture painting allows you to paint directly on the 3D object or the 2D mapping of the surface.
Since Blender automatically mapped the 2D atlas of the texture, it's not easy to tell what parts of the 2D image maps to the 3D object. First mark the sections of the 3D object you want to paint solid before completing your texture by painting the 2D map.
There are many ways to texture within Blender. To keep this process simple, the tutorial used Blender's [Smart UV Project](https://docs.blender.org/manual/en/2.79/editors/uv_image/uv/editing/unwrapping/mapping_types.html), but there are many ways to manually create your 2D texture islands and organize your mesh and texture.
### Mark 3D object
<video controls src="../../../assets/art/accessories/creating-rigid/Marking-3d-Object.mp4" width="100%"></video>
Switch to Texture Paint mode and use the paintbrush to track the "wood" parts of the treasure chest.
1. In Edit mode, select your object.
2. Switch to **Texture Paint** mode. A side-by-side panel displays with your 2D atlas on the left and the 3D object on the right.
3. Expand the Tool submenu in the top-right of either window.
4. Select your brush settings and mark the wooden areas of your chest.
1. Use <kbd>Ctrl</kbd><kbd>Z</kbd>/<kbd>⌘</kbd><kbd>Z</kbd> to undo any accidental brushes on the metal border.
2. Hold <kbd>F</kbd> and drag the mouse to adjust brush size.
### Paint 2D map
<video controls src="../../../assets/art/accessories/creating-rigid/Painting-2d-Map.mp4" width="100%"></video>
With all of the wooden areas of your chest marked, you can now quickly texture your 2D atlas. First adjust your brush settings to have a hard edge and then begin painting the 2D image.
1. On the left window, access to **Tool** menu in the top right of the window.
1. Set the **Falloff** shape to the flattest icon to ensure the edges are sharp.
2. Set the color or any other brush settings here.
2. In the left window, begin coloring in each island of your texture. You can quickly preview the changes on your 3D object on the right side.
1. Use <kbd>Ctrl</kbd><kbd>Z</kbd>/<kbd>⌘</kbd><kbd>Z</kbd> to undo any accidental brushes on the metal border.
2. Hold <kbd>F</kbd> and drag the mouse to adjust brush size.
3. After completion, navigate to **Image** > **Save** to save your image file.
You've completed the texturing section of this tutorial. If desired, download a [reference version](../../../assets/art/accessories/creating-rigid/Chest-Texturing-Complete.blend) of this stage of the project for comparison. | 1,158 | e2aaa02c4cf42be97f07df21f23259667bf504d7247c3639071171e7f1af75a4 |
https://create.roblox.com/docs/art/accessories/creating-rigid/converting | content/en-us/art/accessories/creating-rigid/converting.md | guide | 2026-03-29T11:46:37.705194+00:00 | # Converting
After importing your asset into Studio, you can begin **fitting** your imported object to a mannequin and **converting** the `Class.Model` object into a `Class.Accessory`. When fitting and converting your accessory it's important to use the [Accessory Fitting Tool](../../../art/accessories/accessory-fitting-tool.md) (AFT) to correctly preview the placement and apply the correct configurations to your accessory.
<video controls src="../../../assets/art/accessories/creating-rigid/Converting.mp4" width="100%"></video>
To fit and generate your accessory:
1. In the toolbar's **Avatar** tab, click **Accessory** to open the AFT.
2. In the new AFT panel, select the **Part** field and, in the workspace, select the accessory `Class.MeshPart` object in the workspace and press **Next**.
3. Set **type** of asset to **Back**. Press **Next** when complete.
4. Using both the AFT preview window and the workspace, adjust the position, scale, and rotation of the accessory.
1. Use the AFT preview window and your mannequin as an accurate preview of how your asset fits on the character. The clothing mannequin in the workspace does not accurately portray how rigid accessories attach.
2. In the workspace, use the **Move**, **Scale**, and **Rotate** tools to adjust the positioning of your rigid accessory.
3. If you accidentally select something else, click back into the AFT panel to reselect the accessory and resume your adjustments using the transformation tools.
5. After previewing and fitting your asset, select the **dropdown** next to **Generate** button to select **Generate Legacy Accessory**. The accessory object populates in your viewport and in the **Explorer**.
- For rigid accessories that you intend to sell on the Marketplace you must use the [generate legacy accessory](../accessory-fitting-tool.md#generate-legacy-accessory) option when creating your Marketplace accessories.
<img src="../../../assets/accessories/accessory-fitting-tool/Generate-Legacy-Accessory.png" width ="60%" alt="A dropdown appears above the GenerateMeshPartAccessory when expanded, displaying a Generate Legacy Accessory option."/>
6. Test your accessory by equipping it to a character and using the **Avatar Setup** tool.
<video controls src="../../../assets/art/accessories/creating-rigid/Testing.mp4" width="100%"></video>
After successful fitting and converting, your 3D model should populate in your project as a `Class.Accessory`. With this `Class.Accessory` you can perform any of the following:
- [Upload the accessory](../../../art/accessories/creating-rigid/publishing.md) to the Marketplace.
- Use the accessory in your current experience by equipping it to character models with [HumanoidDescription](../../../characters/appearance.md#manually-modify-appearance), or by dragging and dropping the accessory under the appropriate character `Class.Model` object.
- Save the accessory to your [Toolbox](../../../projects/assets/toolbox.md) to share or use within any of your experiences. | 659 | 53add20d2326501d957e1ab1a44676b3b4752e23aa471e4bd6d005a98b9b2c3e |
https://create.roblox.com/docs/art/accessories/automatic-skinning-transfer | content/en-us/art/accessories/automatic-skinning-transfer.md | guide | 2026-03-29T11:46:37.731269+00:00 | # Automatic Skinning Transfer
**Automatic Skinning Transfer** allows layered clothing and facial accessories to deform accurately along with the character model it's attached to without having to skin the accessory itself. Instead of the complex task of manually [rigging and skinning](../../art/modeling/rigging.md) models in 3D modeling software, you can use this feature to transfer or generate skinning data to the accessory. When using Automatic Skinning Transfer, the Roblox Engine creates and applies skinning at runtime.
**No skinning of accessory geometry is required to use Automatic Skinning Transfer**. In fact, auto-skinned accessories work well with most characters they're attached to, even if those characters have a different number of joints, bones, or use a different kind of skinning, and the accessories move accurately with characters as they animate.
<img src="../../assets/avatar/dynamic-heads/creating-face-accessories/Automatic-Skinning-Transfer-Intro.jpg" width="70%" />
Skinning is still an important concept for character creation, and if you're creating custom characters, you may want to apply skinning data to the model to create a character with more natural looking poses and animations. For information on how to skin a mesh, see [Skin a humanoid model](../../art/modeling/skin-a-humanoid-model.md).
Because the skinning transfer process uses a character's outer cage to help calculate skinning data to apply onto the accessory, it's important that all [layered clothing requirements](../../art/accessories/project-files.md) are still met when creating accessories.
## Enable Automatic Skinning Transfer
To enable the Automatic skinning transfer process, you must enable the `Class.WrapLayer.AutoSkin|AutoSkin` property within the `Class.WrapLayer` instance of the layered `Class.Accessory` you want to automatically skin, then set it to one of the following values:
- `Disabled`: Disables the Automatic Skinning Transfer process. This is the default value.
- `EnabledOverride`: Enables the Automatic Skinning Transfer process, and allows it to override any existing skinning information found on the accessory at runtime.
- `EnabledPreserve`: Enables the Automatic Skinning Transfer process, but doesn't allow it to override any existing skinning information found on the accessory at runtime. If there isn't any skinning to maintain, the Automatic Skinning Transfer process automatically creates new skinning data.
When there isn't any skinning data on the accessory, or if you choose to override any existing skinning data associated with the accessory, the Roblox Engine calculates skinning data from the character's geometry and cages, then the new skinning data and rig associated with the accessory drives the accessory's deformations and motions in sync with the source geometry itself.
## Best practices
While Automatic Skinning Transfer often works better than manual skinning, there are some best practices to reduce unexpected behavior with the accessory skinning. Like all modeling processes, constantly test your layered clothing and facial accessories on different avatar types to achieve the results you want.
### Special skinning transfer joints
Automatic skinning transfer may not work well for certain detailed accessory types, like eyelashes or eyebrows. To get a more controlled skinning transfer result, you have the option to skin accessory geometry to one of two specially named joints: `RBX_Leader` and `RBX_Follower`.
It's best to create these joints/bones directly beneath the Root joint in your hierarchy for simplicity and clarity. These joints/bones won't be detected as a part of your character model's R15 rig on import.
Any vertices skinned to `RBX_Leader` will undergo the same transfer process that exists today. However, any vertices skinned to `RBX_Follower` will actually transfer based on their nearest leader vertex. This allows for better results in situations like an eyelash where the tip of an eyelash strand would normally transfer to somewhere on the brow area, rather than follow the base of the eyelash strand when moving.
For eyelashes, good candidates for RBX_Leader are the ones that are intended to sit right on the eyelid of the character. The remaining vertices can be skinned to RBX_Follower.
<figure>
<img alt="Screenshot of vertices assigned as leader." src="../../assets/avatar/dynamic-heads/creating-face-accessories/Vertices-Group-Leader.png" />
<figcaption>Vertices of an eyelash assigned to a RBX_Leader bone vertex group.</figcaption>
</figure>
<figure>
<img alt="Screenshot of vertices assigned as follower." src="../../assets/avatar/dynamic-heads/creating-face-accessories/Vertices-Group-Follower.png" />
<figcaption>Vertices of an eyelash assigned to a RBX_Follower bone vertex group.</figcaption>
</figure>
For eyebrows, good candidates for RBX_Leader are vertices along the edges that span the browline.
<figure>
<img alt="Screenshot of vertices assigned as leader." src="../../assets/avatar/dynamic-heads/creating-face-accessories/Eyebrows-Follower-Vertices.png" />
<figcaption>Vertices of an eyebrow assigned to a RBX_Leader bone vertex group.</figcaption>
</figure>
<figure>
<img alt="Screenshot of vertices assigned as follower." src="../../assets/avatar/dynamic-heads/creating-face-accessories/Eyebrows-Leader-Vertices.png" />
<figcaption>Vertices of an eyebrow assigned to a RBX_Follower bone vertex group.</figcaption>
</figure>
In Blender, user the **Object Data Properties** > **Vertex Groups** to manage and view your vertex group assignments.
<img alt="Screenshot of properties panel with vertex group assignments" src="../../assets/avatar/dynamic-heads/creating-face-accessories/Vertices-Group-Assign.png" />
In Blender, vertex groups automatically created after you make a bone object. This allows you to quickly set vertices to a specific bone vertex group.
<figure>
<video src="../../assets/avatar/dynamic-heads/creating-face-accessories/Vertices-Transfer-Off.mov" controls width="100%"></video>
<figcaption>Eyelashes without transfer joints. Notice how the upper eyelashes near the bridge of the nose doesn't follow the eyelids as expected.</figcaption>
</figure>
<figure>
<video src="../../assets/avatar/dynamic-heads/creating-face-accessories/Vertices-Transfer-On.mov" controls width="100%"></video>
<figcaption>Eyelashes with transfer joints. All eyelashes follow the leading vertices closest to the eyes.</figcaption>
</figure>
No additional work is needed in Studio to support this method. If your accessory is set to `Class.WrapLayer.AutoSkin.EnabledOverride` and these joints exist with vertices assigned to them, then this skinning transfer variation will be in effect.
If you wish to upload an accessory using these joints as a UGC item, there are a few rules to be aware of:
- Vertices cannot be partially weighted to these joints. If you want to use them you must skin the vertex to the joint with a weight of `1.0`.
- If these joints are present in the mesh, then the accessory must be set to `WrapLayerAutoSkin.EnabledOverride`.
- Body part meshes containing these joints will be rejected by validation.
- Eyebrow and Eyelash accessory types are required to have the special skinning joints and be set to `WrapLayerAutoSkin.EnabledOverride`.
### Modify character cages
You can't upload assets with a partial cage to the Marketplace. You may use partial cages for assets intended for in-experience use, but the Marketplace validation process will reject assets with partial cages.
You can modify character cages for the accessories to deform accurately to the expected character surfaces using the Automatic Skinning Transfer. For example, auto-skinning may cause layered clothing to deform based on an incorrect body part because the transfer process is based on the closest distance between the accessory and its inner cage. In the following instance, a beard accessory was modeled using a blocky-type full-body cage. This causes the beard to deform incorrectly because parts of the beard are closer to the character cage's upper chest instead of the chin:
<img src="../../assets/avatar/dynamic-heads/creating-face-accessories/Full-Body-Cage.png" width="60%" />
<video controls width="60%" src="../../assets/avatar/dynamic-heads/creating-face-accessories/videos/AutoSkin-With-Full-Cage.mp4">
</video>
To prevent a layered accessory from using skinning data from an undesired area of the character's geometry, you can model your asset on a different character mannequin cage. For example, a blocky-type character will struggle with a beard skinning to the torso, but a character with an actual neck, like a humanoid, won't have this problem.
Alternatively, you can remove parts of the outer cage that the layered accessory shouldn't be skinned to. **This is not a valid workflow for assets intended for the Marketplace**, but you can use this for in-experience assets or assets for other use. For example, the following image shows how the outer cage was modified so that it only includes the head geometry. With this improvement to the outer cage, when you automatically transfer skinning data, the beard and partial cage now correctly transfer skinning only from the head geometry.
<img src="../../assets/avatar/dynamic-heads/creating-face-accessories/Head-Cage-Only.png" width="60%" />
<video controls width="60%" src="../../assets/avatar/dynamic-heads/creating-face-accessories/videos/AutoSkin-With-Specific-Cage.mp4">
</video>
It's important to note that you could also solve the previous example's deformation issue by using a different cage altogether. For example, if you use a more humanoid cage with more space between the chest and the chin, the beard is closest to the head instead of being near the chest or neck area, so the Automatic Skinning Transfer wouldn't transfer skinning data from those regions.
<img src="../../assets/avatar/dynamic-heads/creating-face-accessories/Beard-Humanoid-Cage.jpg" width="60%" />
By modifying different regions of the character's cage, you can ensure that your layered clothing and facial accessories deform in relation to the correct region of the body or head, such as modifying the character model's arms so dresses don't incorrectly attach to them while a character is running, or modifying pants that incorrectly map to feet. The following video demonstrates how a jacket's collar incorrectly moves with the head, as the layered clothing is deforming in the collar region, which is closest to the head portion of the cage. To resolve this, you can remove the head portion of the cage so that the jacket won't incorrectly deform in relation to the head at all. Instead, it will deform in relation to the shoulder region, which is much more appropriate for this article of clothing.
<video controls width="60%" src="../../assets/avatar/dynamic-heads/creating-face-accessories/videos/Jacket-Collar-Issue.mp4">
</video>
<img src="../../assets/avatar/dynamic-heads/creating-face-accessories/Jacket-Cage-Comparison.jpg" width="60%" />
During the asset creation process, it's important to verify what skinning solution works best for your design by testing your individual assets on multiple models and animations. You can always skin your assets manually and choose to use the Automatic Skinning Transfer later.
### Different accessory categories
Automatic skinning transfer may not work well for certain accessory categories, such as hat, and glasses-type accessories. For example, hat or glasses accessories might introduce deformation in areas that should typically be rigid. In general, those accessories should remain rigid, and you shouldn't associate any skinning data with them.
For a summary of suggested `Class.WrapLayer.AutoSkin` parameters for different accessory categories, see the following table:
<table>
<thead>
<tr>
<th>Accessory Category</th>
<th>Suggested Parameter</th>
</tr>
</thead>
<tbody>
<tr>
<td>Beard</td>
<td>`EnabledOverride`</td>
</tr>
<tr>
<td>Eyebrow</td>
<td>`EnabledOverride`</td>
</tr>
<tr>
<td>Eyelash</td>
<td>`EnabledOverride`</td>
</tr>
<tr>
<td>Hair</td>
<td>`Disabled`</td>
</tr>
<tr>
<td>Hat</td>
<td>`Disabled`</td>
</tr>
<tr>
<td>Glasses</td>
<td>`Disabled`</td>
</tr>
<tr>
<td>Shirt</td>
<td>`EnabledOverride` or `EnabledPreserve`</td>
</tr>
<tr>
<td>Pants</td>
<td>`EnabledOverride` or `EnabledPreserve`</td>
</tr>
<tr>
<td>Shoes</td>
<td>`EnabledOverride` or `EnabledPreserve`</td>
</tr>
</tbody>
</table> | 2,729 | 9658bd5cf60b3df2920df12ddffaab82b3e35b1f025a80bad59b3216e3e7d692 |
https://create.roblox.com/docs/art/accessories/creating/armature-setup | content/en-us/art/accessories/creating/armature-setup.md | guide | 2026-03-29T11:46:37.855147+00:00 | # Armature Setup
**Rigging** is the process that enables the clothing object to move and deform with a Roblox character's R15 rig. In this tutorial, you'll parent the clothing item to Roblox's provided R15 armature and verify the Automatic Skinning Transfer data. After rigging, be sure to test out some basic poses to ensure that your clothes move and stretch correctly with any character body.
<figure>
<img src="../../../assets/art/accessories/creating/Texturing-Complete.png" />
<figcaption>Clothing mesh with no rigging data</figcaption>
</figure>
<figure>
<img src="../../../assets/art/accessories/creating/Rigging-Pose-Tests.png" />
<figcaption>Clothing mesh with rigging data performing pose tests</figcaption>
</figure>
The rigging process requires the following:
1. Download and append an R15 armature to your project.
2. Parent the rig with Blender's automatic weights.
3. Test poses.
## Transfer armature
Roblox provides an R15 base armature that you can import into your own project. While it is possible to create your own R15 armature rig, importing a premade rig saves you time and reduces the potential for error.
To import the R15 character armature into your file:
1. Download Roblox's [Rig_and_Attachments_Template.blend](../../../assets/modeling/meshes/reference-files/Rig_and_Attachments_Templates.zip). Do not open this project.
2. In your current clothing project, return to **Object Mode**.
3. Navigate to **File** > **Append**, and select the saved **Rig_And_Attachment.blend** file. An additional folder structure appears.
<img src="../../../assets/art/accessories/creating/Rigging-Append-Browser.png" />
4. Select **Armature** > **Armature** and press **Append**. An armature object is added to your workspace.
<img src="../../../assets/art/accessories/creating/Rigging-Armature-Appended.png" />
5. The armature may need reorientation with the following steps:
1. With the armature selected, open the **Item tool** sidebar.
2. Adjust the rotation so the armature is correctly aligned with your mesh.
3. After alignment, navigate to **Object** > **Apply** > **All Transforms** to freeze your new rotation values.
<img src="../../../assets/art/accessories/creating/Rigging-Freeze-Transforms.png" />
<video controls src="../../../assets/art/accessories/creating/Rigging_01.mp4" width="100%"></video>
## Parent armature
With the armature rig in place, you can use Blender's **Parent with Automatic Weights** functionality to quickly set your clothing mesh as a child of the armature. This feature also applies vertex weighting, or **skinning**, automatically to your mesh, which can save you significant time over skinning your clothing manually.
To parent the clothing to the rig:
1. Select the clothing mesh object.
2. Hold shift and click the **Armature** object. Ensure that the armature object is the last object selected.
3. Right-click and select **Parent** > **With Automatic Weights**.
<img src="../../../assets/art/accessories/creating/Rigging-Auto-Weights.png" />
<video controls src="../../../assets/art/accessories/creating/Rigging_02.mp4" width="100%"></video> | 737 | a31ea9a07330d6501bfc443cd8feadcc80acb3b550b8fc9360e6cdca44a84c72 |
https://create.roblox.com/docs/art/accessories/creating/converting | content/en-us/art/accessories/creating/converting.md | guide | 2026-03-29T11:46:37.916980+00:00 | # Converting
With the `Class.Model` in your project, the last step in the process of clothing creation requires you to convert this object to a standard `Class.Accessory` that avatars can equip. Using the [Accessory Fitting Tool](../../../art/accessories/accessory-fitting-tool.md) (AFT), convert the model object to a `Class.Accessory` that you can then use in your experience or publish to the Marketplace.
To generate the accessory object:
1. In the toolbar's **Avatar** tab, click **Accessory** to open the AFT.
2. Select the `Class.Model` of the clothing item in the viewport. The tool's text field populates with the name of the object selected. Alternatively, you can select the object within the **Explorer** window.
3. Test out various sample characters, clothing, and animations. See [Test accessories](../../../art/accessories/accessory-fitting-tool.md#test-accessories) for additional information.
- If required, make minor cage adjustments using the editing features. Larger cage changes may require returning to your third-party modeling software and re-exporting the asset.
4. When ready to generate your accessory, click **Generate MeshPart Accessory**. The accessory object with your model populates in your workspace.
<figure>
<img src="../../../assets/art/accessories/creating/Exporting-Clothing-in-Studio-Highlight.png" />
<figcaption>Clothing accessory in viewport</figcaption>
</figure>
<figure>
<img src="../../../assets/art/accessories/creating/Exporting-Accessory-Explorer.png" />
<figcaption>Clothing accessory in Explorer</figcaption>
</figure>
Congratulations, you've completed your clothing tutorial. With this accessory, you can:
- Equip the accessory on an avatar-ready character by drag and dropping the accessory on an existing model, or using [HumanoidDescription](../../../characters/appearance.md#manually-modify-appearance).
- Save the accessory as an [avatar asset](../../../projects/assets/index.md#for-avatars) for use in an experience later.
- If you meet certain account requirements, you can [upload your asset](../../../marketplace/publish-to-marketplace.md) for moderation and start selling it on the Marketplace. | 467 | fc1d16b19f15c0cb8c50e46c3d6374b4016a628097e86c7babd2f8c46e9c678e |
https://create.roblox.com/docs/art/accessories/creating-rigid/importing | content/en-us/art/accessories/creating-rigid/importing.md | guide | 2026-03-29T11:46:37.939096+00:00 | # Importing
<video controls src="../../../assets/art/accessories/creating-rigid/Importing.mp4" width="100%"></video>
Studio's 3D Importer provides a quick and easy way to import third-party 3D `.fbx` or `.gltf` assets into your projects. The importer provides object previews and error-checking to ensure that your asset meets Studio's general 3D requirements.
<br />
To import your asset ([downloadable reference](../../../assets/art/accessories/creating-rigid/Chest-Texturing-Complete.fbx)):
1. From Studio's **File** menu, select **3D Importer**.
2. In the file browser, select the `.fbx` file saved locally. The 3D Importer loads a preview of the object.
1. If textures don't load for your asset, continue to the next step and add textures manually later.
3. Select **Import**.
1. The asset populates in your workspace as a `Class.Model` that contains a `Class.MeshPart` with the appropriate textures applied as a `Class.MeshPart.TextureID`.
2. If textures were not imported correctly, follow the instructions below to add the file manually.
Add textures manually
If textures didn't load correctly, add them manually. You may need to save and publish your experience in order to access the [Asset Manager](../../../projects/assets/manager.md).
1. In the **Asset Manager**, click the **Import** button.
2. Upload your image file.
3. After moderation clears for your image, select the `Class.MeshPart` parented within your imported `Class.Model`.
4. In the **TextureID** property, select the value field and add the asset ID of the texture image.
After successful import, your model object should populate in your project as a `Class.Model` with the appropriate textures applied. See [3D Importer](../../../art/modeling/3d-importer.md) for additional information on import settings and troubleshooting. | 424 | a3c8d5bf5c1770f667ee5fdb20dfa051b1c402772fb0ab0811e0ef3209ac7f63 |
https://create.roblox.com/docs/art/accessories/creating/exporting | content/en-us/art/accessories/creating/exporting.md | guide | 2026-03-29T11:46:38.013032+00:00 | # Exporting
It's important to follow the Blender export settings to ensure a Studio-compatible `.fbx` file. Before exporting your file, ensure that you've removed extra objects, such as lights, cameras, or mannequins, and applied or removed any active modifiers.
To export your file from Blender:
1. In the topbar, click **File**. A pop-up menu displays.
2. Select **Export**, then **FBX (.fbx)**. The **Blender File View** window displays.
3. On the right-hand side, change the **Path Mode** property to **Copy**, then toggle the **Embed Textures** button.
<img src="../../../assets/modeling/skinned-meshes/Blender-Export-Settings-1.png" width="320" />
4. If your project doesn't have .01 scene unit scaling, set the **Transform** > **Scale** to `.01`.
<img src="../../../assets/modeling/skinned-meshes/Blender-Export-Settings-2.png" width="320" />
5. Under the **Armature** section, disable **Add Leaf Bones**.
<img src="../../../assets/modeling/skinned-meshes/Blender-Export-Settings-3.png" width="320" />
6. Disable **Bake Animation**.
<img src="../../../assets/modeling/skinned-meshes/Blender-Export-Settings-4.png" width="320" /> <br />
7. Click the **Export FBX** button.
You've completed the exporting section of this tutorial. If desired, download a [reference sample](../../../assets/art/accessories/creating/Long_Sleeve_Export.fbx) of this exported file for comparison. You can use this reference in the next importing step. | 377 | 07af60b312107155a9c3921fd67765a6b5cca0e9451f81fad60a0e29a0432522 |
https://create.roblox.com/docs/art/accessories/creating-rigid/publishing | content/en-us/art/accessories/creating-rigid/publishing.md | guide | 2026-03-29T11:46:38.067250+00:00 | # Publishing
After generating your `Class.Accessory` item, you can now begin the process of **publishing** the asset to the Marketplace. This step is optional and only applicable for creators who intend to sell their asset.
Users must meet [creator requirements](../../../marketplace/marketplace-policy.md#creator-requirements) to be eligible to sell assets on the Marketplace. Creators must also provide an upload fee and a payment advance during the upload and publishing process.
Adding your asset to the Marketplace involves 2 steps:
1. **Uploading** - Uploading the asset to Roblox servers for moderation.
2. **Publishing** - Listing the item on sale on the Marketplace.
<video controls src="../../../assets/art/accessories/creating-rigid/Publishing.mp4" width="100%"></video>
## Upload
To upload your accessory:
1. In the **Explorer**, right-click your accessory object and select **Save to Roblox…** from the contextual menu.
2. In the **Asset Configuration** window, set the **Content Type** to **Avatar Item**.
3. Complete the following fields (you can adjust these later):
1. **Title**: The name of your accessory.
2. **Description**: A short description of your asset.
3. **Asset Category**: The type of accessory. This should match the Accessory Type selected during the [fitting and conversion](../../../art/accessories/creating-rigid/converting.md) process.
4. **Creator**: Use the dropdown to select if you'd like to publish this asset as an individual or as part of an associated group.
4. After you select the **Asset Category**, Studio begins validating the asset to ensure that it matches Roblox's accessory technical requirements.
5. If the validation is successful, you can submit the asset to the upload and moderation queue for a fee. See [Fees and commissions](../../../marketplace/marketplace-fees-and-commissions.md) for current fee information.
## Publish
After uploading your accessory, the asset is added to the moderation queue and may take up to 24 hours to clear.
You can check your accessory's moderation status in the [Creator Hub](https://create.roblox.com/dashboard/creations).
After moderation completes, your item's publishing details become available to edit and enable for sale. See the following for an overview on the various sale options available:
<iframe width="800" height="450" src="https://www.youtube-nocookie.com/embed/swQW2VS9ZMA" title="YouTube video player" frameborder="0" allow="accelerometer; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>
<br />
After listing an asset to the Marketplace, you can return to this page to edit your item's sale details, or take the item offsale. | 590 | a44356bf160f5db6a2c39beb7adea1d6a5fec92c409b220b88c7922a30a33916 |
https://create.roblox.com/docs/art/accessories/creating | content/en-us/art/accessories/creating/index.md | guide | 2026-03-29T11:46:38.113467+00:00 | # Creating
<iframe width="800" height="450" src="https://www.youtube-nocookie.com/embed/C-DwGRBHvmE" title="YouTube video player" frameborder="0" allow="accelerometer; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen></iframe>
<br /><br />
You can create your own custom avatar clothing using Blender and Roblox's downloadable project templates. These project templates include [components required for layered clothing](../../../art/accessories/layered-clothing.md#components-of-a-layered-clothing-accessory), and can double as a mannequin to quickly begin shaping and sculpting your clothing assets. By the end of this tutorial, you will have a clothing asset that contains all the required components for a layered clothing accessory on the Marketplace.
While this content and the provided examples cover the Blender workflow and tools, you can apply the same concepts to other third-party modeling applications.
<figure>
<img src="../../../assets/art/accessories/creating/Modeling-Mannequin-Start.png" />
<figcaption>Provided Blender mannequin template</figcaption>
</figure>
<figure>
<img src="../../../assets/art/accessories/creating/Example-Product.png" />
<figcaption>Final Studio-ready clothing asset</figcaption>
</figure>
This tutorial is intended for creators with moderate Blender experience and uses the following processes to create a clothing item:
1. Modeling basic clothing using an existing mannequin shape.
2. Texturing your mesh to change its surface appearance and color.
3. Caging your clothing mesh using Roblox's template cages.
4. Rigging your clothing mesh using Roblox's armature templates.
5. Exporting your asset from Blender.
6. Importing and converting the model to an accessory in Studio.
This tutorial covers a **basic workflow** for 3D clothing creation. There are many external resources for different techniques, processes, and refinements you can incorporate for creating clothing, such as using Blender's various sewing and cloth simulation tools and PBR textures. | 430 | 0fc067980b205ea3466d7c8f466f56be24abe54dafac3ee9ddc532095a988f88 |
https://create.roblox.com/docs/art/accessories/creating/importing | content/en-us/art/accessories/creating/importing.md | guide | 2026-03-29T11:46:38.126579+00:00 | # Importing
After creating the clothing item in your third-party modeling tool, import the `.fbx` using Studio's 3D Importer tool to add the object to your project as a `Class.Model`.
Use the 3D Importer to import your `.fbx` into Studio:
1. From Studio's **File** menu, select **Import 3D**.
1. Select your exported `.fbx` and verify any possible warnings or errors.
1. Warnings or errors related to the clothing mesh may require returning to Blender to resolve.
1. Select **Import** to add the model to your workspace.
<img src="../../../assets/art/accessories/creating/Exporting-Clothing-In-Studio.png" /> | 154 | e0d3cb2aaaf6f8c64f5d7d59f8864b056f5fb59fc78fb921613edc61bb57e03a |
https://create.roblox.com/docs/art/accessories/creating/sculpting | content/en-us/art/accessories/creating/sculpting.md | guide | 2026-03-29T11:46:38.322084+00:00 | # Sculpting
After scaling and positioning your clothing mesh, begin applying sculpting detail to add cloth and fabric detail to your mesh. While there are many ways to sculpt an object in Blender, this tutorial primarily uses the **Elastic Deform**, **Inflate**, and **Clothing** tools to make your mesh look more like realistic clothing.
<center>
<figure>
<img src="../../../assets/art/accessories/creating/Modeling-Complete-2.png" width="60%" />
<figcaption>Clothing mesh after sculpting details</figcaption>
</figure>
</center>
To add clothing details:
1. With the shirt highlighted, switch to **Sculpt Mode**.
2. Disable **X-Ray mode**, if required.
3. Enable **X Mirror** to perform symmetrical edits.
4. Select the **Elastic Deform** tool at `.5` strength to stretch parts of vertices to completely cover the mannequin.
1. Use <kbd>F</kbd> to change the radius of the brush.
2. You can hide the mannequin to access hard-to-reach areas.
<video controls src="../../../assets/art/accessories/creating/Modeling_05.mp4" width="100%"></video>
5. Select the **Cloth** tool.
6. Disable **X Mirror**. The cloth tool can produce unexpected results with symmetry enabled.
7. Using the Cloth tool, click and drag on your mesh to add a cloth-like surface to your mesh. Adjust the settings to change the strength of the deformations.
<video controls src="../../../assets/art/accessories/creating/Modeling_06.mp4" width="100%"></video>
8. Using the **Elastic Deform**, **Inflate**, and **Cloth** tools, make the final adjustments to your mesh so that it sits on top of the mannequin with the final desired shape.
<video controls src="../../../assets/art/accessories/creating/Modeling_07.mp4" width="100%"></video> | 424 | bd1680fa459c922f8141e4ada61ae3b03403b817f566c3eb211623f6798ab7bf |
https://create.roblox.com/docs/art/accessories/creating/caging-setup | content/en-us/art/accessories/creating/caging-setup.md | guide | 2026-03-29T11:46:38.323519+00:00 | # Caging Setup
**Caging** is the process of setting the clothing's interior and exterior surfaces, referred to as the inner and outer cages respectively. This enables your clothing to layer over existing clothing and bodies, and additional clothes to layer on top.
Since the shirt in this tutorial was created using the cage templates as a mannequin, there is no need to adjust the inner cage where your clothing asset already fits over. **Only the outer cage needs to be adjusted** to fit over the new clothing item.
<figure>
<img src="../../../assets/art/accessories/creating/Texturing-Complete.png" />
<figcaption>Clothing and cage meshes before caging</figcaption>
</figure>
<figure>
<img src="../../../assets/art/accessories/creating/Caging-Complete.png" />
<figcaption>Outer cage mesh after caging process</figcaption>
</figure>
The caging process uses the following steps:
1. Set up your project by isolating the outer cage and the clothing mesh in your project.
2. Modify the outer cage to wrap over the clothing mesh using sculpting tools.
To set up your project:
1. Switch to **Object mode**.
2. In the Outliner:
1. Hide the Armature.
2. Unhide your LongSleeve_OuterCage object.
3. In the Outliner, navigate to **Armature** > **Long Sleeve** and toggle the **Disable Selection** icon. This prevents accidental edits to the clothing mesh.
<img src="../../../assets/art/accessories/creating/Caging-Outliner-Setup.png" />
4. Select the OuterCage object, and navigate to Object Properties and enable **Wireframe**. This helps easily visualize and access the mesh.
<img src="../../../assets/art/accessories/creating/Caging-Outer-Cage-Properties.png" />
<video controls src="../../../assets/art/accessories/creating/Caging_01.mp4" width="100%"></video> | 414 | ae617f8f4099dc63cf9b3ff9a9cbaf9bc26583c13e928c3049ff4cf39a32ae2e |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 33