Is SwiftUI backwards-compatible with iOS 12.x and older?

Question

If I have an app made with SwiftUI, will it work for iOS below iOS 13?

Cesaro

Folks does anyone know that why my answer deleted by @Jean-François Fabre – Scraperboard

NO, SwiftUI will not work with iOS 12.x & older. – Typal

Answer 1

I just checked it out in Xcode 11 and can confirm it won't be backwards-compatible, as can be seen in SwiftUI's View implementation:

/// A piece of user interface.
///
/// You create custom views by declaring types that conform to the `View`
/// protocol. Implement the required `body` property to provide the content
/// and behavior for your custom view.
@available(iOS 13.0, OSX 10.15, tvOS 13.0, watchOS 6.0, *)
public protocol View : _View {

    /// The type of view representing the body of this view.
    ///
    /// When you create a custom view, Swift infers this type from your
    /// implementation of the required `body` property.
    associatedtype Body : View

    /// Declares the content and behavior of this view.
    var body: Self.Body { get }
}

Blowhole

At least another 5 years? So you only use APIs available in iOS 7 and below at the moment? – Schach

The weirdest thing is that you can make a SwiftUI application with xcode 11 on Mojave (10.4) that will only run on Catalina (10.5) – Weave

Answer 2

SwiftUI and Combine use Opaque-Return-Types in Swift 5.1 and since Opaque-Return-Types (alongside other features) are implemented in Swift 5.1 and due to the nature of their implementation, they can not be back deployed to Swift 5.0(unlike DSL or Property-Wrappers), and because iOS 13 is the earliest iOS SDK that contains Swift 5.1 runtime in the OS, so the answer to the question is no and SwiftUI and Combine can not be used on earlier versions of iOS.

Unless, Apple provides a way to bundle Swift 5.1 runtime (or future releases) with the application like it used to do with earlier Swift versions, but since it will increase App-size and add overhead to the whole system again, I doubt this will ever happen.

It might be backward compatible

Swift 5.1 is not released yet and SwiftUI uses features such as opaque return types, DSL, propertyDelegate(introduced in WWDC as propertyWrapper) and etc, which will be available only in Swift 5.1. Since Swift 5 is binary stable, I guess it was not possible to use embedded swift-frameworks inside Xcode11, hence they’ve re-implemented these features in Cocoa’s core and marked them as iOS13+ available until Swift 5.1 gets released.

My assumptions are based on the fact that, Ordered Collection Diffing and DSL are going to be available in Swift 5.1 and have no correlations with Xcode or Apple’s eco-system, but they’re also marked as @available(iOS13,...). This means that they had to mark everything using Swift 5.1 features with the iOS availability attribute. Some of them will get removed once Swift 5.1 gets released, but we can’t be sure about SwiftUI and Combine unless Apple tells otherwise. This is also mentioned in DSL’s proposal:

Implementation: PR. Note that the implementation in the Xcode developer preview uses a somewhat simpler transformation than that described here. The linked PR reflects the implementation in the preview but is under active development to match this proposal.

So backward incompatibility limitation might be lifted when Swift 5.1 gets released, but it really needs to be clarified by Apple team.

Catalyst

Any update on this? PR you mentioned is merged, Swift 5.1 is released – Degust

@user158 I just updated the answer and described why this feature can not be supported. – Catalyst

Answer 3

I don't think so, because all libraries are already annotated for iOS 13 or higher.

Also, in the documentation, Apple clearly mentions the supported versions:

• iOS13.0+ beta
• macOS10.15+ beta
• tvOS 13.0+ beta
• watchOS 6.0+ beta

Bine

Answer 4

No. SwiftUI requires a deployment target of iOS 13 or later, macOS 10.15 or later, tvOS 13 or later, or watchOS 6 or later. The framework contains many new types that don’t exist on older versions of the OSs.

Wharf

It's possible to use SwiftUI on iOS 13 while supporting lower deployment target. Please check https://mcmap.net/q/151761/-how-to-incorporate-framework-swiftui – Nuisance

Answer 5

If you are shooting to support iPhone and not iPad you could probably expect most users will upgrade to iOS 13 within 12-18 months(starting with the release date). Maybe 85-90%? (I think Apple said at this point theres still 15% of people not on iOS 12) That’s still quite a while though to where you aren’t going to be able to deploy SwiftUI apps right away or else risk alienating a lot of users.

Also depending on what the other 10-15% is, that could mean a lot of users (and $$) for you left on the table.

If you are supporting iPad as well then its more tricky because people don't upgrade their iPads as often. Theres a lot of iPad 2s along with 3rd and 4th generation iPads still out in the wild, that only have 10.3.3 and cannot upgrade anymore. People just aren't going to go get up and go pay between $400 - $1,000 for a new iPad when theirs works perfectly fine.

