Controls the playback of an animation on an `Class.Animator`. This object
cannot be created, instead it is returned by the
`Class.Animator:LoadAnimation()` method.


The function in this code sample will play an AnimationTrack on a loop, for a
specific number of loops, before stopping the animation.

In some cases the developer may want to stop a looped animation after a
certain number of loops have completed, rather than after a certain amount of
time. This is where the DidLoop event can be used.

This event fires whenever a looped `Class.AnimationTrack` completes a
loop, on the next update.

Currently it may also fire at the exact end of a non looped animation
track but this behavior should not be relied upon.


AnimationTrack.DidLoop

Fires when an `Class.AnimationTrack` loops on the next update following
the end of the previous animation loop.


The function in this code sample plays an animationTrack and yields until
it has stopped and ended, printing at each step along the way.

Fires when the `Class.AnimationTrack` is completely done moving anything
in the world, meaning the animation has finished playing, the "fade out"
is finished, and the subject is in a neutral pose.

You can use this to take action when the animation track's subject is back
in a neutral pose that's unaffected by the `Class.AnimationTrack` or to
clean up the `Class.AnimationTrack`.


AnimationTrack.Ended

Fires when the `Class.AnimationTrack` is completely done moving anything
in the world.


Fires every time playback of an `Class.AnimationTrack` reaches a
`Class.Keyframe` that does not have the default name of `Keyframe`. This
event lets you run code at predefined points in an animation (set by
`Class.Keyframe` names).

`Class.Keyframe` names do not need to be unique. For example, if an
animation has three keyframes named `Particles`, this event will fire each
time one of these keyframes is reached.

`Class.Keyframe` names can be set in the
[Animation Editor](/animation/editor) when creating or editing
an animation. They cannot however be set by a `Class.Script` on an
existing animation prior to playing it.


AnimationTrack.KeyframeReached

keyframeName

The name of the `Class.Keyframe` reached.


Fires every time playback of an `Class.AnimationTrack` reaches a
`Class.Keyframe` that does not have the default name of `Keyframe`.


The function in this code sample will play an animationTrack and yield until
it has stopped, before printing.

Fires whenever the `Class.AnimationTrack` finishes playing.

This event has a number of uses. It can be used to wait until an
`Class.AnimationTrack` has stopped before continuing (for example, if
chaining a series of animations to play after each other). It can also be
used to clean up any `Class.Instance|Instances` created during the
animation playback.


AnimationTrack.Stopped

Fires when the `Class.AnimationTrack` finishes playing. The AnimationTrack
might still animate the subject while the animation "fades out". To catch
when the AnimationTrack is completely done moving anything in the world,
use the `Class.AnimationTrack.Ended` event.


The following function will play an AnimationTrack for a specific duration.
This is done by changing the speed of the animation to the length of the
animation divided by the desired playback duration. This could be used in
situations where a developer wants to play a standard animation for different
duration (for example, recharging different abilities).

In this example a player and an animation is loaded. The Length of an
AnimationTrack determines how long the track would take to play if the speed
is at 1. If the speed is adjusted, then the actual time it will take a track
to play can be computed by dividing the length by the speed.

This method changes the `Class.AnimationTrack.Speed` of an animation. A
positive value for speed plays the animation forward, a negative one plays
it backwards, and `0` pauses it.

A track's initial speed is set as a parameter in
`Class.AnimationTrack:Play()`. However a track's
`Class.AnimationTrack.Speed` can be changed during playback using this
method. When speed is equal to `1`, the amount of time an animation takes
to complete is equal to `Class.AnimationTrack.Length` (in seconds).

When is adjusted, then the actual time it will take a track to play can be
computed by dividing the length by the speed. `Class.AnimationTrack.Speed`
is a unitless quantity.


AnimationTrack:AdjustSpeed

speed

The playback speed the animation is to be changed to.


Changes the `Class.AnimationTrack.Speed` of an animation. A positive value
for speed plays the animation forward, a negative one plays it backwards,
and `0` pauses it.


This code sample includes a function that changes the weight of an
AnimationTrack and yields until the weight has changed to the new target
weight.

The purpose of this sample is to demonstrate how the fadeTime parameter of
AnimationTrack.AdjustWeight works. In most cases, if a developer wishes to
yield over the fadeTime it is recommended they use wait(fadeTime).

Changes the weight of an animation, with the optional `fadeTime` parameter
determining how long it takes for `Class.AnimationTrack.WeightCurrent` to
reach `Class.AnimationTrack.WeightTarget`.

When weight is set in an `Class.AnimationTrack` it does not change
instantaneously but moves from `Class.AnimationTrack.WeightCurrent` to
`Class.AnimationTrack.WeightTarget`. The time it takes to do this is
determined by the `fadeTime` parameter given when the animation is played,
or the weight is adjusted.

