skip to content

SwiftUI Bridging

UIHostingController puts SwiftUI inside UIKit, while UIViewRepresentable brings UIKit into SwiftUI. Every real migration lives on this boundary, so interviewers ask how state and updates cross it.

on this pageshow

explore

questions

6

In a UIKit app, how do you show a new SwiftUI checkout screen inside an existing UINavigationController, and how does data reach it?

level: juniorimportance: must knowfreq 78%

answer

  1. a view controller that owns SwiftUI
  2. init(rootView:)
  3. push it like any controller
  4. closures carry events back
  5. new tree, new environment

basics

~20 s

Wrap the SwiftUI view in a UIHostingController(rootView:) and push that controller like any other. Data goes in through the root view's initializer or the rootView property, and events come back through closures or a shared model.

solid answer

~40 s

SwiftUI views are not view controllers, so UIKit needs an adapter: `UIHostingController`, a `UIViewController` subclass that owns a SwiftUI hierarchy. You build the screen with its inputs, `UIHostingController(rootView: CheckoutView(total: cart.total, onPlaceOrder: { ... }))`, set its `title` and call `pushViewController(_:animated:)`; it can also be presented or embedded as a child view controller. Data flows in through the root view's initializer, and you can swap the whole view later by assigning `rootView`. Results flow out through closures you pass in, or through a shared observable model both sides hold. One thing does not travel: the hosted screen starts its own SwiftUI hierarchy, so environment values your other SwiftUI screens set are not there unless you add them to the root view.

code

swift · 27 lines
swift
import SwiftUI
import UIKit

struct CheckoutView: View {
    let total: Decimal
    let onPlaceOrder: () -> Void

    var body: some View {
        VStack(spacing: 16) {
            Text(total, format: .currency(code: "EUR"))
            Button("Place order", action: onPlaceOrder)
        }
    }
}

final class CartViewController: UIViewController {
    var cartTotal: Decimal = 42

    func showCheckout() {
        let checkout = CheckoutView(total: cartTotal) { [weak self] in
            self?.navigationController?.popToRootViewController(animated: true)
        }
        let host = UIHostingController(rootView: checkout)
        host.title = "Checkout"
        navigationController?.pushViewController(host, animated: true)
    }
}

go deeper

for a junior

Recall the type and its initializer: UIHostingController(rootView:) is a view controller, so you push, present or embed it exactly like one.

for a middle

Explain the two data directions: inputs through the root view or rootView assignment, outputs through closures or a shared observable model.

for a senior

Point out what the boundary drops, chiefly environment values set by other SwiftUI ancestors, and show how child containment keeps appearance and trait callbacks correct.

for a principal

Treat the hosting controller as the contract between a UIKit flow and a SwiftUI screen: decide which dependencies every hosted screen receives and where that wiring lives.