There’s always room and a need for updating the app, making it better, fixing bugs, that don’t necessarily have anything to do with iOS 13. i.e. finding a bug you didn’t know about before that making a lot of users unhappy.. not on the latest iOS version. and we haven't even talking about enterprise / corporate customers that a lot of dev shops support. theres a lot of more pushback on iOS updates for various reasons in that area.

So before you get all excited about iOS 13 and SwiftUI (which you absolutely should because its awesome), back in the real world, outside of Silicon Valley, that's not exactly going to align with what the average consumer expects and you will need to support older devices and need to because theres just too many people you would be alienating.

Bulge

I know a number of people on "unsupported" iPhones, so you are never going to reach 100% for the latest iOS release. I know I will be thinking long and hard about my next phone when my current one dies – Malayalam

@Bulge While your assumptions maybe right they do not answer the question. – Der

iOS 12 did not drop support for over 10% of the devices so it's hard to say if we can expect the same adoption rates for iOS 13. – Solvolysis

SwiftUI will need to support older devices and need to because theres just too many people you would be alienating! thumb – Concrete

As of 2021, 90% of apple users are on 13+ – Hampson

Answer 6

It is compatible with iOS 13+. Here is link to its documentation.

https://developer.apple.com/documentation/swiftui/

---

Even Xcode 10 does not support it. You need to use Xcode 11 which is in beta as of (Jun 3 2019). https://developer.apple.com/tutorials/swiftui/creating-and-combining-views

Tintype

Answer 7

Based on Apple documentation it's available only starting with iOS 13, unfortunately.

https://developer.apple.com/documentation/swiftui/

Tetrastichous

All that linked documentation says is that you need to use iOS 13 SDK (i.e. Xcode 11). That does not mean the minimum supported iOS version of the device has to be iOS 13... you can support older iOS versions just fine... – Penick

Answer 8

only works for ios 13 or later

you can still attach your SwiftUI code by using

@available(iOS 13.0, *)

if you still using Xcode below Xcode 11 and have SwiftUI code, you can wrap it with

#if canImport(SwiftUI)
...
#endif

This can fix the issue when compiling with Xcode below Xcode 11

Treaty

Answer 9

As everyone has said, it will not be backwards compatible with older iOS versions. But given that Apple consistently have a high install base of their latest iOS, and also given that iOS 13 requires iPhone 6S or later, iPad Air 2 or later, the new iPad mini 4 and iPhone SE. The vast majority of users will be able to install iOS 13 and enjoy lovely SwiftUI apps.

Natashianatassia

My iPad doesnt make the cut for iOS 13, and given it is still going strong and isint going to be replaced for awhile (I hope) here hoping that the apps I enjoy/need dont cast older devices adrift. – Malayalam

Answer 10

Sadly no, SwiftUI is only allowed in iOS 13 and above. It was introduced in the iOS 13 framework. Before iOS 13, everything was built using Obj-C framework (Including Swift).

On the right side of the dev documentation, it shows the supported versions of iOS, macOS, tvOS, watchOS, etc.

https://developer.apple.com/documentation/swiftui/

Hope this helps!

Flexed

Answer 11

As all people before me mentioned, it's very clear that it will require iOS 13 or later. But as a new iOS developer, I was worried about to what extent I should adopt SwiftUI in comparison with UIKit. I already built some small projects with UIKit, and went somewhere advanced with it.

But as SwiftUI commenced, how to combine between them. The article in the following link puts all in context: https://www.hackingwithswift.com/quick-start/swiftui/answering-the-big-question-should-you-learn-swiftui-uikit-or-both

My only concern now is that I noticed with Xcode 11 that an Xcode project cannot combine both Storyboards and SwiftUI.

Western

Answer 12

Create two storyboards, one with UIKit, and the other using UIHostingController with SwiftUI.

Then use if #available() to check if the OS supports SwiftUI.

    // SwiftUI
    
    let storyboard_swiftUI = UIStoryboard(name: "Main-SwiftUI", bundle: nil)
    let controller_swiftUI = storyboard_swiftUI.instantiateViewController(withIdentifier: "ViewControllerSwiftUI")

    // UIKit
    
    let storyboard_UIKit = UIStoryboard(name: "Main-UIKit", bundle: nil)
    let controller_UIKit = storyboard_UIKit.instantiateViewController(withIdentifier: "ViewControllerUIKit")

    if #available(macCatalyst 14.0, iOS 14.0, *){

        // SwiftUI

        self.present(controller_swiftUI, animated: true)

    } else {
        
        // UIKit
        
        self.present(controller_UIKit, animated: true)

    }

Osmic