The animation weighting system is used to determine how
`Class.AnimationTrack|AnimationTracks` playing at the same priority are
blended together. The default weight is `1`, and no movement will be
visible on an `Class.AnimationTrack` with a weight of `0`. The pose that
is shown at any point in time is determined by the weighted average of all
the `Class.Pose|Poses` and the `Class.AnimationTrack.WeightCurrent` of
each `Class.AnimationTrack`. See below for an example of animation
blending in practice. In most cases blending animations is not required
and using `Class.AnimationTrack.Priority` is more suitable.


AnimationTrack:AdjustWeight

weight

The weight the animation is to be changed to.


fadeTime

The duration of time that the animation will fade between the old
weight and the new weight for.


Changes the weight of an animation, with the optional `fadeTime` parameter
determining how long it takes for `Class.AnimationTrack.WeightCurrent` to
reach `Class.AnimationTrack.WeightTarget`.


This `LocalScript` code waits for the local player's `Humanoid` object to
load, then it creates a new `Animation` instance with the proper
`Class.Animation.AnimationId`. The animation is then loaded onto the humanoid,
creating an `AnimationTrack`, and the track is played with
`Class.AnimationTrack:Play()`. Following that, the
`Class.AnimationTrack:GetMarkerReachedSignal()` function detects when the
"KickEnd" marker is hit.

This method returns an `Datatype.RBXScriptSignal` (event) similar to the
`Class.AnimationTrack.KeyframeReached` event, except it only fires when a
specified `Class.KeyframeMarker` has been hit in an
`Class.Animation|animation`. The difference allows for greater control of
when the event will fire.

To learn more about using this method, see
[here](/animation/events).

#### See Also

- `Class.KeyframeMarker`
- `Class.AnimationTrack`, controls the playback of an animation on a
  `Class.Humanoid` or `Class.AnimationController`
- `Class.Keyframe`, holds the `Class.Pose|Poses` applied to joints in a
  `Class.Model` at a given point of time in an animation
- `Class.Keyframe:AddMarker()`
- `Class.Keyframe:RemoveMarker()`
- `Class.Keyframe:GetMarkers()`


AnimationTrack:GetMarkerReachedSignal

name

The name of the `Class.KeyframeMarker` the signal is being created
for. Not to be confused with the name of the `Class.Keyframe`.


The signal created and fired when the animation reaches the created
`Class.KeyframeMarker`.


Returns an `Datatype.RBXScriptSignal` (event) that fires when a specified
`Class.KeyframeMarker` has been hit in an `Class.Animation|animation`.


AnimationTrack:GetParameter

AnimationTrack:GetParameterDefaults

AnimationTrack:GetTargetInstance

AnimationTrack:GetTargetNames

This sample includes a function that will jump to the first keyframe of a
specified name in an AnimationTrack.

As AnimationTrack.TimePosition cannot be set while the animation is not
playing the function first checks to see if the animation is playing.

This sample will only work once an Animation has loaded.

Returns the time position of the first `Class.Keyframe` of the given name
in an `Class.AnimationTrack`. If multiple `Class.Keyframe|Keyframes` share
the same name, it will return the earliest one in the animation.

This method will return an error if it is uses with an invalid keyframe
name (one that does not exist for example) or if the underlying
`Class.Animation` has not yet loaded. To address this make sure only
correct keyframe names are used and the animation has loaded before
calling this method.

To check if the animation has loaded, verify that the
`Class.AnimationTrack.Length` is greater than zero.


AnimationTrack:GetTimeOfKeyframe

The name associated with the `Class.Keyframe` to be found.


The time, in seconds, the `Class.Keyframe` occurs at normal playback
speed.


Returns the time position of the first `Class.Keyframe` of the given name
in an `Class.AnimationTrack`.


The following code sample includes two functions that demonstrate how
AdjustSpeed and TimePosition can be used to freeze an animation at a
particular point.

The first function freezes an animation at a particular point in time (defined
in seconds). The second freezes at it at a percentage (between 0 or 100) by
multiplying the percentage by the track length.

As TimePosition can not be used when an AnimationTrack is not playing, the
functions check to make sure the animation is playing before proceeding.

When `Class.AnimationTrack:Play()` is called the track's animation will
begin playing and the weight of the animation will increase from `0` to
the specified `weight` (defaults to `1`) over the specified `fadeTime`.

The speed the `Class.AnimationTrack` will play at is determined by the
speed parameter (defaults to `1`). When the speed is equal to `1` the
number of seconds the track will take to complete is equal to the track's
`Class.AnimationTrack.Length` property. For example, a speed of `2` will
cause the track to play twice as fast.

The weight and speed of the animation can also be changed after the
animation has begun playing by using the
`Class.AnimationTrack:AdjustWeight()` and
`Class.AnimationTrack:AdjustSpeed()` methods.

If you want to start the animation at a specific point using
`Class.AnimationTrack.TimePosition`, it's important the animation is
played before this is done.


AnimationTrack:Play

