
Key takeaways
• SwiftUI vs UIKit for video conferencing is rarely a pure-SwiftUI call. In 2026 the quickest way to ship is a hybrid: SwiftUI for chrome and controls, UIKit for the video canvas and renderers.
• SwiftUI costs roughly 13% more memory and 5–10% more CPU than UIKit on comparable video grids. You start to feel it past ~12 concurrent tiles or on older devices.
• The video surface must be UIKit-backed. AVSampleBufferDisplayLayer and Metal render on CALayers, and WebRTC’s renderer is a UIView subclass, so you wrap them in UIViewRepresentable and give each tile a stable identity so SwiftUI does not re-create it.
• State-loop bugs kill more video apps than framerate does. Never store frame buffers in @State. Use @Observable (iOS 17+) with scoped reads, and batch updates with Combine.
• Fora Soft has shipped 250+ real-time video products. Book a scoping call on SwiftUI vs UIKit for your app and we’ll send a decision matrix within 48 hours of that first 30-minute call.
Updated November 2026: Apple’s App Store build rules for call apps (iOS 13 minimum target since September 2026, iOS 27 SDK and iOS 15 minimum from April 2027), plus a short answer on SwiftUI vs UIKit performance.
Why Fora Soft wrote this playbook
We’ve built real-time video products on iOS since the first WebRTC builds reached the platform, and our WebRTC development engineers still own the media layer on every iOS call app we ship. Since 2005, more than 20 years, our video conferencing app development team has shipped 250+ real-time video and streaming products. They range from 1:1 calling apps like Speakk to classroom platforms with thousands of concurrent tiles like BrainCert, and from social video networks like ChillChat to cloud meeting rooms like ProVideoMeeting. When SwiftUI arrived in 2019 we adopted it fast and learned the hard way where it shines, where it breaks under real-time load, and where UIKit still earns its keep.
This playbook is what we would tell a founder, CTO or engineering lead on a 30-minute call. We are not pitching SwiftUI as the future. It is a decision guide built on apps that survived production: real devices, real networks, real budgets, and users who will not put up with a frozen tile during a sales call or a healthcare consultation. Every recommendation comes with numbers, the SDKs we use day to day, and the mistakes we made so you can skip them.
If you want a second opinion on your framework choice or a scoped estimate for your video app, our Agent Engineering workflow turns a 30-minute call into a numbered plan within days. Book a slot below and bring your hardest edge case.
Stuck picking SwiftUI or UIKit for your video app?
Share your target device, participant count, and ship date. We’ll map them to a hybrid architecture and a realistic timeline.
The verdict — what actually ships video calls in 2026
The short answer: every serious iOS video conferencing app we have seen in production in 2026 is either UIKit-only or a SwiftUI/UIKit hybrid. Pure SwiftUI calling apps exist as prototypes, internal tools and 1:1 demos. None of them serve thousands of concurrent tiles at stable frame rates. Even the SDKs that now lead with SwiftUI keep a UIKit view under the video. LiveKit’s Swift SDK offers SwiftUIVideoView, yet its documentation describes VideoView as a UIKit-based class that must be used on the main thread (checked November 2026).
The reason is architectural. Video rendering on iOS happens on AVSampleBufferDisplayLayer, Metal layers, or WebRTC’s RTCMTLVideoView, and all of them are UIKit surfaces: a CALayer hosted in a UIView, or a UIView subclass. SwiftUI exposes them through UIViewRepresentable, and every such bridge is a seam that can re-create the renderer, drop frames or fight SwiftUI’s diffing engine. In a chat app nobody notices the seam. In a 20-tile classroom it separates a $0 refund from a churned enterprise customer.
SwiftUI is still the right choice for the 70% of the UI that is not live video: chat, participant lists, settings, onboarding, CallKit-adjacent flows and pre-join screens. Our rule of thumb is SwiftUI outside the meeting and UIKit (or UIKit-wrapped) inside it. You stay fast, and the meetings stay smooth.
Reach for a SwiftUI/UIKit hybrid when: you need to ship fast, your meeting surfaces have 2–24 concurrent video tiles, and your team is comfortable writing at least one UIViewRepresentable wrapper around the video renderer.

