Introduction

Good UIView animations feel simple to the user because they move the interface toward a new stable state without fighting layout or blocking interaction. In practice, the best patterns are to animate view properties or constraint changes, keep the final UI state authoritative, and avoid treating animation code like a pile of magic numbers.

Animate Properties, Not Screenshots of State

UIView animation works best when you change real view properties such as alpha, transform, or layout constraints and let UIKit animate the transition.

1UIView.animate(withDuration: 0.25) {
2    self.panelView.alpha = 1.0
3    self.panelView.transform = .identity
4}

This is better than trying to manually step through intermediate frames yourself. UIKit is optimized for property-based animation and keeps the code easier to reason about.

Prefer Constraint Animation for Layout Changes

If Auto Layout controls the view position, animate constraint changes and call layoutIfNeeded() inside the animation block.

1self.leadingConstraint.constant = 20
2
3UIView.animate(withDuration: 0.3) {
4    self.view.layoutIfNeeded()
5}

This is the usual best practice for moving views in modern UIKit. Animating the frame directly while constraints also exist often leads to jumps, warnings, or animations that snap back at the end.

Keep the End State Real

A clean animation sets the model state first and lets the animation reveal it. That means the view hierarchy should end in the same configuration the layout system expects after the animation finishes.

If you animate to a visual state that does not match the underlying constraints or properties, the next layout pass can undo the effect immediately.

That is why animation should not be a fake overlay on top of the real UI state. It should be the transition into the real UI state.

Use Spring Animations Deliberately

Spring animation is useful when a transition should feel physical or playful.

1UIView.animate(
2    withDuration: 0.6,
3    delay: 0,
4    usingSpringWithDamping: 0.75,
5    initialSpringVelocity: 0.5,
6    options: [.curveEaseInOut],
7    animations: {
8        self.cardView.transform = .identity
9    }
10)

Use springs where bounce adds clarity or delight. Do not add spring motion to every transition just because it looks modern in isolation.

Pick the Right API for Complexity

For many cases, UIView.animate is enough. If the animation needs interactive control, scrubbing, or interruption, UIViewPropertyAnimator is often a better choice.

The rule is simple:

• use UIView.animate for straightforward transitions
• use UIViewPropertyAnimator for interactive or interruptible animation

Choosing the more complicated API too early often makes simple animations harder to maintain.

Performance Still Matters

Animations run on the main thread's UI lifecycle, so avoid doing heavy work at the same time. Image decoding, data processing, or synchronous network calls can make an otherwise correct animation feel broken.

Also prefer animating properties the rendering system handles efficiently. Large view hierarchy changes and layout thrashing can hurt smoothness more than the animation curve itself.

Name Animations by Their Intent

Animation code becomes easier to maintain when method names describe the UI transition, not the low-level property changes. A method named showDetailsPanel() is much easier to understand later than one named animatePanelAlphaAndTransform(), even if both perform the same work internally.

Common Pitfalls

• Animating frames directly while Auto Layout constraints still define the final position.
• Treating the animation as separate from the real end-state layout.
• Adding spring animation everywhere even when the motion does not match the UX.
• Doing heavy computation during the same user interaction that should animate smoothly.
• Reaching for a more complex animation API before confirming that UIView.animate is insufficient.

Summary

• Animate real view properties or constraints, not improvised intermediate state.
• For Auto Layout changes, update constraints and animate layoutIfNeeded().
• Make sure the final animated state matches the real UI state.
• Use spring motion only when it helps the interaction feel right.
• Start with UIView.animate and move to more advanced APIs only when the interaction requires it.