The duration of time that the animation's weight should be faded in
for.


The weight the animation is to be played at.


Plays the `Class.AnimationTrack`. Once called an `Class.AnimationTrack`
will play with the specified `fadeTime`, weight and speed.


AnimationTrack:SetParameter

value

AnimationTrack:SetTargetInstance

target

This code sample includes a function that stops an AnimationTrack with a
specific fadeTime, and yields until the fade is completed and the weight of
the AnimationTrack is equal to zero.

The purpose of this sample is to demonstrate how the fadeTime parameter of
AnimationTrack.Stop works. In most cases, if a developer wishes to yield over
the fadeTime it is recommended they use wait(fadeTime).

Stops the `Class.AnimationTrack`. Once called, the weight of the animation
will move towards zero over a length of time specified by the optional
`fadeTime` parameter. For example, if `Stop()` is called with a `fadeTime`
of `2`, it will take two seconds for the weight of the track to reach zero
and its effects completely end. Please note this will be the case
regardless of the initial weight of the animation.

It is not recommended to use a `fadeTime` of `0` in an attempt to override
this effect and end the animation immediately for `Class.Motor6D|Motor6Ds`
that have their `Class.Motor.MaxVelocity` set to zero, as this causes the
joints to freeze in place. If it must end immediately, ensure the
`Class.Motor.MaxVelocity` of `Class.Motor6D|Motor6Ds` in your rig are high
enough for them to snap properly.


AnimationTrack:Stop

The time, in seconds, for which animation weight is to be faded out
over.


AnimationTrack

The following code sample prints the name of an animation whenever an
`Class.AnimationTrack` plays on a `Class.Humanoid`. This script can be placed
in a model with a `Class.Humanoid` child.

The `Class.Animation` object that was used to create this
`Class.AnimationTrack`. To create an `Class.AnimationTrack`, you must load
an `Class.Animation` object onto an `Class.Animator` using the
`Class.Animator:LoadAnimation()` method.


AnimationTrack.Animation

The `Class.Animation` object that was used to create this
`Class.AnimationTrack`.


This code sample includes a simple function that will play an AnimationTrack
if it is not playing, or otherwise adjust its speed and weight to match the
new parameters given.

A read-only property that returns true when the `Class.AnimationTrack` is
playing.

This property can be used to check if an animation is already playing
before playing it (as that would cause it to restart). If you want to
obtain all playing `Class.AnimationTrack|AnimationTracks` on an
`Class.Animator` or a `Class.Humanoid`, they should use
`Class.Animator:GetPlayingAnimationTracks()`


AnimationTrack.IsPlaying

A read-only property that returns true when the `Class.AnimationTrack` is
playing.


A read-only property that returns the length (in seconds) of an
`Class.AnimationTrack`. This will return `0` until the animation has fully
loaded and thus may not be immediately available.

When the `Class.AnimationTrack.Speed` of an `Class.AnimationTrack` is
equal to `1`, the animation will take `Class.AnimationTrack.Length` (in
seconds) to complete.


AnimationTrack.Length

A read-only property that returns the length (in seconds) of an
`Class.AnimationTrack`. This will return `0` until the animation has fully
loaded and thus may not be immediately available.


The animation in this example normally loops. After the player and the
animation are loaded the animation is played in a non-looped fashion then in a
looped fashion.

This property sets whether the animation will repeat after finishing. If
it is changed while playing the result will take effect after the
animation finishes.

This property defaults to how it was set in the
[Animation Editor](/animation/editor). However, this property
can be changed, allowing control over the `Class.AnimationTrack` while it
is running. This property also correctly handles animations played in
reverse (negative `Class.AnimationTrack.Speed`). After the first keyframe
is reached, it will restart at the last keyframe.


AnimationTrack.Looped

Sets whether the animation will repeat after finishing. If it is changed
while playing the result will take effect after the animation finishes.


This property sets the priority of an `Class.AnimationTrack`. Depending on
what this is set to, playing multiple animations at once will look to this
property to figure out which `Class.Keyframe` poses should be played over
one another. It uses `Enum.AnimationPriority` which has 7 priority levels:

1. `Enum.AnimationPriority|Action4` (highest priority)
2. `Enum.AnimationPriority|Action3`
3. `Enum.AnimationPriority|Action2`
4. `Enum.AnimationPriority|Action`
5. `Enum.AnimationPriority|Movement`
6. `Enum.AnimationPriority|Idle`
7. `Enum.AnimationPriority|Core` (lowest priority)

Properly set animation priorities, either through the
[Animation Editor](/animation/editor) or through this property,
allow multiple animations to be played without them clashing. Where two
playing animations direct the target to move the same limb in different
ways, the `Class.AnimationTrack` with the highest priority will show. If
both animations have the same priority, the weights of the tracks will be
used to combine the animations.


AnimationTrack.Priority

