Introduction

Animating a UILabel font-size change is slightly tricky because changing label.font is not an implicitly animatable property. In practice, you either animate a visual scale transform for a smooth effect, or you change the font while animating layout and appearance around it.

Why Font Size Does Not Animate Like Frame Changes

UIKit animation blocks interpolate many view properties such as frame, alpha, and transforms. The font property of UILabel is different: if you set a new font size inside UIView.animate, the label usually jumps from one size to the other instead of smoothly tweening.

That is why developers often think their animation code is broken when the real issue is that font itself is not being interpolated.

The Most Practical Technique: Animate Transform

If the visual goal is simply "make the label look larger or smaller smoothly," animate the label's transform.

1import UIKit
2
3let label = UILabel()
4label.text = "Hello"
5label.font = UIFont.systemFont(ofSize: 20)
6
7UIView.animate(withDuration: 0.3) {
8    label.transform = CGAffineTransform(scaleX: 1.5, y: 1.5)
9}

This is smooth because transforms are animatable. The label's underlying font is still the original size, but the rendered result grows on screen.

To return it:

UIView.animate(withDuration: 0.3) {
    label.transform = .identity
}

This is often the best answer for emphasis effects, badges, counters, or interactive UI feedback.

When You Need a Real Font Change

Sometimes the transform trick is not enough. You may need the actual font to change because:

• layout should reflow based on the new size
• accessibility behavior matters
• text rendering should use the new font metrics permanently

In that case, set the new font and animate layout changes around it.

1import UIKit
2
3label.font = UIFont.systemFont(ofSize: 28, weight: .semibold)
4UIView.animate(withDuration: 0.3) {
5    label.superview?.layoutIfNeeded()
6}

This does not interpolate the font itself, but it can animate any frame or constraint changes caused by the new font size.

A Combined Technique for Better Perception

A common production pattern is:

• temporarily animate scale for visual smoothness
• then commit the final font size
• reset the transform back to identity

1import UIKit
2
3func animateFontChange(label: UILabel, to size: CGFloat) {
4    let oldTransform = label.transform
5
6    UIView.animate(withDuration: 0.15, animations: {
7        label.transform = oldTransform.scaledBy(x: 1.2, y: 1.2)
8    }, completion: { _ in
9        label.font = label.font.withSize(size)
10        label.transform = .identity
11    })
12}

This is not mathematically perfect font interpolation, but it often looks better than a hard jump.

Constraint-Based Layout Considerations

If the label is inside Auto Layout, a font change may affect intrinsic content size. That means neighboring views can move, wrap, or compress differently.

When that matters, call layoutIfNeeded inside an animation block on the appropriate container.

1label.font = UIFont.systemFont(ofSize: 30)
2UIView.animate(withDuration: 0.25) {
3    label.superview?.layoutIfNeeded()
4}

Without that, the font may change instantly and surrounding layout may also jump.

What About Core Animation?

You can apply lower-level Core Animation transforms to the label's layer, but for most UILabel size effects, UIView.animate with transforms is simpler and easier to maintain.

Core Animation is more useful when you need timing curves, keyframes, or repeated motion beyond a basic grow-shrink effect.

Dynamic Type and Accessibility

If your app supports Dynamic Type, be careful not to fight the user's accessibility settings.

A permanent font-size change should usually respect text styles or scaled fonts rather than arbitrary fixed numbers.

Animation for feedback is fine, but long-term text sizing should still cooperate with the system's accessibility model.

Common Pitfalls

The biggest mistake is expecting label.font = ... inside UIView.animate to interpolate smoothly. It usually does not.

Another mistake is using transform scaling when the actual layout needs to adapt to a new font size. Transform only changes appearance, not intrinsic font metrics.

A third issue is forgetting Auto Layout. If the new font changes label size, animate the container layout so neighboring views do not snap abruptly.

Finally, scaling text too aggressively can make it look blurry or visually inconsistent if the effect is held for too long. Use transform animation mainly for short emphasis transitions.

Summary

• 'UILabel.font does not animate smoothly by itself.'
• For a visual size effect, animate the label's transform.
• For a real font-size change, set the new font and animate layout updates around it.
• Combine transform and final font updates if you want a smoother perceived transition.
• Use layoutIfNeeded when Auto Layout should animate the resulting size change.
• Pick the technique based on whether you want a visual effect or a true typographic change.