Figure 1. SwiftUI owns the ~70% of the call screen that isn’t live video; UIKit owns the ~30% that is.
Where SwiftUI fits and where it breaks
SwiftUI earns its reputation everywhere outside high-frequency pixel work. Onboarding, login, dashboards, chat lists, participant panes, settings, device pickers, captions, reactions and the end-of-call rating screen all benefit: SwiftUI’s declarative syntax cuts development time there by 30–40% and turns previews into an everyday tool. @Observable (iOS 17), SF Symbols, built-in dark mode and Dynamic Type pay off in the first week.
SwiftUI breaks under video load on the high-frequency update path. Put per-frame or per-participant bitmap data in @State and you trigger cascading diff passes until the main thread saturates. Give an UIViewRepresentable an unstable identity (inline in an index-keyed ForEach, or an .id() that changes each pass) and your renderer gets torn down and rebuilt, so users see flicker, black frames or audio-only fallbacks. With a stable identity SwiftUI reuses the view and only calls updateUIView, so most flicker traces back to destructive work inside updateUIView, such as re-attaching the track. We have debugged these bugs on shipped apps. They never show up in the first week of a project; they surface three months in, once the participant count crosses 8 or 12.
The second failure mode is platform features SwiftUI has not caught up with. AVPictureInPictureController, custom orientation locking, CallKit custom UI, and telling a pinch-to-zoom on a tile apart from a swipe-to-dismiss on the parent all still need a UIKit escape hatch. SwiftUI closes some of this every year, but a production video app will still touch UIKit for at least one of them.
Where SwiftUI earns its keep
1. The app chrome. Navigation stacks, tab bars, modal sheets and toolbar buttons become one-liners. NavigationSplitView and NavigationStack handle iPad and Mac Catalyst layouts without separate storyboards.
2. Chat and participant lists. Lists with ForEach over a participant model stay clean, fast and diff well. Drag-to-reorder, swipe actions, search and pull-to-refresh come free.
3. Reactions, overlays, and annotations. Animated overlays on a video tile, emoji reactions, hand-raise badges and name pills are where SwiftUI’s .animation and matchedGeometryEffect shine.
4. Previews and design reviews. With #Preview macros your designer can click through a call state machine without building and running the app. On a team of five that alone saves a week per quarter.
5. Accessibility. VoiceOver, Dynamic Type and reduced motion work out of the box. UIKit needs extra code for each of them.
Where SwiftUI breaks under video load
1. State loops on the video path. Storing CVPixelBuffer or CMSampleBuffer in @State triggers a full-body re-render on every frame. Even a 15 fps tile can saturate the main thread. Keep frames out of SwiftUI entirely: the video layer renders itself and SwiftUI only owns the layout.
2. UIViewRepresentable re-creation. A change in a tile’s identity (a re-render alone does not do it) can re-invoke makeUIView and tear down the underlying layer. Stable identity (.id(participant.id)), equatable models and keeping the representable off the parent’s state-reading path prevent it.
3. LazyVGrid with many tiles. Past ~20 participants, a LazyVGrid creates and destroys tiles lazily as they scroll, so live video stops and starts at the scroll edges. A UICollectionView with prefetching handles this better.
4. Gesture conflicts. Pinch-to-zoom on a tile, drag-to-dismiss and tap-to-focus: SwiftUI gesture modifiers collide with the UIKit gesture recognizers inside your renderer. Coordinators and simultaneousGesture solve most cases, though each one costs a debugging session.
5. Orientation control on a single screen. Locking one screen to horizontal while the rest of the app stays portrait still needs a UIHostingController subclass and overrides, because pure SwiftUI has no clean API for it. Since iOS 27 (released September 14, 2026) Apple treats supported orientations as a preference the system ignores when the app runs in a resizable environment, so the lock is no longer guaranteed anyway.
Reach for pure SwiftUI when: you show 1–2 tiles, your minimum target is iOS 17 or newer, you lean on an SDK’s drop-in renderer, and you need no Picture-in-Picture, CallKit, or per-screen orientation lock.
Where UIKit still wins on video surfaces
UIKit has a decade more maturity than SwiftUI, and you see it most clearly inside a call. Every commercial video SDK (LiveKit, Agora, Twilio, Zoom, Daily, 100ms, Vonage) ships its renderer as a UIView. Every Apple framework on the video path is UIKit-first: AVFoundation, VideoToolbox, Metal, AVKit and CallKit’s provider UI. When something breaks in a meeting, the Stack Overflow answers, WWDC samples and engineering blogs you end up reading are UIKit too.
Performance is the second reason. In our own tests, UIKit uses roughly 13% less memory and 5–10% less CPU than SwiftUI on comparable participant grids. Independent re-tests look at tighter budgets: Jacob’s Tech Tavern compared SwiftUI and UIKit on iOS 26 in March 2026 against a 120 fps target, which leaves just 8.33 ms per frame. iOS 26 narrowed the gap. Apple said at WWDC25 that SwiftUI now schedules UI updates better on iOS and macOS, that lists of 100,000+ items load 6x faster and update up to 16x faster on macOS, and it added a SwiftUI performance instrument to Xcode. UIKit still wins on large, live video grids. On a 1:1 call nobody can see the difference. In a 12-person classroom on an iPhone 12, it decides between a steady 30 fps and thermal throttling down to 15 fps after 20 minutes. On older devices (iPhone X, iPad mini 5) the gap widens to 20% or more.
UIKit also gives you direct, predictable lifecycles. viewDidLoad, viewWillAppear and viewDidDisappear are exact hooks to start or stop the camera, attach the remote renderer, or release the MTKView. SwiftUI’s .onAppear and .task come close, but in corner cases (tab switches, modal dismissals, backgrounding) they fire unpredictably, and you end up chasing duplicate tracks or abandoned sessions.
Reach for UIKit when: you are rendering live video at 24+ fps, your meeting needs to support 12+ concurrent tiles on an iPhone 13 or older, or you are integrating directly with AVCaptureSession, Metal, or WebRTC’s low-level video API.
The hybrid pattern most shipped apps actually use
Most professional iOS teams shipping video products in 2026 use a version of the same pattern. The app frame is SwiftUI, the call screen is a SwiftUI container, and the video tiles are UIKit renderers wrapped in UIViewRepresentable. State flows through an @Observable call model shared by both layers. You get SwiftUI’s development speed on 70% of the surface and UIKit’s stability on the 30% users care about most.
We give every team the same three-layer split. Layer one is a pure Swift domain model of the call (room, local participant, remote participants, tracks, media state) with no UIKit or SwiftUI imports. Layer two is an @Observable facade that the UI reads. Layer three is the UI, where SwiftUI owns layout and UIKit owns the pixels. A framework-free domain model can be unit-tested, reused on macOS via Catalyst, and kept when you swap the UI stack later because Apple changed direction.
Keep the UIViewRepresentable around your video renderer minimal. Create the view once, set the participant ID via updateUIView, never re-instantiate the Metal layer, and use EquatableView or an explicit .id() so SwiftUI does not tear it down. Put the representable in a LazyVGrid only while your participant count stays below ~20; above that, use UICollectionView.
// Minimal, safe UIViewRepresentable for a WebRTC tile
struct VideoTile: UIViewRepresentable, Equatable {
let participantID: String
func makeUIView(context: Context) -> RTCMTLVideoView {
let view = RTCMTLVideoView()
view.videoContentMode = .scaleAspectFill
return view
}
func updateUIView(_ view: RTCMTLVideoView, context: Context) {
// Attach track only once per participant; CallModel owns the cache
CallModel.shared.attach(participantID: participantID, to: view)
}
// With .equatable() at the call site, an unchanged participant skips updateUIView
static func == (lhs: VideoTile, rhs: VideoTile) -> Bool {
lhs.participantID == rhs.participantID
}
}