Sets the priority of an `Class.AnimationTrack`. Depending on what this is
set to, playing multiple animations at once will look to this property to
figure out which `Class.Keyframe` `Class.Pose|Poses` should be played over
one another.


This read-only property gives the current playback speed of the
`Class.AnimationTrack`. When equal to `1`, the amount of time an animation
takes to complete is equal to `Class.AnimationTrack.Length`, in seconds.

If the speed is adjusted through `Class.AnimationTrack:AdjustSpeed()`, the
actual time it will take a track to play can be computed by dividing the
length by the speed. Speed is a unitless quantity.


AnimationTrack.Speed

Read-only property that gives the current playback speed of the
`Class.AnimationTrack`.


Returns the position in time in seconds that an `Class.AnimationTrack` is
through playing its source animation. Can be set to make the track jump to
a specific moment in the animation, but the `Class.AnimationTrack` must be
playing to do so. It can also be used in combination with
`Class.AnimationTrack:AdjustSpeed()` to freeze the animation at a desired
point by setting speed to `0`.


AnimationTrack.TimePosition

Returns the position in time in seconds that an `Class.AnimationTrack` is
through playing its source animation. Can be set to make the track jump to
a specific moment in the animation.


This code sample loads two animations onto the local player's Humanoid and
demonstrates how the fadeTime paramater in AnimationTrack.Play determines how
long it takes for an AnimationTrack's WeightCurrent to reach it's
WeightTarget.

As WeightCurrent and WeightTarget are floats the == operator cannot be used to
compare, instead it is more appropriate to check that the difference between
them is sufficiently small to assume the weight fade has completed.

When weight is set in an `Class.AnimationTrack` it does not change
instantaneously but moves from `Class.AnimationTrack.WeightCurrent` to
`Class.AnimationTrack.WeightTarget`. The time it takes to do this is
determined by the `fadeTime` parameter given when the animation is played,
or the weight is adjusted.

`Class.AnimationTrack.WeightCurrent` can be checked against
`Class.AnimationTrack.WeightTarget` to see if the desired weight has been
reached. Note that these values should not be checked for equality with
the `==` operator, as both of these values are floats. To see if
`Class.AnimationTrack.WeightCurrent` has reached the target weight, it is
recommended to see if the distance between those values is sufficiently
small.


AnimationTrack.WeightCurrent

Read-only property that gives the current weight of the
`Class.AnimationTrack`.


This read-only property gives the current weight of the
`Class.AnimationTrack`. It has a default value of `1` and is set when
`Class.AnimationTrack:Play()`, `Class.AnimationTrack:Stop()` or
`Class.AnimationTrack:AdjustWeight()` is called. When weight is set in an
`Class.AnimationTrack` it does not change instantaneously but moves from
`Class.AnimationTrack.WeightCurrent` to
`Class.AnimationTrack.WeightTarget`. The time it takes to do this is
determined by the `fadeTime` parameter given when the animation is played,
or the weight is adjusted.

`Class.AnimationTrack.WeightCurrent` can be checked against
`Class.AnimationTrack.WeightTarget` to see if the desired weight has been
reached. Note that these values should not be checked for equality with
the `==` operator, as both of these values are floats. To see if
`Class.AnimationTrack.WeightCurrent` has reached the target weight, it is
recommended to see if the distance between those values is sufficiently
small.


AnimationTrack.WeightTarget

Controls the playback of an animation on an `Class.Animator`.


`Instance` is the base class for all classes in the Roblox class hierarchy
which can be part of the `Class.DataModel` tree.

It is not possible to directly create root `Instance` objects, but the special
`Datatype.Instance.new()` constructor creates objects via code, taking the
name of the class as a parameter and returning the created object.


Demonstrates detecting changes to an instance's ancestry by connecting to the `Class.Instance.AncestryChanged` event.

The ChangingPart's Parent is set to different values overtime. The parent of the part is the part's ancestor, so the `Class.Instance.AncestryChanged` event will fire whenever it changes.

Fires when the `Class.Instance.Parent` property of the object or one of
its ancestors is changed.

This event includes two parameters: `child` refers to the `Class.Instance`
whose `Class.Instance.Parent` was actually changed, while `parent` refers
to this instance's new `Class.Instance.Parent`.

You can use this event to track the deletion of an instance in Studio,
such as manual deletion in the Explorer or through a plugin. If you need
to detect when an instance is destroyed using `Class.Instance:Destroy()`,
use the `Class.Instance.Destroying` event instead.


Instance.AncestryChanged

child

The `Class.Instance` whose `Class.Instance.Parent` has been changed.


parent

The new `Class.Instance.Parent` of the `Class.Instance` whose
`Class.Instance.Parent` was changed.


Fires when the `Class.Instance.Parent` property of the object or one of
its ancestors is changed.


This event fires whenever any attribute is changed on the instance,
including when an attribute is set to `nil`. The name of the changed
attribute is passed to the connected function.

