From UIKit to SwiftUI

Developers have a new tool, SwiftUI, to create user interfaces that are far more user-friendly and cutting-edge than those created using UIKit. For developers who have put a lot of time and effort into understanding and using UIKit, the switch to SwiftUI might not be as simple. In some circumstances, you might also want to recycle previously created UIKit code or interface elements.

Luckily, SwiftUI’s interaction with UIKit offers a solution for these situations. This post will examine how to combine UIKit with SwiftUI, the advantages of doing so, and any potential drawbacks.

What is UIKit?

For the purpose of creating graphical user interfaces (GUIs) on Apple platforms, the UIKit framework offers a selection of user interface elements and tools. With the initial release of the iOS SDK, it has served as the main framework for creating iOS and iPadOS apps.

### What is SwiftUI?

A new framework called SwiftUI was released in 2019 and offers a declarative syntax for creating user interfaces for Apple systems. Using SwiftUI, you can describe the layout and behavior of your user interface in a way that is far more intuitive and natural than with UIKit, which takes a programmatic approach to creating user interfaces.

SwiftUI in UIKit integration

Using a UIHostingController to enclose a SwiftUI view inside a UIKit view is how SwiftUI is integrated with UIKit. A UIViewController subclass called a UIHostingController provides the framework required to embed a SwiftUI view inside a UIKit view hierarchy.

You must first create a SwiftUI view that you want to embed inside your UIKit view hierarchy in order to use a UIHostingController. Create a struct for this view that follows the View protocol. Once you’ve created your SwiftUI view, you can use it as a UIHostingController’s root view.

Here’s an example of how a UIHostingController may be used to incorporate a SwiftUI view into a UIKit view hierarchy:

import UIKit
import SwiftUI

class ViewController: UIViewController {

    override func viewDidLoad() {

        let hostingController = UIHostingController(rootView: MySwiftUIView())
        hostingController.didMove(toParent: self)

struct MySwiftUIView: View {
    var body: some View {
        Text("Hello, World!")

Advantages of SwiftUI into UIKit integration

SwiftUI views integration into UIKit views has some advantages:

  • Better user interface. SwiftUI views have a contemporary and unified design that can improve the aesthetics and usability of your project.
  • Faster development. SwiftUI views can be created more quickly and easily than UIKit views, especially for straightforward user interfaces. You can save time and money by doing this.
  • Declarative syntax. SwiftUI employs a declarative syntax, which allows you to specify how you want your interface to appear while leaving the implementation details to the framework.
  • Automatic view updating. SwiftUI refreshes your views automatically as the underlying data changes, cutting down on the amount of code you need to write.

Disadvantages of SwiftUI into UIKit integration

SwiftUI views integration into UIKit views has also some disadvantages:

  • Compatibility. Because some UIKit views are incompatible with SwiftUI, your options may be constrained and their integration may necessitate writing bespoke code.
  • Added complexity. If you need to manage several view hierarchies, integrating SwiftUI and UIKit views can make your program more difficult.
  • Maintenance burden. Because you must maintain both the SwiftUI and UIKit code, integrating SwiftUI and UIKit views might increase the maintenance burden of your app.

UIKit in SwiftUI integration

In order to use a UIKit view inside SwiftUI you need to use the UIViewRepresentable protocol. This allows you to use a UIView subclass in your SwiftUI views:

import SwiftUI

struct MyUIViewWrapper: UIViewRepresentable {
    func makeUIView(context: Context) -> MyUIView {
        return MyUIView()
    func updateUIView(_ uiView: MyUIView, context: Context) {
        // Update the view here

class MyUIView: UIView {
    // Implement your UIView subclass here

struct MySwiftUIView: View {
    var body: some View {

In this example, we create a UIViewRepresentable struct, MyUIViewWrapper, which conforms to the UIViewRepresentable protocol. Then we then implement the makeUIView(context:) method, which creates and returns an instance of our wrapped MyUIView. We also implement the updateUIView(_:context:) method, which allows us to update the wrapped MyUIView based on changes to the SwiftUI view or its environment. Finally, we can use our MyUIViewWrapper in SwiftUI views just like any other SwiftUI view.

Advantages of UIKit into SwiftUI integration

Integrating UIKit into SwiftUI has a number of advantages:

  • Reusing existing UIKit code. If you wish to reuse existing UIKit code, you may use a UIHostingController to embed it inside a SwiftUI view hierarchy. This enables you to continue using your current UIKit code while making the switch to SwiftUI gradually.

  • Improved performance. As SwiftUI is intended to be more performant than UIKit, your app’s performance may be improved by embedding UIKit views within a SwiftUI view hierarchy.

  • Better code maintainability. Compared to UIKit’s programmatic approach, SwiftUI’s declarative syntax is simpler to comprehend and maintain in your code.

Disadvantages of UIKit and SwiftUI Integration

Despite the advantages, it’s important to be aware of a few restrictions when integrating UIKit with SwiftUI:

  • Compatibility. Not every UIKit component can be integrated into a SwiftUI view hierarchy. UITableView and UICollectionView, for instance, are not supported at the moment.

  • Increased complexity. Combining UIKit with SwiftUI can make your code more complex, especially if you’re switching from a codebase that only uses UIKit.

  • Maintenance costs. Keeping up with two different codebases for UIKit and SwiftUI can be time-consuming and raise your app’s maintenance costs.


In conclusion, integrating UIKit and SwiftUI views can offer a range of benefits for app development. Combining these frameworks can provide developers with more flexibility, allowing them to use the best tools for specific tasks while still maintaining a cohesive user interface.