Priority Conflicts: The Most Common Cause
Roblox animations use a priority system that determines which animation controls each joint when multiple animations play simultaneously. The priorities, from lowest to highest, are Core, Idle, Movement, Action, Action2, Action3, and Action4. When two animations at the same priority try to control the same joint, they blend unpredictably, causing jitter and snapping. The fix is simple: set your animation priorities intentionally. Idle animations should be Idle priority. Walk and run should be Movement. Attacks and abilities should be Action or higher. If your attack animation looks choppy, check whether it is set to the same priority as your movement animation. In the Animation Editor, select the animation and change Priority in the properties panel. As a rule, only one animation at Action priority or above should play per body group at any given time.
FadeTime and Blending: The Transition Problem
When you call AnimationTrack:Play() or AnimationTrack:Stop(), the optional fadeTime parameter controls how long the animation takes to blend in or out. The default is 0.1 seconds, which is fine for most transitions, but problems arise when you set it to 0 (instant snap) or when you stop and start animations in the same frame without any fade. If your character snaps into an animation pose instead of transitioning smoothly, add a fadeTime of 0.1-0.2 seconds to both Play() and Stop(). For combat games where responsiveness matters, 0.1 seconds is fast enough that players will not notice the blend but slow enough to eliminate visual snapping. If you are chaining animations (combo attack 1 into attack 2), stop the first with a short fade and play the second with a matching fade so they cross-blend rather than pop.
- AnimationTrack:Play(fadeTime) — default 0.1s, set higher for smoother blends
- AnimationTrack:Stop(fadeTime) — always stop with a fade to avoid snapping
- Cross-blending: stop current and play next with matching fadeTimes (0.1-0.15s)
- Never set fadeTime to 0 unless you specifically want an instant cut
Weight and Layering Issues
AnimationTrack.Weight controls how much influence an animation has, from 0 (no effect) to 1 (full effect). If your animation looks partial or ghostly, the weight may not be at 1. This happens when you adjust weight for layering (playing a lower-body walk animation at weight 1 while an upper-body aim animation also plays at weight 1 on different joints). If both animations affect the same joints and both are at weight 1, they blend, which causes the mushy, choppy look. The solution is to ensure your animations only keyframe the joints they need to control. An upper-body attack animation should not have keyframes on the legs. Delete unnecessary keyframes in the Animation Editor so that lower-priority animations can control those joints cleanly. If you must layer animations on the same joints, reduce the weight of the less important one using AdjustWeight().
Framerate and Keyframe Density
Roblox interpolates between keyframes, so an animation with keyframes only at the start and end of a motion will look different than one with keyframes every 2-3 frames. Choppy animations often have too few keyframes during fast motions. For a punch that takes 0.3 seconds, you need keyframes at least every 3-4 frames (at 30fps) during the swing to ensure the interpolation follows the intended arc. Conversely, too many keyframes can cause stiffness because Roblox has no room to interpolate smoothly. The sweet spot for most animations is keyframes at the major pose changes (start, anticipation, contact, follow-through, recovery) with the interpolation handling the in-betweens. In the Animation Editor, use EasingStyle settings on keyframes (Linear, Cubic, Bounce) to control how Roblox interpolates between poses. Cubic is usually the smoothest for natural motion.
Animation Events and Timing Bugs
If your animation looks fine in the editor but misfires in-game, the issue is often in your script logic, not the animation itself. Common bugs include: playing the animation multiple times in rapid succession (each Play() call restacks), not stopping the previous animation before playing the next, or using task.wait() for timing instead of animation events. Use AnimationTrack:GetMarkerReachedSignal("markerName") to fire logic at specific frames rather than guessing timing with waits. Check AnimationTrack.IsPlaying before calling Play() to prevent re-stacking. If an animation plays faster or slower than expected, check AnimationTrack.Speed and AnimationTrack.Length to ensure nothing is modifying the playback rate.