When learning iOS development, we often think of navigation as a simple line. You push View A, then View B, then View C. To go back, you pop them off. This mental model works most of the time, until it doesn’t.

I encountered an issue where I needed to navigate backward from the currently presented view to a very specific view controller deeper in the app’s history. I knew for a fact that the target view existed. I had passed through it just moments before. Yet, every time my code tried to locate it within the navigation stack, it returned nil.

The problem? I was thinking in one dimension when iOS navigation is actually two-dimensional.

The Horizontal Trap

When we learn UIKit, we start with UINavigationController. It manages a stack of view controllers, literally an array called viewControllers.

When you perform a push segue, you are appending a new view to the end of that horizontal array.

The mental model looks like this:

[Root VC] -> pushed -> [List VC] -> pushed -> [Detail VC] (Current View)

If you are sitting on the Detail VC and you want to check if the List VC is behind you, it’s easy. You just iterate through the current navigation controller’s array.

This was the logic I was using, and it failed. Why? Because I wasn’t just pushing views, I was using modal presentations.

The Vertical Reality

The moment you call .present(_:animated:), you are no longer moving horizontally. You are creating a new layer on top of the current context.

If you present a new UINavigationController modally, you have essentially created an entirely new, isolated horizontal stack sitting above the old one.

The actual hierarchy looks like this:

[ Root View Controller ]  ← The foundation
      |
      +-- [ Tab Bar Controller ]
               |
               +-- [ Nav Stack A ] → [ List VC ] → [ Detail VC ]
               |                                        |
               +-- [ Nav Stack B ]                      | (presents modally)
                                                        ↓
                                                 [ Modal Nav Stack ]  ← ISOLATED
                                                        |
                                                 [ Current View ]

My issue was that my code was running inside the Current View. When I asked it to search its navigation stack, it only looked left and right along the top layer. It had no idea the bottom layer existed. It was structurally blind to the views beneath it.

Why Standard Stack Searches Fail

When we use UINavigationController, we work with a viewControllers array, a simple stack. Pushing a new view adds it to this array.

// This only searches the current horizontal stack
if let targetVC = navigationController?.viewControllers.first(where: { $0 is TargetViewController }) {
    navigationController?.popToViewController(targetVC, animated: true)
}

This code works perfectly if your target view is in the same navigation stack. But what if you’ve presented a modal?

The moment you call .present(), you create a new layer on top of your current view. This presented view controller might have its own UINavigationController, creating a completely separate horizontal stack.

If you only check the current navigationController?.viewControllers array, you’re blind to anything above or below your current modal layer. You’re searching left and right when you need to look up and down.

[ Root View Controller ]  ← The foundation
      |
      +-- [ Tab Bar Controller ]
               |
               +-- [ Nav Stack A ] → [ List VC ] → [ Detail VC ]
               |                                        |
               +-- [ Nav Stack B ]                      | (presents modally)
                                                        ↓
                                                 [ Modal Nav Stack ]  ← ISOLATED
                                                        |
                                                 [ Current View ]

Implementation: Depth-First Hierarchy Traversal

To find a view controller anywhere in your app’s hierarchy, we need to search like we’re navigating a tree, not a list. We need to check:

  1. Is the current view controller our target?
  2. Does it contain child stacks (Navigation or Tab Bar controllers)?
  3. Most importantly: Has it presented another view vertically?

Here’s a robust extension that does exactly this:

import UIKit

