Introduction

If a CALayer moves with an unwanted animation, Core Animation is usually applying an implicit action for the property change. To move the layer instantly, you need to disable those implicit animations for that update. The safest solution is usually a CATransaction with actions disabled, though there are a few other valid patterns depending on how often the layer changes.

Why the Layer Animates at All

CALayer animates many property changes automatically. Setting position, bounds, frame, opacity, and similar properties can create an implicit animation even if you never added an explicit CABasicAnimation.

That means code like this may animate:

layer.position = CGPoint(x: 100, y: 200)

If you expected an instant jump, Core Animation's default actions are the reason.

The Most Common Fix: Disable Actions in a Transaction

Wrap the property change in a CATransaction and disable actions for that transaction.

1import QuartzCore
2import UIKit
3
4func moveLayerInstantly(_ layer: CALayer, to point: CGPoint) {
5    CATransaction.begin()
6    CATransaction.setDisableActions(true)
7    layer.position = point
8    CATransaction.commit()
9}

This is the standard solution because it is explicit, local to the change, and easy to read in maintenance code.

Updating the Frame Instead of Position

The same pattern applies if you are changing the frame.

1func moveFrameInstantly(_ layer: CALayer) {
2    CATransaction.begin()
3    CATransaction.setDisableActions(true)
4    layer.frame = CGRect(x: 20, y: 40, width: 120, height: 60)
5    CATransaction.commit()
6}

The key point is not which geometry property you change. The key point is that the change happens while Core Animation actions are disabled.

Remove Existing Animations If Needed

Sometimes the real issue is not just an implicit animation. The layer may already have explicit animations attached. In that case, disabling actions for the next property update is not enough by itself.

1layer.removeAllAnimations()
2
3CATransaction.begin()
4CATransaction.setDisableActions(true)
5layer.position = CGPoint(x: 180, y: 220)
6CATransaction.commit()

If a layer keeps sliding even after you disable actions, check whether an explicit animation is still running.

Permanent Disabling Through the actions Dictionary

If a particular layer should never animate certain properties implicitly, you can override its actions dictionary.

1import QuartzCore
2
3layer.actions = [
4    "position": NSNull(),
5    "bounds": NSNull(),
6    "frame": NSNull()
7]

This is useful when a layer is updated often and you do not want to wrap every single change in a transaction. The tradeoff is that the behavior is now embedded in layer configuration rather than at the call site.

UIView Animation Blocks Are a Different System

If the layer belongs to a UIView, also remember that view animations and layer implicit animations can overlap conceptually but are not the same mechanism. For view-backed layout changes, a UIView.performWithoutAnimation block may be more appropriate at the view level.

1UIView.performWithoutAnimation {
2    view.layer.position = CGPoint(x: 120, y: 120)
3    view.layoutIfNeeded()
4}

That is useful when the movement is part of a larger UIKit layout update rather than raw Core Animation layer work.

Debugging Unexpected Motion

If the layer still animates, inspect these possibilities:

• an explicit CAAnimation is attached
• the change is being performed inside another animation context
• a view layout pass is reapplying geometry later
• the wrong layer is being updated

Those cases often look like "disable actions did not work" when the problem is actually elsewhere.

When Instant Movement Is the Right Choice

Moving a layer instantly is common for:

• snapping a drag handle to a final position
• correcting state after a gesture cancel
• initial layout before the screen appears
• updating a debug or overlay layer without visual transition

Using animation in those cases can make the UI feel laggy or wrong.

Common Pitfalls

• Changing position directly and forgetting that Core Animation may animate it implicitly.
• Disabling actions but leaving an older explicit animation attached to the layer.
• Using a permanent actions override when only one update should have been animation-free.
• Debugging a UIView layout animation as if it were purely a CALayer problem.
• Updating the wrong geometric property and then being surprised by layout side effects.

Summary

• 'CALayer property changes often animate implicitly unless you disable actions.'
• The standard instant-move fix is a CATransaction with setDisableActions(true).
• Remove existing explicit animations if the layer keeps moving anyway.
• Use the actions dictionary only when you want persistent no-animation behavior.
• If the layer belongs to a view, consider whether the real issue is UIKit layout animation rather than Core Animation alone.