SwiftUI vs UIKit stopped being an either-or decision for working iOS codebases years ago. A screen built this quarter is probably SwiftUI. A screen that predates SwiftUI, or needs a level of control SwiftUI still won't hand over cleanly, is probably UIKit. Xcode 27, which bundles Swift 6.4 and SDKs for iOS 27, changes a few specifics on both sides of that split, starting with how you preview a SwiftUI view in the first place.
SwiftUI vs UIKit: the core difference
SwiftUI describes a screen as a function of state: you write what the interface should look like for a given set of data, and the framework re-renders whatever changed when that data changes. UIKit works the other way around. You write the steps: create the label, set its text, add it to the view, update it again when the data changes. Apple's own documentation captures the boundary between the two cleanly. A UIHostingController exists so a team can "integrate SwiftUI views into a UIKit view hierarchy," and that phrasing gives away the model: SwiftUI views form their own hierarchy, separate from UIKit's, and the two only meet at specific bridging points.
That split isn't unique to Apple's ecosystem. Jetpack Compose does the same thing for Android, and Flutter and React Native run versions of it across platforms. For a team deciding on a UI paradigm at a strategic level rather than for one iOS screen, how SwiftUI compares to Jetpack Compose and Flutter covers that ground.
When SwiftUI is the right call
Default to SwiftUI for anything built new. A form, a settings screen, a list backed by an API response, a card layout that needs to adapt to three device sizes: SwiftUI handles all of it with less code than the UIKit equivalent, and the preview updates as you type instead of requiring a full build-and-run cycle.
It's also the better choice when the same screen needs to run on more than one Apple platform. A SwiftUI view built for iPhone carries most of its logic over to iPad, Mac, and visionOS with far less platform-specific rewriting than a UIKit view controller needs. If the product roadmap includes a Mac or Vision Pro version of the same feature, building it in SwiftUI first avoids a second UI layer later.
When UIKit still wins
UIKit still wins on anything that needs exact, frame-by-frame control: a custom transition between two screens, a collection view with a bespoke layout that doesn't map to SwiftUI's built-in containers, or gesture handling that has to interrupt and resume mid-animation. SwiftUI's layout system is opinionated, and fighting it usually costs more time than dropping into UIKit for that one screen.
That opinionated layout system is also why interop has a hard edge. Apple's layout guidance for UIViewRepresentable states plainly that "SwiftUI fully controls the layout of the UIKit view's center, bounds, frame, and transform properties," and warns against setting those properties directly on a wrapped view because it produces undefined behavior. Any UIKit view a team wraps for use inside SwiftUI has to give up manual control over its own position and size. For a view that leans on that kind of manual layout code, wrapping costs more than it saves. Rewriting it as native SwiftUI, or keeping it UIKit-native behind a UIHostingController boundary, is usually the safer call.
How to mix SwiftUI and UIKit in one app
Migrating a codebase from UIKit to SwiftUI, or adding a new SwiftUI screen inside an established UIKit app, doesn't require a rewrite. Apple built two bridging APIs for exactly that.
Embedding SwiftUI in a UIKit app with UIHostingController
UIHostingController is the bridge in the UIKit-to-SwiftUI direction. Apple's documentation for UIHostingController describes its purpose directly: create one "when you want to integrate SwiftUI views into a UIKit view hierarchy." It behaves like a regular UIViewController from UIKit's point of view, so it pushes onto a navigation stack, presents modally, or embeds inside a container view controller the same way any other view controller does. Apple lists it as available from iOS 13.0, iPadOS 13.0, Mac Catalyst 13.0, tvOS 13.0, and visionOS 1.0 onward, which lines up with SwiftUI's own minimum platform support.
Embedding UIKit in a SwiftUI app with UIViewRepresentable
UIViewRepresentable runs the bridge the other way. Apple's UIViewRepresentable reference defines it as "a wrapper for a UIKit view that you use to integrate that view into your SwiftUI view hierarchy," available from the same iOS 13.0 floor as UIHostingController. A team reaches for it when a screen is otherwise SwiftUI but needs one component, a map view, a camera preview, a legacy chart library, that only exists in UIKit.
The layout constraint covered earlier applies here directly: once a UIKit view is wrapped, its frame belongs to SwiftUI. Building the wrapper's makeUIView and updateUIView methods to pass data in one direction, from SwiftUI state into the UIKit view, keeps the two systems from fighting over which one owns the view's position.
What changed for this decision in Xcode 27 and Swift 6.4
Xcode 27 shipped in September 2026 and changes two things that touch this decision directly. First, Apple's Xcode 27 release notes confirm the toolchain now bundles Swift 6.4 and SDKs for iOS 27, iPadOS 27, tvOS 27, watchOS 27, macOS 27, and visionOS 27, and it needs a Mac running macOS Tahoe 26.6 or later to install. Second, and more relevant to a team writing SwiftUI day to day, the same release notes list PreviewProvider and its family of preview modifiers as deprecated. A codebase still using the old preview protocol instead of the #Preview macro now has a real migration item, not just a style preference.
Xcode 27 also carries Swift 6.4's new default build system, which affects both frameworks equally since it's a Swift Package Manager change rather than a UI-framework one, but any team weighing tooling risk should read it before treating this upgrade as routine. For the CI-specific fallout beyond SwiftUI, the fuller Xcode 27 breakdown for build and deployment teams covers what else broke.
SwiftUI vs UIKit at a glance
| Framework | Paradigm | Minimum iOS version | Best for |
|---|---|---|---|
| SwiftUI | Declarative | iOS 13.0+ | New screens, data-driven UI, cross-Apple-platform reuse |
| UIKit | Imperative | Every iOS version | Custom animations, bespoke layouts, fine-grained control |
What to test for when you hire for this decision
Asking a candidate to explain SwiftUI vs UIKit in the abstract gets a textbook answer. Asking them to walk through a specific screen, an infinite-scrolling feed with custom cell animations, say, and defend where they'd draw the SwiftUI/UIKit boundary and why, gets a much better read on their judgment. The strongest answers name the interop APIs, UIHostingController and UIViewRepresentable, without prompting, and can explain why the layout-ownership issue matters in practice rather than just that it exists.
HighCircl's engineer-led vetting runs every candidate through four stages: background and experience verification, a communication and product-thinking assessment, a take-home project built to mirror real work, and a live technical session on architectural reasoning. That last stage is where a SwiftUI/UIKit tradeoff question actually separates candidates, because it forces a specific decision under scrutiny instead of a rehearsed answer. Roughly one in ten applicants makes it through the full process, and the talent pool spans Poland, Hungary, Slovakia, Serbia, Slovenia, Romania, and Spain, with senior engineers running €45-105/hr ($50-115/hr).
If the roster gap this decision exposes needs filling faster than an internal search allows, the deeper walkthrough on vetting Swift 6 concurrency and architecture judgment goes further into the interview questions worth asking, and HighCircl can put a vetted senior iOS engineer in front of a team within 72 hours.
Frequently asked questions
Can I use SwiftUI and UIKit in the same app?
Yes. UIHostingController embeds SwiftUI views inside a UIKit hierarchy, and UIViewRepresentable wraps UIKit views for use inside a SwiftUI hierarchy. Both are supported from iOS 13.0 onward, so there's no minimum-version reason to avoid mixing them in a codebase that already targets iOS 13 or later.
Does Apple recommend SwiftUI over UIKit for new projects?
Apple hasn't published a rule that says every new project has to start in SwiftUI. Its tooling investment leans that direction, though: Xcode 27 deprecated PreviewProvider and its family of preview modifiers in favor of the #Preview macro, which also previews UIKit views and view controllers, so the change is a tooling cleanup more than a push away from UIKit.
What iOS version do I need to support to use SwiftUI?
iOS 13.0 or later, per Apple's own minimum-version listings for the interop APIs covered above. A codebase still supporting iOS 12 or earlier can't adopt SwiftUI until that floor moves up.
Is UIKit deprecated?
No. Nothing in Apple's current release notes or framework documentation marks UIKit as deprecated. SwiftUI itself depends on UIKit for interop through UIViewRepresentable and UIHostingController, which would be an odd position for Apple to take with a framework it planned to retire.