Figure 2. The three-layer hybrid: a framework-free call model, an @Observable facade, and a UI layer where SwiftUI lays out and UIKit renders.
SwiftUI vs UIKit performance: benchmarks side by side
Short answer: UIKit is faster than SwiftUI for video calls once the grid grows. In our 2026 measurements a pure SwiftUI grid used roughly 13% more memory and 5–10% more CPU than UIKit, and on a 12-tile call on an iPhone 12 it dropped to 18–24 fps while UIKit held 28–30 fps. A hybrid with UIKit tiles in a SwiftUI shell stays within measurement noise of pure UIKit, and on a 1:1 call the SwiftUI vs UIKit performance difference is imperceptible.
The numbers below combine published benchmarks with our internal measurements on 4-, 12- and 24-tile participant grids running a WebRTC SFU on iPhone 12, 14 Pro and 15 Pro. Absolute values depend on tile resolution and codec, so read them as relative deltas. The direction holds across all of them: SwiftUI is cheap enough for chrome and small meetings, noticeable at mid-scale, and a liability at large scale without UIKit escape hatches.
How we measured. These are Fora Soft internal numbers: Xcode 26 Instruments (Time Profiler plus Animation Hitches) over 20-minute sessions, 360p tiles on a LiveKit SFU, on iPhone 12, 14 Pro and 15 Pro running iOS 26. We cross-checked the direction against published iOS 26 benchmarks. Absolute values move with tile resolution and codec, so read the columns as relative deltas rather than lab-grade constants.
| Scenario | Metric | Pure UIKit | Hybrid | Pure SwiftUI |
|---|---|---|---|---|
| 4 tiles, iPhone 14 Pro | Sustained FPS | 30 | 30 | 29–30 |
| 4 tiles, iPhone 14 Pro | Peak memory | ~92 MB | ~105 MB | ~140 MB |
| 12 tiles, iPhone 12 | Sustained FPS | 28–30 | 26–30 | 18–24 (throttles) |
| 12 tiles, iPhone 12 | CPU at 20 min | 38% | 42% | 58% |
| 24 tiles, iPhone 15 Pro | Sustained FPS | 30 | 30 | 22–27 (jitter) |
| 24 tiles, iPhone 15 Pro | Peak memory | ~240 MB | ~260 MB | ~340 MB |
| Chat & chrome only | Dev velocity | Baseline | +30% | +35–40% |

