The core idea

An AirPlay-connected Apple TV shows up to your app as an external UIScreen. Once you notice one connected, you create a second UIWindow scoped to that screen and hand it its own SwiftUI view hierarchy. Your original window keeps running as the controller UI. Two completely independent view trees, sharing only whatever state you choose to pipe between them.

Detecting the external display

import UIKit
import Combine

final class ExternalDisplayObserver: ObservableObject {
    @Published var externalScreen: UIScreen?

    private var cancellables = Set<AnyCancellable>()

    init() {
        externalScreen = UIScreen.screens.first { $0 != UIScreen.main }

        NotificationCenter.default.publisher(for: UIScreen.didConnectNotification)
            .compactMap { $0.object as? UIScreen }
            .sink { [weak self] screen in self?.externalScreen = screen }
            .store(in: &cancellables)

        NotificationCenter.default.publisher(for: UIScreen.didDisconnectNotification)
            .sink { [weak self] _ in self?.externalScreen = nil }
            .store(in: &cancellables)
    }
}

That's the whole detection layer. No AVKit, no route picker parsing — just watching for a screen that isn't the main one.

Standing up the second window

This is the part that trips people up, because UIWindowScene in a SwiftUI-lifecycle app doesn't hand you a second scene automatically just because a screen connected. You create the window yourself and attach it to the connected screen directly:

final class ExternalWindowController {
    private var externalWindow: UIWindow?

    func present<Content: View>(_ content: Content, on screen: UIScreen) {
        let window = UIWindow(frame: screen.bounds)
        window.screen = screen
        window.rootViewController = UIHostingController(rootView: content)
        window.isHidden = false
        externalWindow = window
    }

    func dismiss() {
        externalWindow?.isHidden = true
        externalWindow = nil
    }
}

Wire it to the observer above: when externalScreen goes non-nil, call present; when it goes nil, call dismiss. The TV-facing view and the phone-facing view can now be two entirely different SwiftUI hierarchies driven by the same @StateObject game/session model, updating independently.

Things that actually matter once you ship this

Test on real hardware. The Simulator's AirPlay support is unreliable for external-screen connect/disconnect notifications. You will chase phantom bugs if you trust it. Keep a real Apple TV on your desk.

Design for viewing distance, not touch distance. The TV window is read from six to ten feet away by multiple people at once. Font sizes and contrast that look fine on a phone preview look thin and grey on a television. Oversize everything on the external view relative to your instinct.

Handle disconnection as a first-class state, not an edge case. People walk out of AirPlay range, TVs go to sleep, someone else's AirPlay request steals the route. Your controller view needs a real "TV disconnected" state that pauses or gracefully degrades the session, not a force-unwrap crash.

Don't put game logic in the window controller. Keep ExternalWindowController dumb — it only knows how to mount and unmount a view on a screen. All state belongs in an observable session object that both windows read from, so reconnecting the TV mid-session just reattaches the view instead of losing state.

That's the entire pattern. It scales from a simple scoreboard to a full dual-screen party game, and once it clicks, you start noticing how much SwiftUI UI could live on a second screen that almost nobody builds for.