Using SwiftUI with UIKit

At a glance

Project structure

Source bundle/
├── UseSwiftUIWithUIKit/
│   ├── AppDelegate.swift
│   ├── Examples/
│   │   ├── SwiftUI in Cells/
│   │   │   ├── SwiftUI Views/
│   │   │   │   ├── HeartRateCellView.swift
│   │   │   │   ├── SleepCellView.swift
│   │   │   │   ├── HealthCategoryCellView.swift
│   │   │   │   └── StepCountCellView.swift
│   │   │   └── HostingConfigurationExample.swift
│   │   ├── Data Flow with SwiftUI Cells/
│   │   │   └── CellDataFlowExample.swift
│   │   └── SwiftUI View Controllers/
│   │       └── HostingControllerExample.swift
│   ├── MainMenuViewController.swift
│   └── SceneDelegate.swift
├── Configuration/
│   └── SampleCode.xcconfig
└── UseSwiftUIWithUIKit.xcodeproj/
    └── .xcodesamplecode.plist

Structure observations

• The menu is a small factory router; each example is its own composition root rather than one cross-example architecture.
• Controller embedding follows UIKit child-containment rules, while cell embedding uses content configuration with no child controller.
• The data-flow example separates collection identity updates from property updates on each ObservableObject.

Overall architecture

flowchart LR
    MENU["MainMenuViewController"] --> FACTORY["Private MenuItem factories"]
    FACTORY --> HOSTVC["HostingControllerViewController"]
    FACTORY --> HOSTCELL["HostingConfigurationViewController"]
    FACTORY --> FLOW["MedicalConditionsViewController"]
    HOSTVC --> UHC["UIHostingController child controllers"]
    HOSTCELL --> UICONFIG["UIHostingConfiguration cells"]
    FLOW --> STORE["Private DataStore"]
    STORE --> SNAPSHOT["Diffable IDs"]
    SNAPSHOT --> OBMODEL["MedicalCondition ObservableObject"]
    OBMODEL --> UICONFIG

Reference code

UseSwiftUIWithUIKit/MainMenuViewController.swift:11 — example factory registry

private struct MenuItem {
    var title: String
    var subtitle: String
    var viewControllerProvider: () -> UIViewController

    static let allExamples = [
        MenuItem(title: "SwiftUI View Controllers",
                 subtitle: "Using UIHostingController",
                 viewControllerProvider: { HostingControllerViewController() }),
        MenuItem(title: "SwiftUI in Cells",
                 subtitle: "Using UIHostingConfiguration",
                 viewControllerProvider: { HostingConfigurationViewController() })
    ]
}

Interpretation

The sample compares integration boundaries, not competing app architectures. A hosting controller adapts SwiftUI into the UIKit controller hierarchy; a hosting configuration adapts SwiftUI into cell content; observable objects allow the two frameworks to share state while the UIKit data store retains collection ownership.

Ownership and state

classDiagram
    MainMenuViewController *-- UICollectionView : private
    MenuItem *-- ViewControllerFactory : closure
    HostingControllerViewController *-- HeartHealthAlertArray : private models
    HostingControllerViewController *-- UIHostingControllerArray : private children
    MedicalConditionsViewController *-- DataStore : private
    MedicalConditionsViewController *-- UICollectionView : private
    MedicalConditionsViewController *-- DiffableDataSource : private
    DataStore *-- MedicalConditionArray : private
    MedicalConditionView o-- MedicalCondition : ObservedObject

Ownership evidence

UseSwiftUIWithUIKit/Examples/Data Flow with SwiftUI Cells/CellDataFlowExample.swift:140 — UIKit list and store ownership

class MedicalConditionsViewController: UIViewController {
    private var dataStore = DataStore()
    private var collectionView: UICollectionView!
    private var dataSource:
        UICollectionViewDiffableDataSource<Section, MedicalCondition.ID>!

    override func loadView() {
        setUpCollectionView()
        view = collectionView
    }
}

Composition denotes source-visible construction and retained value state. Aggregation denotes a stored or injected collaborator whose exclusive lifetime the source does not prove.

Class and protocol design

UseSwiftUIWithUIKit/Examples/SwiftUI View Controllers/HostingControllerExample.swift:136 — SwiftUI child-controller adapter

    private func createHostingControllers() {
        for alert in alerts {
            let alertView = HeartHealthAlertView(alert: alert)
            let hostingController = UIHostingController(rootView: alertView)
            hostingController.sizingOptions = .intrinsicContentSize
            hostingControllers.append(hostingController)
        }
    }

    private func setUpViews() {
        hostingControllers.forEach { addChild($0) }
        // Add each hosted view to the UIKit hierarchy.
        hostingControllers.forEach { $0.didMove(toParent: self) }
    }

View, ObservableObject, Identifiable, and UIKit data-source/delegate roles are framework contracts. The sample defines no local protocol abstraction; its reusable boundaries are adapters, observable models, and factory closures.

Access control

Reference code

UseSwiftUIWithUIKit/Examples/Data Flow with SwiftUI Cells/CellDataFlowExample.swift:19 — file-private actor-isolated model

@MainActor
private class MedicalCondition: Identifiable, ObservableObject {
    let id: UUID
    @Published var text: String
}

@MainActor
private class DataStore {
    private var data: (
        conditions: [MedicalCondition],
        conditionsByID: [MedicalCondition.ID: MedicalCondition]) = ([], [:])
}

Here, top-level private makes each example file a hard implementation boundary. @MainActor adds concurrency isolation but does not widen or narrow visibility. The sample exposes no public, open, or fileprivate surface.

Logic ownership and placement

Design patterns

Naming conventions

• Example entry controllers name the bridge (HostingController, HostingConfiguration, MedicalConditions).
• Private models use domain names (HeartHealthAlert, MedicalCondition, DataStore) rather than framework mechanics.
• Adapter/view names state content (HeartRateCellView, MedicalConditionView).
• One-file examples intentionally colocate private models, SwiftUI views, and their UIKit composition root.

Architecture takeaways

• Choose UIHostingController for controller containment and UIHostingConfiguration for cell content.
• Keep UIKit ownership of collection identity separate from observable mutation of one item’s properties.
• Use file-level private types to stop teaching-example details from becoming accidental module architecture.

Source map

• Official Apple documentation