For this chapter, it’s essential to download Xcode version 16.0 or higher from the App Store.

Ensure that you’re operating on the most recent version of macOS (Ventura or newer). Just search for Xcode in the App Store, choose the latest version, and proceed with the download. Open Xcode and complete any further setup instructions that appear. After Xcode is completely up and running, you can begin.

This chapter includes many code examples, and can be found in the following GitHub repository:

https://github.com/PacktPublishing/Mastering-iOS-18-Development/tree/main/Chapter%201

Releasing a major iOS version is always a big deal, even if it’s the 18th already. Let’s try to analyze the iOS SDK before iOS 18:

• SwiftUI is becoming more mature and capable. However, some features, such as complex animations or transitions, gesture handling, navigation, and drawing, remain challenging to implement using SwiftUI.
• Core Data is the go-to framework for most iOS developers as a solution for storing data persistently.
• While XCTest is considered a robust and convenient testing framework, it lacks features that are commonly available on other platforms, such as parameterized testing and better testing organization.
• WidgetKit’s popularity proves that the ability to show information at a glance is crucial in today’s world.

No one can argue that this list is important. However, one critical topic that Apple didn’t focus on until WWDC 2024 is artificial intelligence.

The rise of...

Swift Testing is a new framework with a new and refreshing approach to testing. Swift Testing contains modern features such as macros, which work with structs instead of classes and can tag tests and test suites.

Swift Testing is supposed to replace XCTest, which was introduced in 2013 as part of Xcode 5. XCTest belongs to older times when Objective-C was the dominant language. However, Swift took over, and Apple understood that iOS developers needed a modern testing framework.

Here’s a simple test function:

@Test("Test view model increment function", .enabled(if: AppSettings.CanDecrement), .tags(.critical))
func testViewModelIncrement() async throws {
//         preparation
        let viewmodel = CounterViewModel()
        viewmodel.count = 5
//        execution
 ...

Swift Data was introduced in WWDC 2023 as part of iOS 17, and its goal was to replace the old but popular Core Data framework.

Swift Data provides a modern API based on Swift, which can help reduce friction when working with persistent stores. One of the trends we see in Apple development tools is moving away from GUI to code-based tools. A good example is SwiftUI – even though it is possible to drag and drop components to build a user interface, the primary way to do this is in code. The same goes for App Intents and Swift Package Managers. The data layer goes through the same concept – in Swift Data, we don’t have any data model editor, so we build our data model using only code.

For example, here’s how to create a data model for a Book entity:

@Model
class Book {
    var author: String
    var title: String
    var publishedDate: Date
}

At first...

This is a small improvement, but it may indicate an interesting direction Apple is taking with SwiftUI. In general, UIKit’s transitioning capabilities are very robust and provide us with the flexibility to create any transition we want. Even before that, from the beginning, UIKit had some nice built-in transitions we could use to make our navigation more appealing.

In iOS 18, Apple added a new transition that allows us to navigate to a new view using a zoom animation.

Let’s create an album grid that, when tapping on the album, transitions to a full album screen with a zoom animation:

    @Namespace() var namespace
    var body: some View {
        NavigationStack {
            ScrollView {
                LazyVGrid...

iPad is not the focus of this book. This is not because iPadOS is unimportant but because most, if not all, of the topics we discuss here are also suitable for iPadOS.

However, there are special features that are relevant to iPadOS that are worth mentioning. One of them is the float tab bar.

The tab bar has existed in iOS since its very beginning. It allows users to navigate between different sections of an app. In both iOS and iPadOS, the tab is located at the bottom of the screen. While it looks perfectly fine on small devices, a tab bar on big screens seems stretched and doesn’t use the large space.

One solution for handling navigation in a iPadOS is to implement a sidebar – a view on the side that displays the different sections of the app.

In iPadOS 18, the position of the sidebar changed, and it is now located at the top of the screen, floating over the app content. Not only that; the user can also transition between a tab bar...

Controlling and observing scroll view behavior was part of the reason why UIKit developers hadn’t moved to SwiftUI yet.

Scroll views are crucial in mobile apps, not just because of the small screen, which often requires the user to scroll for more content, but also because they help reuse visible content to minimize memory usage or adjust our UI based on scroll position.

However, why is handling scroll views in SwiftUI more complex than in UIKit? We can think of two reasons:

1. SwiftUI is relatively new: SwiftUI is still considered to be a new framework. Think how much time it took for UIKit to become a mature framework. Obviously, we can achieve this in several years and 17 years of development.
2. Flexibility: Due to the imperative approach, UIKit gives us direct control over views. This means that we can adjust particular view parameters based on the scroll state. SwiftUI’s declarative nature sometimes makes achieving...

Handling texts on screen was also a very mature area where UIKit provided great frameworks such as TextKit. We could manipulate texts and create almost any effect that we wanted.

In iOS 18, Apple introduced TextRenderer, a protocol that can help us change the default behavior of our texts in SwiftUI.

Let’s say that we want a title with a different opacity for each line and even rotate the lines a bit. This creates a nice effect for the titles in our app. So, let’s see how to do that in SwiftUI:

struct CustomTextRenderer: TextRenderer {
    func draw(layout: Text.Layout, in ctx: inout
     GraphicsContext) {
        for (index, line) in layout.enumerated() {
            ctx.opacity = Double(index + 1) * 0.1
            ctx...

What does it mean to position sub-views from another view? While this description sounds weird and unclear, it is a nice addition to SwiftUI that can help us provide more dynamic and reusable content.

To understand what it means, let’s take the following code as an example:

struct NewsView: View {
    var body: some View {
        Text("Major Breakthrough in Renewable Energy: New Solar Panel Technology Promises 30% Efficiency Increase")
        Text("lobal Markets React to Sudden Interest Rate Hike: Stocks Tumble Across the Board")
        Text("Historic Peace Agreement Reached: Leaders Sign Pact to End Decades-Long Conflict")
        Text("Innovative AI Tool Revolutionizes Healthcare: Doctors Embrace Machine Learning...

AI and machine learning are not new areas for Apple and the iOS platform. Apple uses AI to adjust photos taken, suggest apps to users according to their usage, optimize battery charging, and many more.

For developers, Apple provides the CoreML framework and tools such as Create ML to help users train and create their own machine learning models.

However, the rising popularity of services such as ChatGPT and Gemini proved that CoreML is insufficient, and that Apple needs to integrate AI deeper into the system.

So, what did Apple prepare for us, the developers, regarding AI in iOS 18?

Apple integrated AI into iOS 18 by letting iOS understand what’s happening in the system and helping the user perform common tasks using natural language understanding, similar to ChatGPT.

For example, let’s say we’re working on a word-processing app and created an App Intent that allows the user to add an image to a document.

Until iOS 18...

There’s no other way of looking at iOS 18 than as an exciting one. The addition of Apple Intelligence is only part of the story – Apple took care of many system and SDK aspects such as testing, persistent data, UI, and more.

In this chapter, we explored the basics of the new Swift Testing framework, learned about Swift Data improvements, and discussed enhancements in SwiftUI such as zoom transition, floating tab bar, scroll views, and text rendering. We even scratched the surface of Apple Intelligence and tried to understand how it is integrated with App Intents. By now, you should be familiar with the most exciting and new topics in iOS 18.

A few code examples are just not enough. We are developers, and we need more! So, let’s jump straight into SwiftData and explore Apple’s new persistent data framework in the next chapter.