## Why UIKit needs an adapter A UIKit app is built from **view controllers**: `UINavigationController` pushes them, `present(_:animated:completion:)` shows them modally, and container controllers embed them as children. A SwiftUI screen is something else entirely, a `View` value that describes an interface and that SwiftUI renders and keeps up to date. UIKit has no idea how to push a `View`. The adapter is **`UIHostingController`**, available since iOS 13. Apple's documentation describes it as "a UIKit view controller that manages a SwiftUI view hierarchy". It is an ordinary `UIViewController` subclass, generic over the SwiftUI view it shows, so anything UIKit can do with a view controller it can do with a hosting controller: - **push** it with `pushViewController(_:animated:)`; - **present** it modally; - **embed** it as a child view controller inside a UIKit screen. The opposite direction, putting a UIKit view inside a SwiftUI screen, uses the representable protocols (`UIViewRepresentable`, `UIViewControllerRepresentable`). Mixing the two up is a common junior slip: a SwiftUI screen entering a UIKit app goes through a hosting controller (SwiftUI rows inside UIKit cells use `UIHostingConfiguration` instead). ## Pushing the checkout screen Suppose a long-lived UIKit shopping app wants a new checkout screen written in SwiftUI, shown from the existing cart screen inside the app's `UINavigationController`. 1. **Build the SwiftUI view with its inputs.** `CheckoutView(total: cartTotal, onPlaceOrder: { ... })`. The view's initializer is its API: it takes the data it shows and the callbacks it fires. 2. **Wrap it.** `let host = UIHostingController(rootView: checkout)`. The `rootView:` label is the one the initializer declares. 3. **Configure it as a view controller.** For example `host.title = "Checkout"`, which the navigation bar shows like any pushed controller's title. 4. **Push it.** `navigationController?.pushViewController(host, animated: true)`. From UIKit's point of view nothing else changes: the back button, the swipe-to-go-back gesture and the navigation bar behave as they do for every other screen, because the navigation controller is still the one managing the stack. ## How data crosses the boundary | Direction | Mechanism | When to use it | |---|---|---| | UIKit to SwiftUI, once | Root view initializer arguments | Data known when the screen opens, such as the cart total | | UIKit to SwiftUI, later | Assign a new value to `host.rootView` | You hold the controller and want to rebuild the root view with new inputs | | UIKit to SwiftUI, live | An observable model object both sides hold | Data that keeps changing while the screen is visible | | SwiftUI to UIKit | Closures passed in the initializer | Events: order placed, cancelled, address chosen | A few rules keep this clean: - **Prefer typed closures** for events. A closure such as `onPlaceOrder` makes the screen's outputs part of its signature and is easy to test. - **Capture the UIKit side weakly** in those closures (`[weak self]`), because the hosting controller keeps its root view, and the root view keeps the closure. - **Use a shared model for live data.** If the SwiftUI view reads properties of an `@Observable` class (iOS 17) or an `ObservableObject`, SwiftUI re-renders the parts that read a changed property; UIKit code only mutates the model. - **`rootView` is settable.** Assigning it replaces the root view value; SwiftUI then updates the hosted hierarchy to match the new value. ## What the hosted screen does not inherit A hosting controller **starts a new SwiftUI hierarchy**. SwiftUI's environment flows from ancestor views to descendants inside one hierarchy, and the cart screen is a UIKit view controller, not a SwiftUI ancestor. So: - Objects or values that other SwiftUI screens install with `environment(_:)`, `environment(_:_:)` or `environmentObject(_:)` are **not** present in the new hierarchy. Apple's documentation for `Environment` says that when a view reads an object by type and it is not in the environment, **SwiftUI throws an exception**, so the app crashes. Attach what the screen needs to its root view: `UIHostingController(rootView: CheckoutView(...).environment(cart))`. - Values SwiftUI derives from UIKit's **trait collection**, such as color scheme, Dynamic Type size, layout direction and size classes, do reach hosted content, because the hosting controller sits in UIKit's trait hierarchy. ## Embedding instead of pushing When the SwiftUI view is only part of a UIKit screen, embed the hosting controller as a **child view controller**: call `addChild(host)`, add `host.view` to your view hierarchy with constraints, then call `host.didMove(toParent: self)`. Containment keeps the controller in UIKit's view controller hierarchy, so it receives appearance callbacks and has a place to present from. How the embedded view reports its size to Auto Layout is a separate concern handled by the hosting controller's sizing options. ## What interviewers listen for - The type name and initializer: `UIHostingController(rootView:)`. - That it is pushed, presented or embedded like any view controller. - A clear answer for both data directions, with closures for events. - Awareness that the hosted screen gets a fresh environment and needs its dependencies attached.

  • The checkout screen reads a cart model with @Environment(Cart.self) and crashes when pushed from UIKit; why?
    A `UIHostingController` starts a new SwiftUI hierarchy, so objects other SwiftUI screens installed with `environment(_:)` are not in it. Reading a non-optional object by type that is missing makes SwiftUI raise an exception. Attach the object to the root view, `UIHostingController(rootView: CheckoutView().environment(cart))`, or read it as optional and handle `nil`.
  • How would you place the same SwiftUI view as one section of an existing UIKit screen instead of a whole pushed screen?
    Embed the hosting controller as a child: `addChild(host)`, add `host.view` to your hierarchy with constraints or to a stack view, then call `host.didMove(toParent: self)`. Containment puts the controller in UIKit's view controller hierarchy, so it receives appearance callbacks and has a place to present from; adding only `host.view` leaves the controller detached.
  • When the cart total changes while checkout is on screen, how does the hosted view see it?
    Either assign a new value to `host.rootView`, rebuilding the root view with the new total, or pass an observable model, an `@Observable` class from iOS 17 or an `ObservableObject` before that, which the SwiftUI view reads; SwiftUI then re-renders the parts that read the changed property without any UIKit code.

  • Pushing the SwiftUI view itself onto the navigation controller without a hosting controller.
  • Using UIViewRepresentable to put a SwiftUI screen into a UIKit app.
  • Expecting environment objects from other SwiftUI screens to appear inside a new hosting controller.
  • Adding the hosting controller's view as a subview without addChild and didMove(toParent:).
  • Capturing the presenting view controller strongly in the hosted view's callback closures.
open as a page

In SwiftUI, when do a UIViewRepresentable's makeUIView, updateUIView and dismantleUIView run, and how does a Coordinator act as the UIKit view's delegate?

level: middleimportance: must knowfreq 74%

basics

~20 s

makeUIView creates the UIKit view once per identity, updateUIView pushes current SwiftUI state into it whenever that state changes, and the static dismantleUIView cleans up on removal. A Coordinator, created first, is the long-lived object that serves as delegate.

open as a page

In UIKit, how does UIHostingConfiguration put a SwiftUI row inside a UICollectionView cell, and how should the row update when its data changes?

level: middleimportance: should knowfreq 48%

basics

~20 s

UIHostingConfiguration, iOS 16, is a UIContentConfiguration whose content is a SwiftUI view; you assign it to a cell's contentConfiguration. When data changes you reconfigure the item so a fresh configuration is built, or let an observed model update the row.

open as a page

A SwiftUI store-locator screen wraps MKMapView in a UIViewRepresentable with a region binding, and the map jitters and re-centres endlessly; what causes the loop and how do you fix it?

level: seniorimportance: should knowfreq 55%

basics

~20 s

updateUIView sets the map's region from the binding, the map reports its slightly adjusted region through the delegate, the coordinator writes it back, and SwiftUI calls updateUIView again. Break the cycle by skipping values the map itself just reported.

open as a page

In UIKit, a SwiftUI banner hosted in a UIHostingController inside a UIStackView keeps its first size after its text changes; why, and how do sizingOptions fix it?

level: seniorimportance: should knowfreq 50%

basics

~20 s

Auto Layout keeps using a view's intrinsic content size until the view invalidates it. Setting the hosting controller's sizingOptions to .intrinsicContentSize, iOS 16, makes its view invalidate that size when the SwiftUI content's ideal size changes.

open as a page

When bringing SwiftUI into a large UIKit shopping app, how do you choose between hosting whole screens and bridging components bottom-up, and who owns each boundary?

level: principalimportance: should knowfreq 40%

basics

~20 s

Host whole new screens in UIHostingController when a flow can stay UIKit-navigated, and bridge leaf components with UIHostingConfiguration or representables when screens are shared. Either way, one team owns each boundary type and its contract.

open as a page