Introduction

If you do not want to use a navigation controller push, a modal presentation, or a hand-built container hierarchy, the cleanest way to animate between screens is usually to replace the window's rootViewController with a transition animation. This is useful for flows such as login to main app, onboarding completion, or a full reset of the visible UI.

Replace the window root controller with animation

A navigation controller is designed for stack-based movement, but some transitions are not stack changes at all. If the old screen should disappear completely and the new screen should become the fresh top-level interface, swap the root controller.

1import UIKit
2
3func switchRootViewController(window: UIWindow, to newController: UIViewController) {
4    let snapshot = window.snapshotView(afterScreenUpdates: true)
5    newController.view.addSubview(snapshot ?? UIView())
6
7    window.rootViewController = newController
8    window.makeKeyAndVisible()
9
10    UIView.animate(withDuration: 0.35, animations: {
11        snapshot?.alpha = 0
12        snapshot?.transform = CGAffineTransform(scaleX: 1.05, y: 1.05)
13    }, completion: { _ in
14        snapshot?.removeFromSuperview()
15    })
16}

This pattern makes the change feel animated while still treating the destination as a new application root.

Using UIView.transition for a simpler crossfade

If you do not need a custom snapshot animation, UIView.transition is even simpler:

1import UIKit
2
3func crossfadeRoot(window: UIWindow, to controller: UIViewController) {
4    UIView.transition(with: window,
5                      duration: 0.3,
6                      options: [.transitionCrossDissolve],
7                      animations: {
8                          window.rootViewController = controller
9                      },
10                      completion: nil)
11}

This gives you a clean full-screen transition without introducing a navigation stack or modal relationship.

When this approach is the right fit

This strategy is best when the new view controller should replace the old app state rather than sit on top of it.

Common examples include:

• login screen to authenticated app shell,
• onboarding flow to home screen,
• logout flow back to authentication,
• or switching between two completely separate UI shells.

In these cases, a push animation can be semantically wrong because there is no meaningful "back" relationship.

How to create the destination controller

You can still instantiate the new controller from a storyboard if needed:

1let storyboard = UIStoryboard(name: "Main", bundle: nil)
2let home = storyboard.instantiateViewController(withIdentifier: "HomeViewController")
3
4if let scene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
5   let window = scene.windows.first {
6    crossfadeRoot(window: window, to: home)
7}

The important point is not how the controller is created. The important point is that the transition occurs by replacing the window root, not by pushing or presenting.

Why not manually move random controller views around

Developers sometimes try to animate between controllers by removing one controller's view and adding another controller's view directly to the hierarchy. That usually leads to lifecycle problems because the view controller containment rules are no longer being respected.

If you truly need both controllers alive at once, use a proper custom container. But if you only need a full-screen replacement, swapping the root controller is usually cleaner.

Common Pitfalls

The most common mistake is using root-controller replacement for screens that really should support back navigation. If the user expects to return to the previous screen, a navigation controller is the better tool.

Another issue is forgetting to keep a valid UIWindow reference. In multi-scene apps, code that assumes a single global window may fail or update the wrong scene.

Be careful with app state too. Replacing the root controller resets the visible hierarchy, so any temporary state stored in the old flow disappears unless you pass it explicitly.

Finally, do not animate controller views manually without understanding containment. If two controllers are both active in the hierarchy, use proper child view controller APIs instead of raw subview swapping.

Summary

• If the transition is a full UI handoff, replacing the window rootViewController is a strong option.
• 'UIView.transition gives a simple animated root swap without navigation or modal presentation.'
• Snapshot-based animation allows more custom visual effects.
• This technique fits login, onboarding, and app-shell transitions better than stack navigation.
• If both controllers must coexist, use a real container controller instead of ad hoc view swapping.