Figure 3. A 12-tile call on an iPhone 12: pure SwiftUI trails on sustained FPS and burns more CPU by the 20-minute mark.
Two patterns stand out. First, the hybrid sits within measurement noise of pure UIKit on sustained FPS, because the SwiftUI overhead lives mostly in startup and diff passes rather than in the video hot path. Second, pure SwiftUI at scale is slow because its default patterns (state-held frames, re-created representables) work against you. A disciplined pure-SwiftUI app with careful @Observable scoping can close most of the gap, but by then you have re-invented the UIKit patterns, and the hybrid is the honest answer.
For iOS performance tuning beyond framework choice, read our companion guide on how to optimize iOS apps for speed and stability. It covers Instruments workflows, memory leaks and launch-time tuning, and all of them compound with the framework choice.
Feature-by-feature comparison matrix
Once the benchmark numbers are clear, most decisions come down to capability gaps: which framework gives you the feature you need today without a workaround. The matrix below is the cheat sheet we hand new hires before their first video-app project.
| Capability | SwiftUI native | Needs UIKit bridge | UIKit effort (days) |
|---|---|---|---|
| Camera preview | No | AVCaptureVideoPreviewLayer | 0.5–1 |
| WebRTC remote tile | No | RTCMTLVideoView | 1–2 |
| Picture-in-Picture | No | AVPictureInPictureController + delegate | 3–5 |
| CallKit incoming UI | No | CXProvider + PushKit | 3–7 |
| Per-screen orientation lock | No | UIHostingController override (a preference only in iOS 27 resizable modes) | 1 |
| 20+ tile scrollable grid | LazyVGrid (flaky at scale) | UICollectionView recommended | 2–4 |
| Animated overlays on tile | Yes | — | 0 |
| Dynamic Type & VoiceOver | Yes (default) | — | 0 |
| Metal-based filters/LUTs | No | MTKView + CIContext | 3–8 |
Scan the right column and the pattern is plain. Almost every video-specific capability needs a UIKit bridge, and almost every non-video capability is free in SwiftUI. That is the case for the hybrid: the shape of the platform’s APIs in 2026, with taste and futureproofing playing no part.
Need a second opinion on your SwiftUI call screen?
We benchmark participant grids, trace state loops, and ship hybrid refactors. Most audits identify the main drop-frame cause inside one call.
State management for live participant grids
In a SwiftUI video app, how you shape state is the biggest single decision for both performance and correctness. A bad model feeds a loop: one participant property changes, SwiftUI re-diffs the whole grid, every UIViewRepresentable re-invokes updateUIView, the video pauses for a beat, and the user blames your app. With the right model the same grid holds 30 fps across a 60-minute session.
On iOS 17 and later we strongly recommend the @Observable macro over ObservableObject/@Published. @Observable tracks reads per property inside each view body, so a toolbar that only reads isMuted does not re-render when activeSpeakerID changes. For targets below iOS 17, get a similar effect with several small ObservableObject classes, one per concern.
One WWDC26 change removes a classic call-screen bug. In “What’s new in SwiftUI” (WWDC26) Apple made @State lazily initialize @Observable classes, so @State private var call = CallViewModel() is now created once for the lifetime of the view instead of on every parent re-init, and the change is back-deployed to iOS 17. Before, each throwaway instance could open its own session or subscription. We still keep the media session in a service, but a view-owned call model is no longer a trap.
Three rules that keep grids smooth
1. Never store frame data in SwiftUI state. The video renderer owns its pixel buffer. SwiftUI owns only the tile’s size, position and participant identity.
2. Scope state to the smallest unit that changes. A ParticipantViewModel per tile that is itself @Observable beats a single CallModel publishing the whole roster on every event.
3. Batch high-frequency events. Active-speaker updates, audio-level meters and network-quality badges fire many times per second. Debounce them with Combine (.throttle(for: .milliseconds(250), scheduler: RunLoop.main, latest: true)) or an AsyncSequence with a sampling operator before they reach the view model.
Wiring AVFoundation, Metal, and WebRTC into SwiftUI
Three rendering pipelines cover 95% of iOS video apps. All of them are UIKit-native, and each has a safe way to expose it to SwiftUI.
AVCaptureVideoPreviewLayer (local camera preview). Wrap a UIView whose layer class is AVCaptureVideoPreviewLayer, inject the session through the initializer, and set videoGravity = .resizeAspectFill. Never store the session in @State. Keep it in a singleton or a view model with explicit start and stop.
AVSampleBufferDisplayLayer (custom decoded frames). When you decode frames yourself, for Metal-based filtering or HDR tone mapping for example, use AVSampleBufferDisplayLayer.enqueue(_:). It is also the preferred API for custom WebRTC renderers. Expose it via UIViewRepresentable.
RTCMTLVideoView / LiveKit VideoView (SFU pipeline). Every serious WebRTC SDK in 2026 ships an MTKView-backed renderer. Wrap it, and cache attachments per participant ID so SwiftUI redraws do not detach and re-attach the track. That one cache explains most of the “flickering tile” bug reports we have debugged.
AVPlayerLayer (VOD playback inside a call). Replays, watch-party mode and webinars often need a prerecorded stream next to live video. VideoPlayer (SwiftUI native) works, but for adaptive bitrate controls or custom overlays, fall back to AVPlayerLayer via a representable.
A safe camera preview snippet
final class PreviewView: UIView {
override class var layerClass: AnyClass { AVCaptureVideoPreviewLayer.self }
var previewLayer: AVCaptureVideoPreviewLayer {
layer as! AVCaptureVideoPreviewLayer
}
}
struct CameraPreview: UIViewRepresentable {
let session: AVCaptureSession // owned by a view model, never recreated
func makeUIView(context: Context) -> PreviewView {
let v = PreviewView()
v.previewLayer.session = session
v.previewLayer.videoGravity = .resizeAspectFill
return v
}
func updateUIView(_ view: PreviewView, context: Context) {}
}
SwiftUI video call components: what each SDK ships in 2026
Short answer: SwiftUI video call components are prebuilt SwiftUI views for a call screen: the participant tile, the grid layout, call controls and the incoming-call screen. Stream and LiveKit ship them for iOS in 2026. The tile still draws video through a UIKit or Metal view underneath, so the SwiftUI vs UIKit rules in this playbook apply to them as well.
The table compares what the three SDKs we meet most often on iOS projects ship today, re-checked against their documentation and release pages on November 20, 2026.
| SDK | SwiftUI video call components | What renders the video | Requirements and status (November 2026) |
|---|---|---|---|
| LiveKit Swift SDK + components-swift | SwiftUIVideoView, SwiftUI components library |
UIKit-based VideoView (main thread only) |
iOS 13+; SDK 2.17.0 (September 2026, still the latest release in November 2026) |
| Stream Video iOS | CallContainer, VideoCallParticipantView, ParticipantsGridLayout, CallControls, IncomingCall |
SwiftUI-first; the UIKit CallViewController wraps the SwiftUI views |
Swift Package Manager only: CocoaPods and XCFrameworks were dropped in 1.50.0 |
| Twilio Video iOS | No SwiftUI component library | UIKit video view you wrap in UIViewRepresentable yourself |
Kept alive: Twilio reversed its planned December 2026 end-of-life in October 2024; SDK 5.11.3 (April 2026), iOS 12.2+ |
How we use them: a component library is the right start for an MVP or an internal tool, since CallContainer or a LiveKit room view puts a working call on screen in a day. For a branded product we keep the SDK’s tile and renderer, replace the layout and controls with our own SwiftUI views, and move the grid to a UICollectionView once calls pass about 20 tiles. If you have already picked LiveKit, our LiveKit development team builds custom iOS rooms on its Swift SDK. For the full build path from SDK choice to App Store, read how to build a SwiftUI video chat app end to end.
PiP, CallKit, and orientation — the tricky platform bits
Three platform features pull UIKit into even a mostly-SwiftUI app. We name them because almost every founder we meet assumes SwiftUI covers them in 2026, and it does not.
Picture-in-Picture. AVPictureInPictureController requires a delegate and a source layer, and both are UIKit. Wrap your video surface in a coordinator and expose PiP controls to SwiftUI through a view model. Without PiP, users who jump to messages or the calendar mid-call lose the video, and retention of mobile meeting products drops sharply.
CallKit. The incoming-call UI and lock-screen handling go through CXProvider and CXCallController, which is system UI driven by a UIKit delegate. SwiftUI handles the screen after the user answers, but the answer and decline events still arrive in UIKit. Add PushKit for VoIP pushes and you have a UIKit subsystem that stays in your app for good.
Per-screen orientation. Locking one screen (the call) to horizontal while the rest of the app stays portrait still requires a UIHostingController subclass that overrides supportedInterfaceOrientations. SwiftUI still has no first-class way to do it. iOS 27 weakens the trick: per Apple’s WWDC26 “Modernize your UIKit app” session, supported orientations are now a preference the system ignores in resizable environments (an iPhone app on iPad, or iPhone Mirroring on the Mac, which always runs in portrait). Design the call screen to adapt to any size first and treat the horizontal lock as a hint.
External camera and Continuity Camera. If your app supports Continuity Camera on iPadOS and macOS, or external USB cameras, AVCaptureDevice.DiscoverySession and the device-change notifications follow UIKit/AppKit conventions. Handle them in a service layer and keep them out of SwiftUI.
iOS 27 resizability and the scene lifecycle. iOS 27 shipped on September 14, 2026 and made iPhone apps resizable. The same WWDC26 session says the UIScene lifecycle is now required when building with the latest SDKs (an app without a UISceneDelegate will no longer launch). It also asks you to read the screen from window?.windowScene?.screen and size classes instead of the main screen, idiom or orientation. Older call apps that set up CallKit and the call window in AppDelegate need this migration most. SwiftUI apps get most of it for free, while hybrid apps have to check every UIKit view controller on the call path. The migration also has a deadline: starting April 2027, iOS apps uploaded to App Store Connect must be built with the iOS 27 SDK (Apple Developer news, September 9, 2026), so a call app without a scene delegate cannot ship an update after that date.
A 20-tile participant grid — reference architecture
This is the architecture we deploy when a client needs a conferencing screen that holds 20+ tiles without thermal throttling on iPhone 13-class hardware. It comes from roughly a dozen production shipments in education, telehealth and enterprise meetings.
Container. A SwiftUI view owns the layout and the controls: layout toggle (grid or speaker), reactions, mute, leave. It reads a single @Observable CallViewModel, and only the properties it displays.
Grid. Below 20 active tiles, a LazyVGrid with a stable .id(participant.id) on each tile. At 20 or more, a UICollectionView inside a UIViewControllerRepresentable, with prefetching and diffable data sources. At that scale UIKit’s cell recycling behaves more predictably than SwiftUI’s lazy stack.
Tile. Each tile is VideoTile(participantID:), an Equatable UIViewRepresentable. The service layer pools the underlying MTKView and reuses it across participants, so nothing is allocated per frame.
Overlays. Name pill, mute badge, active-speaker ring and reactions are pure SwiftUI, layered on the tile in a ZStack. Each reads its own small model scoped to one participant.
Subscriptions. The call model subscribes only to the top N active tracks (usually N=9 in speaker view, N=20 in grid) and tells the SFU which simulcast layers to deliver. That is how a 200-participant classroom runs at 30 fps: the user sees 20 tiles at most, the SFU sends only those streams, and the device never decodes more than it displays. We unpack the same simulcast trick in our video streaming guide.
Thermal and energy control. Hook ProcessInfo.thermalState into the call model. When thermal state reaches .serious or .critical, drop non-speaker tiles to audio-only and lower the simulcast layer to 180p. Users would rather see fewer faces than watch the phone shut down.
Reach for a UICollectionView grid when: you routinely show 20+ live tiles, need smooth scroll with track prefetching, or watch a LazyVGrid drop frames at the scroll edges on your minimum device.
Mini case — what we learned shipping ChillChat and Speakk
ChillChat is a social video network where strangers meet in themed rooms of up to 8 participants. We built every non-meeting surface of the iOS app in SwiftUI (onboarding, rooms directory, profiles, moderation tools) and put the live tiles behind a UIKit renderer. Careful @Observable scoping and a per-tile .id() got us 30 fps on iPhone 11 and above, and SwiftUI previews plus declarative lists took roughly 4 weeks off the schedule.
Speakk is a WhatsApp-style messenger with 1:1 and small-group video calling. Its calling surface is simpler, one or two tiles, so we pushed SwiftUI further and kept only the camera preview and remote renderer in UIKit. Chat features moved faster, but we still needed CallKit, PushKit and PiP, and all three are UIKit. The lesson: “mostly SwiftUI” still means you own three UIKit subsystems.
In both products the decision that mattered most was a single CallController service owning AVFoundation, WebRTC tracks and the renderer lifecycle. The UI layer, SwiftUI or UIKit, only asked for “a view for participant X” and never touched media directly. That boundary made both apps testable, let us swap the video SDK (Twilio to LiveKit on one of them) without rewriting the UI, and kept bug reports out of SwiftUI’s state graph.
If you want a similar architecture review for your app, a 30-minute scoping call usually surfaces the top two risks in your current stack and the smallest refactor that would stabilize your call screen.
Decision framework — pick your stack in five questions
Answer these five questions in order. Each one either confirms your instinct or moves you toward a different split.