extension UIViewController {
    /**
     Recursively searches the entire view hierarchy to find a
     view controller of a specific type.
     
     - Parameter type: The class type of the view controller to find.
     - Returns: The found view controller, or nil if not found.
     */
    func findInHierarchy<T: UIViewController>(type: T.Type) -> T? {
        // 1. Check if current controller is what we're looking for
        if let target = self as? T {
            return target
        }
        
        // 2. Search horizontal stack (Navigation Controller)
        if let nav = self as? UINavigationController {
            // Check from top to bottom for efficiency
            for vc in nav.viewControllers.reversed() {
                if let found = vc.findInHierarchy(type: type) {
                    return found
                }
            }
        }
        
        // 3. Search tabs (Tab Bar Controller)
        if let tab = self as? UITabBarController,
           let selected = tab.selectedViewController {
            if let found = selected.findInHierarchy(type: type) {
                return found
            }
        }
        
        // 4. Search vertical stack (presented modals) - CRUCIAL
        if let presented = self.presentedViewController {
            if let found = presented.findInHierarchy(type: type) {
                return found
            }
        }
        
        return nil
    }
}

Starting Point: Root vs Current View Controller

You might wonder: “Why not search from the current view controller?”

The answer is simple: the current view is a leaf node. It only knows who presented it, but it can’t see sideways into other tabs or navigation branches.

Starting from the root view controller gives you:

  1. Complete coverage: You scan every branch—all tabs, all navigation stacks, all modals
  2. No dead ends: If you’re in a modal on Tab 2 but your target is in Tab 1, searching from your current position will never find it
  3. Consistency: The search works the same way regardless of where the user currently is

Back Navigation: Dismissing and Popping to Target

Finding a view controller is only half the battle. Actually navigating back to it requires careful cleanup:

  1. Dismiss vertical layers: Remove any modals presented on top of your target
  2. Pop horizontal stack: Remove any views pushed after your target

Here’s a helper function that handles both:

extension UIViewController {
    /**
     Navigates back to a specific view controller by cleaning up
     modals and navigation stacks.
     
     - Parameters:
       - targetType: The type of view controller to return to.
       - animated: Whether to animate the transition.
     */
    func backToView<T: UIViewController>(to targetType: T.Type, animated: Bool = true) {
        // 1. Find the target starting from the root
        guard let root = UIApplication.shared.windows.first(where: { $0.isKeyWindow })?.rootViewController,
              let targetVC = root.findInHierarchy(type: targetType) else {
            print("Error: \(targetType) not found in hierarchy")
            return
        }
        
        // 2. Dismiss everything presented above the target
        if targetVC.presentedViewController != nil {
            targetVC.dismiss(animated: animated, completion: nil)
        }
        
        // 3. Pop navigation stack to reveal the target
        if let nav = targetVC.navigationController {
            nav.popToViewController(targetVC, animated: animated)
        }
        
        // 4. Switch tabs if necessary
        if let tabBar = targetVC.tabBarController,
           let index = tabBar.viewControllers?.firstIndex(where: { 
               $0 == targetVC || $0.children.contains(targetVC) 
           }) {
            tabBar.selectedIndex = index
        }
    }
}

Usage Example

Now you can navigate back from anywhere with a single, clean call:

// Deep inside a modal workflow, return to home
self.backToView(to: HomeViewController.self)

// Or from a button action
@objc func handleBackToHome() {
    self.backToView(to: HomeViewController.self, animated: true)
}

App Demo

https://youtube.com/embed/JgFXwbFHpaM?si=HJdxyHR_wCaUdOnC

Real-World Scenario

Imagine you’re building an e-commerce app. The user starts on the home screen, navigates to a product list, opens product details, then presents a modal login flow (which has its own navigation stack). After logging in, you want to return them to the product details.

// From anywhere in the login flow:
self.backToView(to: ProductDetailViewController.self)

This single line will:

  • Find the ProductDetailViewController in the hierarchy
  • Dismiss the login modal
  • Pop any views pushed after the product detail
  • Switch tabs if needed

Summary

  1. iOS navigation is 2D: Horizontal pushing/popping and vertical presenting/dismissing
  2. Search from the root: Start at rootViewController to see the entire hierarchy
  3. Use recursion: Check the current view, its children, and its presented views
  4. Clean up properly: Dismiss modals before popping navigation stacks

The next time you can’t find a view controller, remember: you’re not looking at a line, you’re looking at a tree. Search accordingly.