For example, the following code snippet connects the `attributeChanged()`
function to fire whenever one of the part's attributes changes:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part

local function attributeChanged(attributeName)
	print(attributeName, "changed")
end

part.AttributeChanged:Connect(attributeChanged)
```

See also `Class.Instance:GetAttributeChangedSignal()` which returns an
event that fires when a specific given attribute changes.


Instance.AttributeChanged

attribute

The name of the attribute that has been changed.


Fires whenever an attribute is changed on the `Class.Instance`.


This snippet prints the names of objects as they are added to the Workspace:

Fires after an object is parented to this `Class.Instance`.

Note, when using this method on a client to detect objects created by the
server it is necessary to use `Class.Instance:WaitForChild()` when
indexing these object's descendants. This is because the object and its
descendants are not guaranteed to replicate from the server to the client
simultaneously. For example:

```
local Workspace = game:GetService("Workspace")

Workspace.ChildAdded:Connect(function(child)
	-- Use WaitForChild() since descendants may not have replicated yet
	local head = child:WaitForChild("Head")
end)
```

Note, this event only operates for immediate children of the
`Class.Instance`. For an event that captures all descendants, use
`Class.Instance.DescendantAdded`.

See also `Class.Instance.ChildRemoved`.


Instance.ChildAdded

The `Class.Instance` that has been added.


Fires after an object is parented to this `Class.Instance`.


Instance.childAdded

This snippet prints the names of objects as they are removed from the
Workspace:

Fires after a child is removed from this `Class.Instance`.

Removed refers to when an object's parent is changed from this
`Class.Instance` to something other than this `Class.Instance`. Note, this
event will also fire when a child is destroyed (using
`Class.Instance:Destroy()`) as the destroy function sets an object's
parent to `nil`.

This event only operates for immediate children of the `Class.Instance`.
For an event that captures all descendants, use
`Class.Instance.DescendantRemoving`.

See also `Class.Instance.ChildAdded`.


Instance.ChildRemoved

The `Class.Instance` that has been removed.


Fires after a child is removed from this `Class.Instance`.


This following example will print the name of any object that is added to the
Workspace:

This event fires after a descendant is added to the `Class.Instance`.

As it fires for every descendant, parenting an object to the
`Class.Instance` will fire the event for this object and all of its
descendants individually.

If you're only concerned with the **direct children** of the
`Class.Instance`, use `Class.Instance.ChildAdded` instead.

See also `Class.Instance.DescendantRemoving`.


Instance.DescendantAdded

descendant

Fires after a descendant is added to the `Class.Instance`.


The following example prints the name of any descendant as it is being removed
from the Workspace:

This event fires **immediately before** the parent `Class.Instance`
changes such that a **descendant** instance will no longer be a
descendant. `Class.Instance:Destroy()|Destroy()` changes an instance's
`Class.Instance.Parent|Parent` to `nil`, so calling that method on a
descendant of the parent will cause this event to fire.

Since this event fires **before** the descendant's removal, the parent of
the descendant will be unchanged at the time of this event firing. If the
descendant is also a **direct child** of the parent, this event will fire
before `Class.Instance.ChildRemoved`.

If a descendant has children, this event fires with the descendant first,
followed by its descendants.

##### Warning

This event fires with the descendant object that is being removed.
Attempting to set the `Class.Instance.Parent|Parent` of the descendant to
something else will fail. Below is an example that demonstrates this:

```
local Workspace = game:GetService("Workspace")

Workspace.DescendantRemoving:Connect(function(descendant)
	-- Do not manipulate the parent of the descendant in this function!
	-- This event fires BECAUSE the parent was manipulated, and the change hasn't happened yet
	-- Therefore, it is problematic to change the parent like this:
	descendant.Parent = game
end)

local part = Instance.new("Part")
part.Parent = Workspace
part.Parent = nil
```

See also `Class.Instance.DescendantAdded|DescendantAdded`.


Instance.DescendantRemoving

The `Class.Instance` that is being removed.


Fires immediately before a descendant of the `Class.Instance` is removed.


This sample demonstrates how, when using Immediate signal behavior, an Instance being destroyed remains in place until the connected function yields.

This sample demonstrates how, when using Deferred signal behavior,
an Instance is destroyed before the signal fires.

The `Class.Instance` will never be deleted from memory while a connected
function is still using it. However, if the function yields at any point,
the `Class.Instance` and its descendants will be parented to `nil`.

If the `Class.Workspace.SignalBehavior` property is set to
`Enum.SignalBehavior.Immediate`, this event fires immediately before the
`Class.Instance` or one of its ancestors is destroyed with
`Class.Instance:Destroy()`.

If the `Class.Workspace.SignalBehavior` property is set to
`Enum.SignalBehavior.Deferred`, this event fires at the next resumption
point, which will be after the `Class.Instance` or one of its ancestors is
destroyed with `Class.Instance:Destroy()`.

With `Enum.SignalBehavior.Deferred|Deferred` behavior, connecting a script
to its own `Class.Instance.Destroying` event is problematic, as the script
will be destroyed before the callback can be called (meaning it will not
execute).

When deleting an `Class.Instance` in Studio, such as manually deleting
through the [Explorer](/studio/explorer) or through a plugin,
the `Class.Instance` isn't destroyed. Instead, the parent is set to `nil`
which you can track with `Class.Instance.AncestryChanged`.


Instance.Destroying

Fires immediately before (or is deferred until after) the instance is
destroyed via `Class.Instance:Destroy()`.


This event fires whenever any style property is changed on the instance,
including when a property is set to `nil`.

```lua
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local playerGui = player.PlayerGui
local HUDContainer = playerGui:WaitForChild("HUDContainer")
local meterBar = HUDContainer.MeterBar