Figure 4. Five questions that sort your app into SwiftUI-heavy, hybrid, or UIKit-heavy.
Q1. How many concurrent video tiles do you need on-screen? 1–2 tiles: SwiftUI-heavy is fine. 3–12 tiles: hybrid. 12+ tiles or scrollable grids: UIKit-heavy, or a UICollectionView inside a representable.
Q2. What is your minimum supported device? iPhone 13 and later: any choice works. iPhone 11/12 or iPad mini 5: hybrid or UIKit. iPhone 8/X with iOS 16: UIKit is the safe default. Apple counted 79% of all active iPhones on iOS 26 in June 2026, so most new call apps can set iOS 17 as the minimum and use @Observable from day one.
Q3. Do you need PiP, CallKit, or per-screen orientation? Any one of them brings UIKit into your codebase. Plan a UIKit hosting layer on day one instead of retrofitting it.
Q4. What is your time to first launch? 8 weeks or less: a hybrid with SwiftUI-heavy chrome wins on speed. 16+ weeks: pick the split with the lowest long-term maintenance, which is often UIKit-heavy on the meeting screen.
Q5. How experienced is your iOS team with Metal, AVFoundation, and WebRTC? If the answer is “low,” stay with an SDK that gives you a drop-in renderer (LiveKit, Daily, 100ms) and use SwiftUI only for the chrome. If you are rolling your own video pipeline, the UIKit side grows fast. For the end-to-end build path, SDK components versus raw WebRTC step by step, see our SwiftUI video chat app guide.
Pitfalls to avoid
1. Storing frames in @State. A single @State var currentFrame: CVPixelBuffer? is enough to collapse performance on a 4-tile grid. Keep frames outside SwiftUI, every time.
2. Letting a tile’s identity change. If a tile’s identity changes each pass (defined inline in an index-keyed ForEach, or given an unstable .id()), you get a new makeUIView call every time. Lift the struct out, make it Equatable, and attach .id(participant.id).
3. LazyVGrid inside ScrollView without stable IDs. When the user scrolls, tiles are destroyed and rebuilt and the video restarts. Attach stable identities and prefetch the next row of tracks before the user gets there.
4. Shipping without Instruments profiles. Without a before-and-after Time Profiler trace of a 10-minute call, your next release will carry a performance regression. Apple’s WWDC25 Optimize SwiftUI performance with Instruments session is worth 60 minutes of your time, along with the SwiftUI Instrument it introduced, which shows view-body and representable updates.
5. Ignoring thermal and energy state. A call that overheats the phone within 10 minutes fails enterprise pilots and drags down App Store ratings. Listen to ProcessInfo.thermalState and isLowPowerModeEnabled, and degrade gracefully.
KPIs to measure after launch
1. Quality KPIs. Median received video FPS per tile (target: ≥ 24 on iPhone 11 and later), audio MOS score (target: ≥ 4.0), freeze count per 30-minute call (target: < 2), and time-to-first-frame after join (target: < 1.5 seconds).
2. Business KPIs. Call completion rate (target: > 95%), pre-join drop-off (target: < 10%), 1-week retention for users who held at least one call (target: > 40%), and average call duration. Your product team watches these numbers, and engineering choices eventually show up in them.
3. Reliability KPIs. Crash-free users (target: > 99.5%), main-thread hang rate (target: < 0.5% of sessions), and p95 memory usage on a 30-minute 8-tile call (target: < 300 MB on iPhone 12). Build these dashboards in the same week you ship the first meeting screen.
When to NOT pick SwiftUI
There are three cases where we still push clients toward UIKit-only in 2026. First, if you must support iOS 12 or earlier, SwiftUI is not available. That case now exists only in in-house builds for MDM-locked enterprise fleets: since September 9, 2026 Apple requires every app uploaded to App Store Connect to target iOS 13 or later, and from April 2027 the floor rises to iOS 15 (Apple, upcoming requirements). Second, if your app is a niche broadcasting tool with heavy Metal pipelines (AR filters, virtual backgrounds, overlay compositing, LUTs), the whole rendering stack is UIKit-native, so SwiftUI buys you almost nothing and adds a seam to debug.
Third, if your team has ten years of UIKit experience, no SwiftUI experience and a 12-week timeline to a critical launch, the learning curve is not worth the risk. SwiftUI is forgiving for list-driven apps and harsh on video apps with a deadline. We have watched experienced UIKit teams lose three weeks to a single state-loop bug. Move to the hybrid after launch.
Cost and timeline implications
Framework choice moves your timeline more than most founders expect. On the chrome (the 70% of screens outside the meeting) SwiftUI saves roughly 30–40% of development time versus UIKit. On the meeting screen you usually give some of that back while fighting state and representable issues. On a greenfield iOS calling app the net is a 15–20% velocity gain with a disciplined hybrid, and break-even or worse if the team tries pure SwiftUI for the meeting. Our video chat app development team plans iOS calling apps on that hybrid from the first sprint.
Maintenance costs diverge later. UIKit-only apps are easier to debug when a call breaks, because forum answers are written for UIKit. SwiftUI apps are cheaper to evolve for product work such as new chat layouts, reactions and onboarding tweaks. The hybrid is not the cheapest on any single dimension, but over a 24-month product horizon it carries the least risk.
Because we pair Agent Engineering with our iOS team, Fora Soft estimates usually come in faster and cheaper than traditional vendors on the chrome and roughly in line on the meeting engine, where physics still sets the pace. For a realistic range on your scope, share your target participant count, minimum device and ship date on a call, and we will send a numbered estimate.
Want a numbered estimate for your video app?
Tell us your device target, participant count, and ship date. We’ll send back a scoped plan within 48 hours of the call.
FAQ
Can SwiftUI alone handle enterprise video conferencing with 20+ participants?
Technically yes, in practice no. At 20+ tiles SwiftUI’s diffing and LazyVGrid recycling fight the video pipeline, so shipped enterprise apps put the grid behind a UICollectionView for predictability. The standard pattern is a UIKit canvas inside a SwiftUI shell.
Is UIKit faster than SwiftUI for video calls?
Yes, on large grids. In our 2026 tests UIKit used about 13% less memory and 5–10% less CPU than SwiftUI on the same participant grid, while on a 1:1 call the difference was imperceptible. A hybrid with UIKit tiles in a SwiftUI shell stays within measurement noise of pure UIKit on frame rate.
Does iOS 27 change the SwiftUI vs UIKit choice for video calls?
The verdict stays, but the call screen changes. iOS 27 (September 14, 2026) makes iPhone apps resizable and treats supported orientations as a preference, so a call screen forced to horizontal must also work at any size. UIKit apps also need the UIScene lifecycle when built with the latest SDK. SwiftUI layouts handle resizing with less work.
Do Apple’s 2027 App Store rules change the SwiftUI vs UIKit decision?
They remove the old-iOS argument for UIKit-only apps. From April 2027 apps uploaded to App Store Connect must be built with the iOS 27 SDK and target iOS 15 or later, which also makes the UIScene lifecycle mandatory for UIKit call screens. The video tile still belongs in UIKit, so the hybrid verdict stays the same.
Is SwiftUI compatible with older iOS versions for video conferencing?
SwiftUI ships on iOS 13+, but the features that matter for video apps (@Observable, modern navigation, improved layout performance) require iOS 17 or later. Since September 9, 2026 App Store uploads must target iOS 13 or later anyway, and from April 2027 they must target iOS 15 or later, so UIKit-only for old iOS now matters for in-house enterprise builds only. Apple reported in June 2026 that 86% of iPhones introduced in the last four years ran iOS 26, so an iOS 17 minimum excludes few active users.
How does SwiftUI compare to UIKit in battery consumption during calls?
In our measurements SwiftUI used 8–15% more battery than UIKit during 30-minute calls with 4+ tiles, because of the extra diff passes and view re-renders. On a 1:1 call the difference is negligible. On a 12-person call it can mean 10–15 fewer minutes of call time per charge, which enterprise users who live on calls will notice.
Do I need to write my own renderer, or can an SDK handle it?
Unless your product is a specialised broadcasting tool, use an SDK. LiveKit, Daily, 100ms, Twilio, Agora and Vonage all ship optimised UIKit renderers. You wrap them in UIViewRepresentable and spend engineering time on the product instead of the video plumbing. We cover SDK trade-offs in depth in our Agora.io alternative guide.
What is the learning curve for UIKit developers switching to SwiftUI?
Two to four weeks for basic fluency on lists and forms. Eight to twelve weeks before a developer knows by instinct when to use @State, @Observable or Binding on performance-sensitive surfaces. The bridging layer (UIViewRepresentable, coordinators) adds another four to six weeks. Budget a full quarter before a team ships production-grade video in SwiftUI.
Are there pre-built UI components for video conferencing in SwiftUI?
Yes. Stream Video iOS ships CallContainer, VideoCallParticipantView, ParticipantsGridLayout and CallControls, and LiveKit ships SwiftUIVideoView plus a SwiftUI components library (as of November 2026). They are a good starting point for an MVP. A branded product will still customise them heavily, but the default UI saves roughly two to three weeks of boilerplate.
How do I handle Picture-in-Picture with SwiftUI?
Wrap AVPictureInPictureController in a coordinator attached to the same UIViewRepresentable as your video renderer, and control PiP state from SwiftUI through an @Observable model. iOS 27 still has no native SwiftUI PiP API (released September 2026; WWDC26’s “What’s new in SwiftUI” announced none), and trying to force PiP without UIKit causes most “PiP does not start” bug reports.
Should I migrate an existing UIKit video app to SwiftUI?
Rarely as a full rewrite. Almost always it is a gradual migration of chrome and settings that leaves the meeting screen alone. A full rewrite of a mature UIKit calling app takes 6–12 months and usually ships with a performance regression. A hybrid migration keeps the stable parts and speeds up the parts that need it.
What to Read Next
iOS Architecture
The 2026 iOS MVVM-C Playbook
SwiftUI @Observable, coordinators, DI and Swift 6 concurrency — the architecture layer behind every hybrid video app.
Swift 6
Swift 6 iOS Development — Next-Gen Video Chat
Strict concurrency, data-race safety, and how the new Swift model fits video chat apps built on SwiftUI or UIKit.
WebRTC Stack
Agora.io Alternative in 2026
Custom WebRTC with LiveKit, mediasoup, Jitsi and Janus — what to pair with your SwiftUI/UIKit front-end.
Performance
How to Optimize iOS Apps for Speed and Stability
Instruments workflows, launch time, memory leaks — the KPIs that compound with framework choice on video apps.
Dependency Management
Swift Package Manager for Video Apps
How to keep LiveKit, WebRTC, Starscream and analytics SDKs reproducible and binary-cached — a 2025 developer’s guide.
Ready to ship a video app that actually scales?
SwiftUI vs UIKit is an architecture question. Ship the chrome in SwiftUI, ship the meeting canvas in UIKit behind a thin representable, and let a disciplined @Observable model connect them. That split gives you 30–40% velocity on most of the app and keeps the live video, the part users judge you on, smooth, predictable and portable across SDKs.
At Fora Soft we have used this pattern across 250+ shipped products, from social video like ChillChat to enterprise learning like BrainCert. If you want a scoped plan for your app (participant count, minimum device, ship date, honest trade-offs), bring your hardest edge case to a 30-minute call. Agent Engineering turns that call into a numbered estimate.
The book · Volume 3 of 7
Video Streaming: A Complete Guide to Video Delivery: From ABR and CDNs to Players, WebRTC, DRM, and the Economics of Streaming
SwiftUI or UIKit decides how the call screen is built; what keeps twenty tiles smooth is the WebRTC layer under it. Our delivery volume covers WebRTC and real-time media, SFU topologies, simulcast and adaptive bitrate, player behaviour under bad networks and QoE monitoring, the parts that decide whether your iOS call holds up when the network drops. Written by Nikolay Sapunov, CEO at Fora Soft.
Read it on Amazon →Kindle & paperback · Fora Soft Video Engineering Handbook
Bring your hardest video-app question to a 30-min call
Share your device target, participant count, and ship date. We’ll send back a hybrid architecture sketch and a scoped estimate.