By Maksym Fedoriaka | 26.10.2023

iOS 17 is here: What’s in store for developers?

Development – 9 min read

ios17 text with mobile phone illustration

Every year of WWDC brings us new iOS and Xcode versions, as well as new features and APIs to be excited about or be aware of. This year is no different—WWDC 2023 has brought us several intriguing novelties as well as improvements to existing components that make the day-to-day lives of us developers just a bit easier.

In this article, we’ve compiled a list of nine updates that our team thinks are the most notable and impactful, and accompanied them with our thoughts. Let’s get right to it.

Clean up your code with the new Observation framework

Swift 5.9 introduced macros, which make up the basis of the Observation framework. The new @Observable macro allows you to improve the ease and efficiency of your SwiftUI views. Now you can

  • track optionals and collections of objects, which isn’t possible when using ObservableObject;
  • use existing data flow primitives like State and Environment instead of object-based equivalents such as StateObject and EnvironmentObject;
  • and update views based on changes to the observable properties that a view’s body reads instead of any property changes that occur to an observable object, which can help improve your app’s performance.

Adopting the new framework is very easy. However, as with everything fresh and shiny from Apple, it’s available only for apps targeting just the latest iOS 17.

Our verdict: “The ease of use of the new Observation framework is something every SwiftUI developer has been dreaming about. Our team remains a bit skeptical about the performance claims, but only time will tell.”

Subtle but important updates to UIKit

With the new #Preview macro, you can create previews for programmatically created UIKit views and view controllers.

A new view controller callback method viewIsAppearing(_:) has been added to the UIViewController class. It is called after viewWillAppear(_:) and before viewWillDisappear(_:). At the time when the system calls it, the view is already in the hierarchy, which makes it a perfect place to run code that depends on the view’s initial geometry, size, and trait collection. And unlike viewWillLayoutSubviews(_:), it’s only called once. This method will be backported all the way back to iOS 13.

The performance of collection views has been vastly improved in iOS 17, up to two or three times depending on the operation. There is also a new layout dimension, uniformAcrossSiblings(estimate:), that allows you to make groups of items look uniform when they have different estimated heights, for example.

The default status bar style now switches between dark and light based on the content of the app, so some customization code can be removed.

Our verdict: “These features are nice quality of life improvements though nothing groundbreaking. UIKit is still a major part of our apps, so any positive change is welcome.”

laptop with code on a table

Revamped UIKit trait system

The trait hierarchy has been reworked to be more consistent in iOS 17. Before, traits propagated from the parent view controller to its child views and view controllers. That meant that direct subviews of the parent could have different traits from the views of the child view controllers. That is now streamlined, and you can expect trait collections to propagate according to the view hierarchy.

What’s more, iOS 17 introduces custom traits. They can be beneficial when you need to propagate data to many children, pass data to distant components that you wouldn’t have an easy connection to otherwise, or provide context about the environment to the child views and view controllers. However, there is a price to pay for this convenience—performance. Try to avoid custom traits when you can pass the data directly, and use value types for trait values.

There are also new APIs for trait overrides. You can easily specify which trait values you want to override, and they will be propagated down the trait hierarchy to all descendants.

This release also comes with adjustments to how we get notified about changes in trait collections. The traitCollectionDidChange(_:) instance method is deprecated in iOS 17, and it’s replaced by new, more flexible trait registration APIs that allow granular control over which trait changes you want to react to in a particular class. You can also register for semantic system sets—for example, sets of traits that affect color or image appearance.

Finally, you can bridge UIKit traits with SwiftUI environment keys so that all of your components have the same data, regardless of whether you wrap SwiftUI components in UIKit or vice versa. 

Our verdict: “The new trait system just makes sense, which is the best compliment you can give to an API. We really like the simplification of the hierarchy and new convenient ways of working with traits.”

SwiftUI gets several notable upgrades

SwiftUI updates can seem iterative and minor at first, but when you put it all together, you can significantly elevate your app in ways that weren’t possible before.

The scroll view received quite a few updates, including paging, vertical page scrolling, content and scroll indicator indentation, custom transitions for scrolling, and much more. Unfortunately, the API that allowed you to see how much you’ve scrolled didn’t make it to the release as it was removed in one of the betas. We hope to see it next time around.

The release also introduces new animation tools. Phase animators allow you to create multistep animations, and the KeyframeTrack structure makes it easy to create a keyframe animation with multiple properties at the same time.