local function stylePropertyChanged()
	print("Styled properties changed")
end

meterBar:StyledPropertiesChanged():Connect(stylePropertyChanged)
```


Instance.StyledPropertiesChanged

Fires whenever any style property is changed on the instance, including
when a property is set to `nil`.


This method applies a tag to the instance, with no effect if the tag is
already applied. Successfully adding a tag will fire a signal created by
`Class.CollectionService:GetInstanceAddedSignal()` with the given tag.

##### Warnings

- An instance's tags that were added client-side will be dropped if the
  server later adds or removes a tag on that instance because the server
  replicates all tags together and overwrites previous tags.

- When tagging an instance, it is common that some resources are used to
  give the tag its functionality, for example event connections or tables.
  To prevent memory leaks, it's a good idea to clean these up (disconnect,
  set to `nil`, etc.) when no longer needed for a tag. Do this when
  calling `Class.Instance:RemoveTag()`, calling
  `Class.Instance:Destroy()`, or in a function connected to a signal
  returned by `Class.CollectionService:GetInstanceRemovedSignal()`.


Instance:AddTag

The children function returns an array of the object's children.


Instance:children

Returns an array of the object's children.


This method destroys all of an instance's children and descendants.

```
local part = Instance.new("Part")

-- Add some sparkles
for i = 1, 3 do
	local sparkles = Instance.new("Sparkles")
	sparkles.Parent = part

  local sc = Instance.new("Sparkles")
  sc.Parent = sparkles
end

print("Children:", #part:GetChildren())  --> Children: 3

part:ClearAllChildren()

print("Children:", #part:GetChildren())  --> Children: 0
```

If you do not wish to destroy **all** children and descendants, use either
`Class.Instance:GetChildren()` or `Class.Instance:GetDescendants()` to
loop through those children/descendants and select what to destroy. For
example, the following code sample will destroy all
`Class.BasePart|BaseParts` descending from a `Class.Model`:

```
local Workspace = game:GetService("Workspace")

local model = Workspace:FindFirstChild("TestModel")

for _, descendant in model:GetDescendants() do
	if descendant:IsA("BasePart") then
		descendant:Destroy()
	end
end
```


Instance:ClearAllChildren

This method destroys all of an instance's children.


Demonstrates cloning a model using `Class.Instance:Clone()`.

`Clone()` creates a copy of an instance and all of its descendants,
ignoring all instances that are not
`Class.Instance.Archivable|Archivable`. The copy of the root instance is
returned by this method and its `Class.Instance.Parent|Parent` is set to
`nil`. Note that if the instance itself has
`Class.Instance.Archivable|Archivable` set to `false`, this method will
return `nil`.

If a reference property such as `Class.ObjectValue.Value` is set in a
cloned instance, the value of the copy's property depends on the
original's value:

- If a reference property refers to an instance that was **also** cloned,
  the copy will refer to the copy.
- If a reference property refers to an instance that was **not** cloned,
  the same value is maintained in the copy.


Instance:Clone

Create a copy of an instance and all its descendants, ignoring instances
that are not `Class.Instance.Archivable|Archivable`.


Instance:clone

Demonstrates destroying a Part using the `Class.Instance:Destroy()` function.

This function is the correct way to dispose of objects that are no longer required.

Sets the `Class.Instance.Parent` property to `nil`, locks the
`Class.Instance.Parent` property, disconnects all connections, and calls
`Destroy()` on all children. This method is the correct way to dispose of
objects that are no longer required.

Disposing of unneeded objects is important, since unnecessary objects and
connections in a place use up memory which can lead to serious performance
issues over time.

As a best practice after calling `Destroy()` on an object, set any
variables referencing the object (or its descendants) to `nil`. This
prevents your code from accessing anything to do with the object.

```lua
local part = Instance.new("Part")
part.Name = "Hello, world"
part:Destroy()
-- Don't do this:
print(part.Name)  --> "Hello, world"
-- Do this to prevent the above line from working:
part = nil
```

Once an `Class.Instance` has been destroyed by this method, it cannot be
reused because the `Class.Instance.Parent` property is locked. To
**temporarily** remove an object instead of destroying it, set
`Class.Instance.Parent|Parent` to `nil`. For example:

```
local Workspace = game:GetService("Workspace")

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```

To destroy an object after a set amount of time, use
`Class.Debris:AddItem()`.


Instance:Destroy

Sets the `Class.Instance.Parent` property to `nil`, locks the
`Class.Instance.Parent` property, disconnects all connections, and calls
`Destroy()` on all children.


Instance:destroy

Returns the first ancestor of the `Class.Instance` whose
`Class.Instance.Name` is equal to the given name.

This method works upwards, meaning it starts at the instance's immediate
`Class.Instance.Parent` and works up towards the `Class.DataModel`. If no
matching ancestor is found, it returns `nil`.

The following code snippet would find the first ancestor of the object
named `Car`.

```
local car = object:FindFirstAncestor("Car")
```

For variants of this method that find ancestors of a specific class,
please see `Class.Instance:FindFirstAncestorOfClass()` and
`Class.Instance:FindFirstAncestorWhichIsA()`.


Instance:FindFirstAncestor

The `Class.Instance.Name` to be looked for.


Returns the first ancestor of the `Class.Instance` whose
`Class.Instance.Name` is equal to the given name.


Returns the first ancestor of the `Class.Instance` whose
`Class.Object.ClassName` is equal to the given className.

This method works upwards, meaning it starts at the instance's immediate
`Class.Instance.Parent` and works up towards the `Class.DataModel`. If no
matching ancestor is found, it returns `nil`.

A common use of this method is finding the `Class.Model` a
`Class.BasePart` belongs to. For example:

```
local model = part:FindFirstAncestorOfClass("Model")
```

This method is a variant of `Class.Instance:FindFirstAncestor()` which
checks the `Class.Object.ClassName` property rather than
`Class.Instance.Name`. `Class.Instance:FindFirstAncestorWhichIsA()` also
exists, using the `Class.Object:IsA()` method instead to respect class
inheritance.


Instance:FindFirstAncestorOfClass

className

The `Class.Object.ClassName` to be looked for.


Returns the first ancestor of the `Class.Instance` whose
`Class.Object.ClassName` is equal to the given className.


Returns the first ancestor of the `Class.Instance` for whom
`Class.Object:IsA()` returns true for the given className.

This method works upwards, meaning it starts at the instance's immediate
`Class.Instance.Parent` and works up towards the `Class.DataModel`. If no
matching ancestor is found, it returns `nil`.

Unlike `Class.Instance:FindFirstAncestorOfClass()`, this method uses
`Class.Object:IsA()` which respects class inheritance. For example:

```
print(part:IsA("Part"))  --> true
print(part:IsA("BasePart"))  --> true
print(part:IsA("Instance"))  --> true
```

Therefore, the following code sample will return the first
`Class.BasePart` ancestor, regardless of if it is a `Class.WedgePart`,
`Class.MeshPart` or `Class.Part`.

```
local part = object:FindFirstAncestorWhichIsA("BasePart")
```

See also `Class.Instance:FindFirstAncestor()`.


Instance:FindFirstAncestorWhichIsA

Returns the first ancestor of the `Class.Instance` for whom
`Class.Object:IsA()` returns true for the given className.


The below would look in Workspace for an object name "Brick". If found, it
will change the name of the object to "Foo".

Returns the first child of the `Class.Instance` with the given name, or
`nil` if no such child exists. If the optional `recursive` argument is
`true`, this method searches all descendants rather than only the
immediate children of the `Class.Instance`.

##### Checking the Existence of an Object

`FindFirstChild()` is necessary if you need to verify an object exists
before continuing. Attempting to index a child by name using the dot
operator throws an error if the child doesn't exist.

```lua
local Workspace = game:GetService("Workspace")

-- The following line errors if the part doesn't exist in the workspace
Workspace.Part.Transparency = 0.5
```

A better approach is to use `FindFirstChild()` to first check for `Part`,
then use an `if` statement to run code that needs it.

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace:FindFirstChild("Part")
if part then
	part.Transparency = 0.5
end
```

##### Finding a Child Whose Name Matches a Property

Sometimes the `Class.Instance.Name|Name` of an object is the same as that
of a property of its `Class.Instance.Parent|Parent`. When using the dot
operator, properties take precedence over children if they share a name.

In the following example, a `Class.Folder` called `Color` is added to a
`Class.Part`, which also has the `Class.Part.Color` property. Notice that
`part.Color` refers to the `Datatype.Color3` property value, not the child
`Class.Folder` instance. A benefit of using
`Class.Instance:FindFirstChild()|FindFirstChild()` is that the
introduction of new properties does not impose a risk on your code.

```lua
local part = Instance.new("Part")
local folder = Instance.new("Folder")
folder.Name = "Color"
folder.Parent = part
local c1 = part.Color  -- The property
local c2 = part:FindFirstChild("Color")  -- The child folder
```

##### Performance Notes

`Class.Instance:FindFirstChild()|FindFirstChild()` takes about 20% longer
than using the dot operator and almost 8 times longer than simply storing
a reference to an object. Therefore, you should avoid calling it in
performance-dependent code such as in tight loops or functions connected
to `Class.RunService.Heartbeat` and `Class.RunService.PreRender`. Instead,
store the result in a variable, or consider using
`Class.Instance.ChildAdded|ChildAdded` or
`Class.Instance:WaitForChild()|WaitForChild()` to detect when a child of a
given name becomes available.


Instance:FindFirstChild

The `Class.Instance.Name` to be searched for.


recursive

Whether or not the search should be conducted recursively.


Returns the first child of the `Class.Instance` found with the given name.


Instance:findFirstChild

Returns the first child of the `Class.Instance` whose
`Class.Object.ClassName|ClassName` is equal to the given `className`.
Unlike `Class.Instance:FindFirstChildWhichIsA()`, this method only returns
objects whose class matches `className`, ignoring class inheritance. If no
matching child is found, this method returns `nil`.


Instance:FindFirstChildOfClass

Returns the first child of the `Class.Instance` whose
`Class.Object.ClassName|ClassName` is equal to the given class name.


Returns the first child of the `Class.Instance` for whom
`Class.Object:IsA()` returns true for the given className.

If no matching child is found, this method returns `nil`. If the optional
recursive argument is true, this method searches all descendants rather
than only the immediate children of the `Class.Instance`.

Unlike `Class.Instance:FindFirstChildOfClass()`, this method uses
`Class.Object:IsA()` which respects class inheritance. For example:

```lua
print(part:IsA("Part")) --> true
print(part:IsA("BasePart")) --> true
print(part:IsA("Instance")) --> true
```

Therefore, the following code sample will return the first
`Class.BasePart` child, regardless of if it is a `Class.WedgePart`,
`Class.MeshPart` or `Class.Part`.

```
local part = object:FindFirstChildWhichIsA("BasePart")
```

Developers looking for a child by name, should use
`Class.Instance:FindFirstChild()` instead.


Instance:FindFirstChildWhichIsA

The `Class.Object.ClassName` to be searched for.


Returns the first child of the `Class.Instance` for whom
`Class.Object:IsA()` returns true for the given className.


Returns the first descendant found with the given `Class.Instance.Name`.

This method is disabled and cannot be used. To find the first descendant
of an instance, consider using the `recursive` parameter on
`Class.Instance:FindFirstChild()` instead.


Instance:FindFirstDescendant

The `Class.Instance.Name` to search for.


Returns the first descendant found with the given `Class.Instance.Name`.


If the `Class.Instance` is an `Class.Actor`, the `Class.Actor` itself is
returned. Otherwise, its closest ancestor `Class.Actor` is returned. If no
ancestor is an `Class.Actor`, the result is `nil`.


Instance:GetActor

Returns the `Class.Actor` associated with the Instance, if any.


This method returns the value which has been assigned to the given
attribute name. If no attribute has been assigned, `nil` is returned.

For example, the following code snippet sets and then gets the value of
the instance's `InitialPosition` attribute:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)

local initialPosition = instance:GetAttribute("InitialPosition")
print(initialPosition)
```

##### See Also

- `Class.Instance:SetAttribute()` which sets the attribute with the given
  name to the given value.
- `Class.Instance:GetAttributes()` which returns a dictionary of key‑value
  pairs for each of the instance's attributes.


Instance:GetAttribute

The name of the attribute being retrieved.


The value which has been assigned to the given attribute name. If no
attribute has been assigned, `nil` is returned.


Returns the value which has been assigned to the given attribute name.


This method returns an event that behaves exactly like the
`Class.Object.Changed|Changed` event, except that it only fires when the
specific given attribute changes; effectively it is similar to
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()` but
for attributes.

It's generally a good idea to use this method instead of a connection to
`Class.Object.Changed|Changed` with a function that checks the attribute
name. Subsequent calls to this method on the same object with the same
attribute name return the same event.

The following code example returns a signal that fires the function
`attributeChanged()` when the part's `InitialPosition` attribute changes:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)

local function attributeChanged()
	print("Attribute changed")
end

part:GetAttributeChangedSignal("InitialPosition"):Connect(attributeChanged)
```

See also `Class.Instance.AttributeChanged` which fires whenever any
attribute is changed on the instance.


Instance:GetAttributeChangedSignal

The name of the specified attribute for which the change signal is
being returned.


An event that fires when the given attribute changes.


Returns an event that fires when the given attribute changes.


Instance

`Instance` is the base class for all classes in the Roblox class hierarchy
which can be part of the `Class.DataModel` tree.


/reference/engine/classes/AnimationTrack.yaml

AnimationTrack

Summary

Properties

Methods

Events

Properties

Methods

Events

On this page