StoreKit now includes SwiftUI views to present in-app purchases to your users, including handling the process of starting the purchase. It’s a welcome update for developers who don’t want to spend too much time on the purchase interface but still want to make it look nice.

And finally, there are a few updates to MapKit, new APIs for adding haptics, and several other additions.

Our verdict: “We love the new improvements and can’t wait for SwiftUI to grow even further in the coming years.”

woman holding a phone and tapping on an interactive widget

Meet interactive widgets

Widgets were introduced a few years back with iOS 14, and users loved them. However, a lot of people had a major gripe with them—they weren’t interactive. Tapping a widget would always open the app, which wasn’t ideal for all scenarios.

With iOS 17, Apple makes widgets interactive. First, you need to create an app intent that corresponds to the action you want to perform on a widget and execute it with a button or toggle (since other controls won’t work). After the execution of the intent, the widget’s timeline will be reloaded to reflect the result of the action.

Apple also allows you to customize the transition between widget states using regular SwiftUI animation APIs. Now you can have full control over animations that happen when a new timeline entry is displayed.

Our verdict: “Interactive widgets are awesome, we can’t wait to use them in our apps. We are glad that Apple took the time to get them right.”

Compliance made easier with privacy manifests

We respect Apple’s attitude towards user privacy. It does, however, mean a bit more work for developers. With privacy manifests, things become slightly easier. The manifest file can contain types of data your app or SDK collects, sensitive APIs it accesses, and tracking behavior. Moreover, with Xcode 15, you can quickly generate a privacy report, which will show you the preview of the app’s privacy information that the user will see in the App Store.

Along with this, starting from spring 2024, Apple will require all apps to specify a reason for using UserDefaults, a very popular storage API. Make sure your app is ready when the time comes.

Our verdict: “Apple takes privacy seriously. This makes all the steps towards compliance a bit more manageable.”

SwiftData helps you with persistence 

SwiftData is a new data persistence framework that allows you to add persistence to your app with minimal code and external dependencies. It relies heavily on Swift macros to make the experience as seamless as possible. With just a few attributes, you can generate a schema, specify relationships between entities, and describe constraints for the uniqueness of fields.

The framework integrates seamlessly with SwiftUI, which Apple focuses on in their materials, but it works wonderfully with UIKit as well. We can’t wait to give it a try for new projects since this is another framework that’s exclusive to the new iOS 17.

Our verdict: “Persistence with minimal code? Bring it on. Too bad it only works from iOS 17 onwards.”

TipKit puts the friendly in user friendly

We always try to make our apps as intuitive as possible. However, with some features, it may be helpful to provide extra information so that users can use them more effectively. With iOS 17, Apple introduces the TipKit framework, allowing developers to offer users more guidance with helpful tooltips.

With the new framework, you can present tips as inline views or popovers, specify the frequency of their appearance, and add rules for their display.

Our verdict: “TipKit is a great addition that allows us to make UIs even friendlier for users.”

close-up of SF Symbols app

SF Symbols get new animations

We love SF Symbols. They look great, and since people are used to them, they also make apps more intuitive to use.

Starting with iOS 17, you will be able to animate both built-in and custom symbols. There are seven animations to choose from: bounce, pulse, scale, appear, disappear, replace, and variable color

And finally, all of these gorgeous animations—along with plenty of customization options—are available through easy-to-use symbol effect APIs for UIKit, SwiftUI, and AppKit.

Our verdict: “We are glad SF Symbols are even more powerful now. What used to be achievable with third-party tools only can now be done natively.”

The bottom line

With several handy enhancements to UIKit and its trait system, developers can look forward to building more responsive apps with less effort. SwiftUI continues to evolve and mature, and while seemingly minor at first, the changes that come with each update are a treat. In terms of fresh additions, the brand new TipKit framework shows a lot of promise for helping users navigate apps more effectively. Last but not least, as far as making app interaction more intuitive goes, users are sure to appreciate the long-awaited introduction of interactive widgets.

Overall, iOS 17 is a great step forward for both developers and users. Whether you're a SwiftUI enthusiast, a UIKit proponent, or just a fan of the Apple ecosystem, there's something in this release to benefit everyone. The future of iOS looks bright, and we can't wait to see what the next iteration will bring.

Share this article

Join our newsletter

By clicking the button I agree with the collection and processing of my personal data as described in the Privacy policy.