Wesley de Groot

Safari in SwiftUI

Fri, 17 Oct 2025 22:36:33 +0200

You started playing around with SwiftUI, and you want to present a Safari(WebView), you search in the documentation, and..., SwiftUI has no native way to display a WebView!

To use Safari (SFSafari) you need to create a custom UIViewControllerRepresentable which is needed to use ViewControllers in SwiftUI.

This post contains, 3 sections,

The code in steps
The code (complete)
Example on how to use.

Full source code of our UIViewControllerRepresentable.

import SwiftUI
import SafariServices
import UIKit

/// Make a Safari View for SwiftUI
public struct SafariView: UIViewControllerRepresentable {
    typealias UIViewControllerType = SFSafariViewController

    /// Create a binding for our URL String
    @Binding var urlString: String

    /// Public initializer.
    public init(url: String) {
        _urlString = url
    }

    /// Make a UIViewController for SwiftUI.
    public func makeUIViewController(
        context: UIViewControllerRepresentableContext<SafariView>
    ) -> SFSafariViewController {
        // Check if the url is valid, otherwise fatalError.
        guard let url = URL(string: urlString) else {
            fatalError("Invalid urlString: \(urlString)")
        }

        // Generate the SFSafariViewController.
        let safariViewController = SFSafariViewController(url: url)

        // Optional, set int/accentcolor.
        safariViewController.preferredControlTintColor = UIColor(Color.accentColor)

        // We want our view to have a close button instead of 'done'
        safariViewController.dismissButtonStyle = .close

        // Return the view
        return safariViewController
    }

    public func updateUIViewController(
      _ safariViewController: SFSafariViewController, 
      context: UIViewControllerRepresentableContext<SafariView>) {
        return
    }
}

How to use:

struct CodeView: View {
    // whether or not to show the Safari ViewController
    @State var showSafari = false

    // initial URL string
    @State var urlString = "https://wesleydegroot.nl"

    var body: some View {
        VStack {
            Button("Open This article") {
                self.urlString = "https://wesleydegroot.nl/blog/Safari-in-SwiftUI"

                showSafari = true
            }
        }
        .popover(isPresented: $showSafari, content: {
            SafariView(urlString: $urlString)
        })
    }
}

// MARK: Preview
struct CodeView_Previews: PreviewProvider {
    static var previews: some View {
        CodeView()
            .previewLayout(PreviewLayout.sizeThatFits)
            .padding()
            .previewDisplayName("Code Preview")
    }
}

Swipe actions in Swift

Fri, 17 Oct 2025 22:36:34 +0200

The issue:

Gestures, delegates, it can be a big struggle (especially for beginners).

If you use a lot of gestures then you’ll need to implement it over and over.
One of the problems is, that code what you write will not apply to other views in your application.
If we use a lot of swipe actions, in different places within our application we want to have reusable code.
But then we see ourselfs overloaded with issues, can it be made more easy?

Yes!

How can we make it more easy?

Using a UIViewextension.

Why not a UIViewController?
“Because we also want to support other applications which have a UIView.”
How do we start?

In this post we’ll start with a UIView extension, to make it reusable for other applications (e.g. UIImageView, UIView, ...).

In my case it didn’t work on a UITableViewController.

Psuedo code:

import Foundation
import UIKit
extension UIView {
// psuedo code continues

We also need a variable, but simply var myVariable = ...does not work, since we are working in an extension.
There is a workaround, and it may be more easy than you think.
We’ll use a structand that will solve all our variable problems.
We want to reuse the data, so we make a static var.

Psuedo code:

// .... psuedo code to above blocks<br>struct gestureClosures {
    static var up = ...
    static var down = ...
    static var left = ...
    static var right = ...
}

We also need to create a function, to make it work!

Psuedo code:

func swipeAction(
        swipeDirection: UISwipeGestureRecognizer.Direction,
        completionHandler: @escaping ()->()
        ) {
        // Add a swiper
        let swiper = .... #selector(self.invokeTarget(_:))
            // give the direction as in swipeDirection
            swiper.direction = swipeDirection
        // add to the view        
        self.addGestureRecognizer(swiper)

        // save the completionHandler
        switch swipeDirection {
        case .up:
            gestureClosures.up = completionHandler
        case .down:
            gestureClosures.down = completionHandler
        case .left:
            gestureClosures.left = completionHandler
        case .right:
            gestureClosures.right = completionHandler 
        default:
            print("Nothing")        
        }    
}

But we still need to respond on the swipe actions!

Yup, pseudocode:

@objc func invokeTarget(...) {
    // disamble 
        switch swipeDirection {
        case .up:
            gestureClosures.up()
        case .down:
            gestureClosures.down()
        case .left:
            gestureClosures.left()
        case .right:
            gestureClosures.righ() 
        default:
            print("Nothing")        
        }
}

And if we translate it to functional swift code.

Then the output looks similair to above.

The complete solution:

import Foundation
import UIKit

// Extend UIView
extension UIView {
    /// Setup a struct for saving the gesture handlers
    struct gestureHandler {
        /// Gesture "Up"
        static var up: (()->())? = nil
        /// Gesture "Down"
        static var down: (()->())? = nil
        /// Gesture "Left"
        static var left: (()->())? = nil
        /// Gesture "Right"
        static var right: (()->())? = nil
    }

    /**
     * Add a swipe action to UIView
     *
     * - Parameter swipeDirection: `.up`,`.down`,`.left`,`.right`
     * - Parameter completionHandler: The completionhandler.
     */
    func swipeAction(
        swipeDirection: UISwipeGestureRecognizer.Direction,
        completionHandler: @escaping ()->()
    ) {
        /// Add swipe handler
        let swiper = UISwipeGestureRecognizer(
            // UIView is the target
            target: self,

            // invokeTarget is our responder
            action: #selector(self.invokeTarget(_:))
        )

        // Set the direction of the swipe handler
        swiper.direction = swipeDirection

        // Add the gesture recognizer to the view
        self.addGestureRecognizer(swiper)

        // Switch between directions,
        // Save it to our struct.
        switch swipeDirection {
        case .up:
            // Save the completionHandler to gestureHandler.up
            gestureHandler.up = completionHandler
        case .down:
            // Save the completionHandler to gestureHandler.down
            gestureHandler.down = completionHandler
        case .left:
            // Save the completionHandler to gestureHandler.left
            gestureHandler.left = completionHandler
        case .right:
            // Save the completionHandler to gestureHandler.right
            gestureHandler.right = completionHandler
        default:
            print("Nothing")
        }
    }

    /**
     * Respond to a swipe action from UIView
     *
     * - Parameter gesture: The UIGestureRecognizer
     */
    @objc func invokeTarget(_ gesture: UIGestureRecognizer?) {
        /// Unwrap the swipeGesture
        if let swipeGesture = gesture as? UISwipeGestureRecognizer {
            // Switch between the direction
            switch swipeGesture.direction {
            case .up:
                /// Unwrap gestureHandler.up if possible
                guard let execute = gestureHandler.up else {
                    return
                }

                execute()
                break;
            case .down:
                /// Unwrap gestureHandler.down if possible
                guard let execute = gestureHandler.down else {
                    return
                }

                execute()
                break;
            case .left:
                /// Unwrap gestureHandler.left if possible
                guard let execute = gestureHandler.left else {
                    return
                }

                execute()
                break;
            case .right:
                /// Unwrap gestureHandler.right if possible
                guard let execute = gestureHandler.right else {
                    return
                }

                execute()
                break;
            default:
                print("N/A")
            }
        }
    }
}

Easy Publishers

Fri, 17 Oct 2025 22:36:34 +0200

Ever wondered how to create a simple publisher?

In this blog i'll try to show you the basics

Firstly we need to import the required frameworks

// Used for the ObservableObject
import Combine

// The easiest for publishers
import SwiftUI

Published object

We're going to create a class what subclasses ObservableObject and contains a @Published variable.
(for this example it is also using a timer to update the value)

class MyObject: ObservableObject {
    // This published variable will be updated several times.
    @Published var y: String

    // Set a default value to y, and start the timer
    init() {
        // Set the value of y to Loading...
        y = "Loading..."

        // Run this function after 5 seconds on the main thread.
        DispatchQueue.main.asyncAfter(deadline: .now() + 5) { 
            self.upd() // Update
        }
    }

    func upd() {
        // Set the value of y to Published World
        y = "Published World"

        // Tell the system that this ObservableObject class is updated.
        self.objectWillChange
    }
}

(SwiftUI) View

struct MyView: View {
    // Define our object(class) as Observed
    @ObservedObject var v = MyObject()

    var body: some View {
        Text(v.y) // This will change automatically if y is changed
    }
}

Full code

import Combine
import SwiftUI

class MyObject: ObservableObject {
    @Published var y: String
    init() {
        y = "Loading..."
        DispatchQueue.main.asyncAfter(deadline: .now() + 5) { 
            self.upd()
        }
    }
    func upd() {
        y = "Published World"
        self.objectWillChange
    }
}

struct MyView: View {
    @ObservedObject var v = MyObject()
    var body: some View {
        Text(v.y)
    }
}

Observable Geocoder

Fri, 17 Oct 2025 22:36:35 +0200

Firstly we want to import CoreLocation for the location services.

We're going to construct a basic class, which subclasses ObservableObject.

class Geocoder: ObservableObject {
/// ...
}

We're going to add @Published public var (published public variables),
for the items we want to expose, in my case it are the following variables placeMark, location, name, iso, country, postalCode, state, subState, city, subCity, street, subStreet, region, timeZone, inlandWater, ocean and areasOfInterest.

Full Code:

import CoreLocation

class Geocoder: ObservableObject {
    /// Placemark
    @Published public var placeMark: CLPlacemark?

    /// Location
    @Published public var location: CLLocation?

    /// The name of the placemark.
    @Published public var name: String?

    /// The abbreviated country or region name.
    @Published public var iso: String?

    /// The name of the country or region associated with the placemark.
    @Published public var country: String?

    /// The postal code associated with the placemark.
    @Published public var postalCode: String?

    /// The state or province associated with the placemark.
    @Published public var state: String?

    /// Additional administrative area information for the placemark.
    @Published public var subState: String?

    /// The city associated with the placemark.
    @Published public var city: String?

    /// Additional city-level information for the placemark.
    @Published public var subCity: String?

    /// The street address associated with the placemark.
    @Published public var street: String?

    /// Additional street-level information for the placemark.
    @Published public var subStreet: String?

    /// The geographic region associated with the placemark.
    @Published public var region: CLRegion?

    /// The time zone associated with the placemark.
    @Published public var timeZone: TimeZone?

    /// The name of the inland water body associated with the placemark.
    @Published public var inlandWater: String?

    /// The name of the ocean associated with the placemark.
    @Published public var ocean: String?

    /// The relevant areas of interest associated with the placemark.
    @Published public var areasOfInterest: [String]?

    /// Geocoder
    private let geoCoder = CLGeocoder()

    init () { }

    /// Update to location
    func update (to location: CLLocation) {
        geoCoder.reverseGeocodeLocation(
            location,
            completionHandler: { (placemarks, _) -> Void in
                // We're only using the first place mark.
                if let placeMark = placemarks?[0] {
                    self.placeMark = placeMark
                    self.location = placeMark.location
                    self.name = placeMark.name
                    self.iso = placeMark.isoCountryCode
                    self.country = placeMark.country
                    self.postalCode = placeMark.postalCode
                    self.state = placeMark.administrativeArea
                    self.subState = placeMark.subAdministrativeArea
                    self.city = placeMark.locality
                    self.subCity = placeMark.subLocality
                    self.street = placeMark.thoroughfare
                    self.subStreet = placeMark.subThoroughfare
                    self.region = placeMark.region
                    self.timeZone = placeMark.timeZone
                    self.inlandWater = placeMark.inlandWater
                    self.ocean = placeMark.ocean
                    self.areasOfInterest = placeMark.areasOfInterest

                    // Send a notification that our `@Published` values have been changed.
                    self.objectWillChange.send()
                }
            }
        )
    }
}

Usage

geocoder.update(to: .init(
    latitude: annotation.coordinate.latitude,
    longitude: annotation.coordinate.longitude
))

New Website

Fri, 17 Oct 2025 22:36:35 +0200

New Website!

Welcome to the new website! We hope you like it.
We've been working hard to make it as easy to use as possible.
If you have any feedback, please let me know.

New Features

New design
Easier to use
More content

Features

This website is built with PHP.
The blog posts are written in Markdown, and parsed with a custom parser.
It supports Github flavoured markdown.

Test

This is a inline code test echo "Hello World";
This is a block code test

echo "Hello World";

This is a indentation code test

echo "Hello World";

This is a quote test

Hello World

This is a link test Google

This is a image test

This is a list test

Item 1
Item 2
Item 3

This is a numbered list test

Item 1
Item 2
Item 3

This is a table test

Header 1	Header 2
Cell 1	Cell 2
Cell 3	Cell 4

This is a bold test Hello World

This is a italic test Hello World

This is a strikethrough test ~~Hello World~~

This is a underline test Hello World

This is a highlight test Hello World

This is a superscript test ^{Hello World}

This is a subscript test _{Hello World}

Snippet: @EnvironmentVariable

Fri, 17 Oct 2025 22:36:36 +0200

If you are creating commandline apps you sometimes need to acces the operating system environment variables, while you can use getenv(name) it can come in handy to use a property wrapper if you need to access the environment variables often, or if you are updating them.

Full code:

/// A  property wrapper to set and get system's environment variables values.
///
/// ```
/// @EnvironmentVariable(name: "PATH")
/// var path: String?
/// ```
@propertyWrapper
public struct EnvironmentVariable {
    var name: String

    public var wrappedValue: String? {
        get {
            guard let pointer = getenv(name) else { return nil }
            return String(cString: pointer)
        }
        set {
            guard let value = newValue else {
                unsetenv(name)
                return
            }

            setenv(name, value, 1)
        }
    }
}

in the future i'll post more about @propertyWrappers.

OTP Code Generation with CryptoKit: A Swift Approach

Fri, 17 Oct 2025 22:36:36 +0200

Introduction

In the realm of secure authentication, One-Time Passwords (OTPs) play a crucial role. Whether it's two-factor authentication (2FA) or protecting sensitive transactions, OTPs provide an additional layer of security. In this article, we'll explore how to generate OTPs using CryptoKit, Apple's powerful cryptographic framework.

What Is an OTP?

An OTP is a temporary password that is valid for a single use or a short period. It ensures that even if an attacker intercepts the password, they won't be able to reuse it. OTPs are commonly used in scenarios like logging into online accounts, confirming transactions, or accessing secure systems.

Understanding TOTP (Time-Based OTP)

TOTP is a type of OTP that changes over time. It's based on a shared secret key and the current time.
The secret key is known only to the user and the server.
The server and the user's device both calculate the same OTP based on the secret key and the current time.
The OTP is typically a 6 or 8-digit numeric code.

Generating TOTP with CryptoKit

Let's dive into the Swift code for generating a TOTP using CryptoKit. We'll assume you already have a shared secret key (usually provided during user registration).

import CryptoKit
import CommonCrypto
import Foundation

func cryptoKitTOTP(secret: String) -> String {
    let period = TimeInterval(30)
    let digits = 6
    let secret = base32Decode(value: secret)!
    var counter = UInt64(Date().timeIntervalSince1970 / period).bigEndian

    // Generate the key based on the counter.
    let key = SymmetricKey(data: Data(bytes: &counter, count: MemoryLayout.size(ofValue: counter)))
    let hash = HMAC<Insecure.SHA1>.authenticationCode(for: secret, using: key)

    var truncatedHash = hash.withUnsafeBytes { ptr -> UInt32 in
        let offset = ptr[hash.byteCount - 1] & 0x0f

        let truncatedHashPtr = ptr.baseAddress! + Int(offset)
        return truncatedHashPtr.bindMemory(to: UInt32.self, capacity: 1).pointee
    }

    truncatedHash = UInt32(bigEndian: truncatedHash)
    truncatedHash = truncatedHash & 0x7FFF_FFFF
    truncatedHash = truncatedHash % UInt32(pow(10, Float(digits)))

    return String(format: "%0*u", digits, truncatedHash)
}

print(cryptoKitTOTP(secret: "5FAA5JZ7WHO5WDNN"))

Conclusion

By leveraging CryptoKit, you can easily implement TOTP generation in your iOS apps. Remember to securely store and manage the shared secret key. OTPs enhance security and protect your users' accounts from unauthorized access.

For more details, refer to the official Apple CryptoKit documentation.

Implementing Admob in SwiftUI

Fri, 17 Oct 2025 22:36:37 +0200

Recently i was working on a project that required me to implement Admob in a SwiftUI app.

I encountered some issues while implementing Admob in SwiftUI, so i decided to make a library Admob-SwiftUI that makes it easy to implement Admob in SwiftUI.

Which problems did i encounter?

Admob banner not showing up.
Padding for the Admob banner.
The new EU consent policy UMPConsentInformation.
Unable to update the consent status.
Ad area unusable if ad is not shown.

Admob Banner not showing up

The Admob banner was not showing up because i had not set the UMPConsentInformation correctly, see the Documentation, and the page in Admob Console.

What did i try to fix the padding?

First i added in every view a padding, (on the bottom) to make sure that the ad would not overlap the view below it.
Using .padding(.bottom, consent.haveConsent ? 50 : 0).
This worked okay, but created a white/black bar where the ad would be shown, and i needed to add it in every view what i displayed on screen, this increases the chance of forgetting to add it.

Using a padding on each view in the TabView. (this works okay, but creates a white/black bar where the ad will be shown) .padding(.bottom, consent.haveConsent ? 50 : 0).
This is also not the solution i wanted.

I searched if there is a way to add some extra padding to the contents of the views in the TabView, after a lot of searching i found contentMargins(_:for:) and this looked promising, so i tried to add that to my app.
But unfortunalet there was a catch, it only works on iOS 17+ and my app supports iOS 16 and up.
I tried to use it with a if #available(iOS 17, *), but the issue is, you can't use if #available(iOS 17, *) in a View in SwiftUI.

So i needed to come up with a different solution...

What about a ViewModifier? no that would not work...

What about a ViewBuilder?
This can work, let's try it out.

extension View {
    @ViewBuilder
    func addAdPadding(height: CGFloat) -> some View {
        if #available(iOS 17.0, *) {
            // If iOS 17+ use contentMargins
            // This is the nices solution, 
            // but it only works on iOS 17+
            self.contentMargins(
                .bottom,
                height + 10,
                for: .scrollContent
            )
        } else {
            // Fallback on earlier versions
            self.padding(
                .bottom,
                height
            )
        }
    }
}

We have our final solution, this works on iOS 16 and up, and it's easy to use.

The new EU consent policy `UMPConsentInformation`

You create a view with the class name AdConsentView and then you can call the updateConsent function to update the consent status.

I call it like this:

struct AdConsentView: View {
    @EnvironmentObject
    private var adHelper: AdHelper

    var body: some View {
        VStack { }
        .background(formViewControllerRepresentableView)
        .onAppear {
            guard !hasViewAppeared else { return }
            hasViewAppeared = true

            DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
                self.askConsent()
            }
        }
    }
}

Full code: https://github.com/0xWDG/Admob-SwiftUI/blob/main/Sources/Admob-SwiftUI/AdConsentView.swift

Updating the consent status

The code for updating the consent is:

func updateConsent() {
    GoogleMobileAdsConsentManager.shared.presentPrivacyOptionsForm(
        from: formViewControllerRepresentable.viewController
    ) { (formError) in
        guard let formError else { return }

        // Handle the error
    }
}

The problem with AdConsentView is that your SwiftUI view is not re-usable for calling only the updateConsent function, so you have to create formViewControllerRepresentable.viewController and the updateConsent function in multiple files, in my case this did not work and i was unable to update the consent of the user.

My solution was to point to the updateConsent() function, to that i can call the updateConsent function from the AdHelper class.

struct AdConsentView: View {
    func updateConsent() {
        GoogleMobileAdsConsentManager.shared.presentPrivacyOptionsForm(
            from: formViewControllerRepresentable.viewController
        ) { (formError) in
            guard let formError else { return }

            // Handle the error
        }
    }

    @MainActor
    func askConsent() {
        // Point to the updateConsent function
        adHelper.updateConsent = updateConsent 

        // initial consent question
    }
}

Ad area unusable if ad is not shown

If the ad is not shown, the view (zstack) will be overlap the view below it, making the view below it unusable, this is intentional if the ad is shown, but if the ad is not shown, the view below it should be usable.

the way to fix this is to set the opacity of the ad to 0 if the ad is not shown. like the snippet below.

.opacity(adHelper.showingAd ? 1 : 0)

Reset the consent status

You can use UMPConsentInformation.sharedInstance.reset() to reset the consent status.
Since the library is already handling the consent status, you can use
adHelper.resetConsent() (which is shorter and easier to remember)

Before the library

struct ContentView: View {
    @ObservedObject var adHelper = AdHelper(
        adUnitId: "ca-app-pub-5555094756467155/7714412839"
    )

    ZStack {
            TabView {
                Text("First View")
                    .tabItem {
                        Image(systemName: "1.square.fill")
                        Text("First")
                    }
                    .padding(.bottom, adHelper.adHeight)
                UpdateConsent()
                    .tabItem {
                        Image(systemName: "2.square.fill")
                        Text("Second")
                    }
                    .padding(.bottom, adHelper.adHeight)
            }

            AdConsentView()
                .environmentObject(adHelper)

            if adHelper.haveConsent {
                VStack {
                    Spacer()
                    BannerView(adUnitID: adHelper.adUnitId)
                        .background(.clear)
                        .frame(width: 320, height: adHelper.adHeight)
                        .padding(.bottom, adHelper.adHeight + 1)
                        .opacity(adHelper.showingAd ? 1 : 0)
                        .environmentObject(adHelper)
                }
            }
    }
    .environmentObject(adHelper)
}

With the library

struct ContentView: View {
    @ObservedObject var adHelper = AdHelper(
        adUnitId: "ca-app-pub-5555094756467155/7714412839"
    )

    AdView {
            TabView {
                Text("First View")
                    .tabItem {
                        Image(systemName: "1.square.fill")
                        Text("First")
                    }
                UpdateConsent()
                    .tabItem {
                        Image(systemName: "2.square.fill")
                        Text("Second")
                    }
            }
    }
    .environmentObject(adHelper)
}

Update/Reset the consent status

struct UpdateConsent: View {
    @EnvironmentObject
    private var adHelper: AdHelper

    var body: some View {
        ScrollView {
            VStack {
                Button("Reset consent", role: .destructive) {
                    adHelper.resetConsent()
                }

                Button("Update Consent") {
                    adHelper.updateConsent()
                }
            }
        }
    }
}

The library is available on Github: https://github.com/0xWDG/Admob-SwiftUI.

Xcode shortcuts

Fri, 17 Oct 2025 22:36:38 +0200

Mastering Xcode: Boost Your Productivity with Essential Shortcuts

As developers, we're always on the quest for efficiency. Whether you're a seasoned Xcode user or just starting out, harnessing the power of keyboard shortcuts can significantly enhance your coding experience. In this article, we'll dive into the world of Xcode shortcuts, uncovering hidden gems that will streamline your workflow and make you feel like a coding wizard.

Why Xcode Shortcuts Matter

Imagine this: You're knee-deep in your Swift code, tweaking UI elements, debugging, and navigating through project files. Instead of reaching for your mouse every time, what if you could perform these tasks effortlessly with a few keystrokes? That's where Xcode shortcuts come to the rescue.

Navigating the Xcode Landscape

Before we delve into the shortcuts themselves, let's orient ourselves within Xcode's interface. Remember these three key areas:

Navigator ⌘ + 0: On the left, the Navigator provides access to project files, source control, and more.
Inspectors ⌘ + ⌥ + 0: To the right, Inspectors reveal contextual information about your code.
Debug Area ⇧ + ⌘ + Y: At the bottom, the Debug Area displays logs, breakpoints, and variables during debugging.

Essential Xcode Shortcuts

Now, let's explore some of my favorite productivity shortcuts:

Jump to Definition ⌃ + ⌘ + J: Instantly navigate to the definition of a class, function, or variable.
Quick Open File ⌘ + Shift + O: Find and open any file in your project swiftly.
Refactor ⌃ + ⌘ + R: Rename variables, methods, or classes seamlessly.
Comment/Uncomment ⌘ + /: Add or remove comments with a single keystroke.
Build and Run ⌘ + R: Compile and launch your app without leaving the keyboard.

Summary / list

Build	`⌘ + B`
Run	`⌘ + R`
Test	`⌘ + U`
Build	`⌘ + B`
Stop	`⌘ + .`
Clean	`⌘ + ⇧ + K`
Clean the build folder	`⌘ + ⇧ + ⌥ + K`
Open quickly	`⇧ + ⌘ + O`
Code completion	`⌃ + Space`

References:

Fun fact: this article is partly generated using bing Copilot!

SwiftUI property wrappers

Fri, 17 Oct 2025 22:36:38 +0200

Let's dive into the fascinating world of SwiftUI property wrappers.

These powerful constructs allow you to manage data, state, and environment information in your SwiftUI views. 🚀

Understanding SwiftUI Property Wrappers

State: Things the view creates (not owns, because Views don't own anything…).
For example: @State, @StateObject, @AppStorage…
Can also more generally mean “the state of the app”, which beyond the view’s state, would also include the view’s dependencies, as well as other parts of the app’s state that don’t affect the view. The meaning of the term through the document usually means the former definition (ie, things the view creates), but can change based on the context.

Dependencies: Things the view receives and doesn’t create.
For example: @Binding, let, @Environment, @EnvironmentObject, @ObservedObject…
Also anything passed to a custom init if there is one.

Property wrappers are a fundamental part of SwiftUI, helping reduce boilerplate code and enabling seamless data flow between views. Let's explore some of the most commonly used property wrappers:

@State: This property wrapper allows you to manage small amounts of value type data locally within a view. When the state changes, SwiftUI automatically updates the view. Use it for UI-related state, such as toggles, counters, or text input fields.
@Binding: When you need to share data between different views, @Binding comes to the rescue. It refers to value type data owned by another view. Changes made locally to the binding propagate back to the original data source. Think of it as a two-way communication channel.
@ObservedObject: Use this property wrapper to refer to an instance of an external class that conforms to the ObservableObject protocol. It's perfect for managing reference type data (e.g., network requests, Core Data objects) that doesn't belong to the view itself.
@Published: Attached to properties inside an ObservableObject, @Published tells SwiftUI to refresh any views that use this property when it changes. It's like a signal to update the UI when the underlying data updates.
@Environment: This wrapper lets you read data from the system environment, such as color schemes, accessibility options, and trait collections. You can also add your own custom keys to the environment. It doesn't own its data but provides access to system-level information.
@AppStorage: If you need to read and write values from UserDefaults, @AppStorage is your friend. It owns its data and simplifies persistent storage for simple values like user preferences or settings.
@FetchRequest: When working with Core Data, use @FetchRequest to start a fetch request for a specific entity. It owns its data and provides a convenient way to retrieve managed objects from your data store.
@ScaledMetric: This wrapper reads the user's Dynamic Type setting and scales numbers based on an original value you provide. It's useful for adapting font sizes and other metrics to the user's preferences.

Custom Property Wrappers

You can also create your own custom property wrappers to encapsulate specific behavior or data management logic. By defining a property wrapper type, you can reuse it across your codebase and ensure consistent behavior wherever it's used.

Here's a simple example of a custom property wrapper that logs changes to a property:

@propertyWrapper
struct LogChanges<Value> {
    var wrappedValue: Value {
        didSet {
            print("Value changed to \(wrappedValue)")
        }
    }

    init(wrappedValue: Value) {
        self.wrappedValue = wrappedValue
    }
}

struct ContentView: View {
    @LogChanges
    var count = 0

    var body: some View {
        VStack {
            Button("Increment") {
                count += 1
            }
            Text("Count: \(count)")
        }
    }
}

In this example, the LogChanges property wrapper prints a message whenever the count property changes. You can create custom property wrappers to add additional functionality or constraints to your properties.

Example 2: Mimicing @Published

Here's another example that mimics the behavior of @Published:

@propertyWrapper
struct Store<Value> :DynamicProperty {
    let storage: State<Value>

    init(wrappedValue value: Value) {
        self.storage = State<Value>(initialValue: value)
    }

    public var wrappedValue: Value {
        get { storage.wrappedValue }
        nonmutating set { storage.wrappedValue = newValue }
    }

    public var projectedValue: Binding<Value> {
        storage.projectedValue
    }
}

struct ContentView: View {
    @Store
    var isOn = false

    var body: some View {
        VStack {
            Text(isOn ? "yes" : "Nope")

            Toggle(isOn: $isOn, label: {
                Text("IsOn?")
            })
        }
        .padding()
    }
}

Conclusion

SwiftUI property wrappers are like magic spells that empower your views. By choosing the right one for each situation, you'll create elegant, responsive interfaces. Happy coding! 🌟

iCloud Drive Tips & Tricks

Fri, 17 Oct 2025 22:36:39 +0200

What Is iCloud Drive?

iCloud Drive is Apple's cloud-based file storage and synchronization service. It allows you to store, organize, and collaborate on files and folders across all your Apple devices. Whether you're using a Mac, iPhone, iPad, or even accessing your files via iCloud.com, iCloud Drive ensures seamless synchronization.
iCloud Drive simplifies file management, collaboration, and access across your Apple ecosystem. Whether you're a student, professional, or creative, harness the power of iCloud Drive to keep your digital life organized and connected.

Must know commandline commands

Download ‘all’ files in the current & sub folders.
find . -type f -name "*.icloud" -exec brctl download “{}” \;

Download a specific file:
brctl download filename

Remove the local download of a file
brctl evict filename

View iCloud log:
brctl log -w --shorten

Diagnose errors:
brctl diagnose

Debugging & more

If you are having issues with iCloud Drive, you can use the following commands in terminal to help diagnose the problem.

Check iCloud Progress:
brctl monitor com.apple.CloudDocs|grep %

Check iCloud Download Progress:
brctl monitor com.apple.CloudDocs|grep ↓

Check iCloud Upload Progress:
brctl monitor com.apple.CloudDocs|grep ↑

Check iCloud Errors:
brctl log -w --shorten

Check iCloud Diagnose:
brctl diagnose

Check iCloud Status:
brctl status

Full list of commands

brctl is the command line tool for iCloud Drive. Here is a full list of commands:

╭── 👤 wesley 📂 ~/d/w/wesleydegroot.nl/blog/
╰─> brctl     
Usage: brctl <command> [command-options and arguments]

    -h,--help            show this help

COMMANDS

diagnose [options] [--doc|-d <document-path>] [<diagnosis-output-path>]
    diagnose and collect logs

    -M,--collect-mobile-documents[=<container>]  (default: all containers)
    -s,--sysdiagnose     Do not collect what's already part of sysdiagnose
    -t,--uitest          Collect logs for UI tests
    -n,--name=<name>     Change the device name
    -f,--full            Do a full diagnose, including server checks
    -d,--doc=<document-path>
                         Collect additional information about the document at that path.
                         Helps when investigating an issue impacting a specific document.
    -e,--no-reveal       Do not reveal diagnose in the Finder when done
    [<diagnosis-output-path>]
                         Specifies the output path of the diagnosis; -n becomes useless.

log [options] [<command>]

    -a,--all                         Show all system logs
    -p,--predicate                   Additional predicate (see `log help predicates`)
    -x,--process <name>              Filter events from the specified process
    -d,--path=<logs-dir>             Use <logs-dir> instead of default
    --last num [m|h|d]               Limits the captured events to the period starting at the given interval ago from the current time
    -S,--start="YYYY-MM-DD HH:MM:SS" Start log dump from a specified date
    -E,--end="YYYY-MM-DD HH:MM:SS"   Stop log dump after a specified date
    -b                               Show CloudDocs logs
    -f                               Show FileProvider related logs
    -F                               Show FruitBasket related logs
    -N                               Show network related logs (should be used in conjonction with another flag)
    -g                               Show Genstore related logs
    -i                               Show SQL and CloudDocs logs
    -o                               Show local storage logs
    -D                               Show logs from the Denator subsystem
    -z,--local-timezone              Display timestamps within local timezone
    --dark-mode                      Adapt color scheme to dark mode terminal
    -q,--quick                       Print logs without heavy pre-processing

dump [options] [<container>]
    dump the CloudDocs database

    -o,--output=<file-path>
                         redirect output to <file-path>
    -d,--database-path=<db-path>
                         Use the database at <db-path>
    -e,--enterprise
                         Use the Data Separated database
    -i,--itemless
                         Don't dump items from the db
    -u,--upgrade
                         Upgrade the db if necessary before dumping

    [<container>]        the container to be dumped

status [<containers>]
    Prints items which haven't been completely synced up / applied to disk

    [<container>]        the container to be dumped

accounts [options]
    Displays iCloudDrive eligible accounts and their logged in/out status and directory name
    -w,--wait            wait for logged in accounts to load

quota
    Displays the available quota in the account

monitor [options] [<container> ...]
    monitor activity
    -g                   dump global activity of the iCloud Drive
    -i                   dump changes incrementally
    -t                   amount of time in seconds to run the query, the query will stop after the specified time
    -S,--scope=<scope>
                         restrict the NSMetadataQuery scope to docs, data, external or a combination

    [<container> ...]    list of containers to monitor, ignored when -g is used

Help

Something isn't working!

Finder freezes

Sometimes this can happen, especially when you have a lot of files in your iCloud Drive. You can try to find the file causing Finder to freeze by using the following command brctl monitor com.apple.CloudDocs|grep % , this will show you the progress of the files being downloaded. If you see a file that is stuck for a long time, you can try to download it manually by using the following command brctl download filename. If that doesn't work, you can try to remove the local download of the file by using the following command brctl evict filename. This will remove the local download of the file and try to download it again. If that doesn't work, you can try to diagnose the issue by using the following command brctl diagnose. This will collect logs and diagnose the issue. If you still can't find the issue, you can try to contact Apple Support for further assistance.

I unzipped a masively big zip and now the contents of the folder are not shown anymore (e.g. on the Desktop)

Go to https://www.icloud.com/iclouddrive and delete the files.

Tips

Do not use a lot of non-standard characters in your file names. This can cause issues with iCloud Drive.
Do not end your file names with a space. This can cause issues with iCloud Drive.
Do not save development folders like node_modules or .git in your iCloud Drive. This can take up a lot of space and cause issues with iCloud Drive.
Do not use iCloud Drive as a backup solution. It's not designed for that and you can lose your files if you're not careful.

Conclusion

i love iCloud Drive and it's features. It's a great way to keep all your files in sync and available on all your devices.
Unfortunately, it's not always working as expected. But with the above commands you can diagnose and fix most of the issues.
I hope this article helps you with your iCloud Drive issues. If you have any questions, feel free to ask them in the comments below.

async/await

Fri, 17 Oct 2025 22:36:39 +0200

Let's delve into the fascinating world of Swift's async/await.
This powerful feature, introduced in Swift 5.5, revolutionizes asynchronous programming, making it more intuitive and readable. Buckle up as we explore the ins and outs of async/await!

What is `async/await`?

At its core, async/await simplifies handling asynchronous tasks. It allows you to write asynchronous code that looks almost synchronous. Here's how it works:

async Functions: You mark a function as async. Inside this function, you can use await to pause execution until an asynchronous operation completes.
await Expression: When you encounter an await expression, the function suspends execution until the awaited task finishes. Meanwhile, other tasks can continue running concurrently.

Example 1: Fetching Data

Let's start with a common scenario: fetching data from a remote API. Imagine we have a callback-based function for fetching data:

func fetchData(completion: @escaping (Data?, Error?) -> Void) {
    let url = URL(string: "https://api.example.com/data")!
    URLSession.shared.dataTask(with: url) { data, _, error in
        completion(data, error)
    }.resume()
}

Now, let's convert this to an async function using async/await:

func fetchData() async throws -> Data {
    let url = URL(string: "https://api.example.com/data")!
    return try await URLSession.shared.data(from: url).0
}

In the async version:

We use try await to wait for the data to be fetched.
The error handling is cleaner, thanks to Swift's throws.

Example 2: Multiple API Calls

Imagine we have a callback-based function for fetching data:

func fetchUser(id: Int, completion: @escaping (User?, Error?) -> Void) {
    // Fetch user details...
}

func fetchPosts(for user: User, completion: @escaping ([Post]?, Error?) -> Void) {
    // Fetch posts for the user...
}

// Usage:

fetchUser(id: 1) { user, error in
  guard let user = user else {
    print(error)
  }
  // Guard for no error
  self.fetchPosts(for: user) { posts, error in
    // Process user and posts
  }
}

Suppose we need to fetch a user and then fetch their posts. In the callback-based world, this can get messy. But with async/await, it's elegant:

func fetchUser(id: Int) async throws -> User {
    // Fetch user details...
}

func fetchPosts(for user: User) async throws -> [Post] {
    // Fetch posts for the user...
}

// Usage
Task {
    do {
        let user = try await fetchUser(id: 1)
        let posts = try await fetchPosts(for: user)
        // Process user and posts
    } catch {
        // Handle errors
    }
}

Running multiple tasks concurrently

func fetchUser(id: Int) async -> User {
    // Fetch user details...
}

func fetchPosts(for userID: Int) async -> [Post] {
    // Fetch posts for the user...
}

// Usage
import Foundation

Task {
    async let user = fetchUser(id: 1)
    async let userPosts = fetchPosts(for: 1)

    await updateUI(user: user, userPosts: userPosts)
}

Wait/Sleep in a Task

Task {
    // Delay the task by 1 second:
    try await Task.sleep(nanoseconds: 1_000_000_000)

    // Perform our operation
    // ...
}

Cancellation

func fetchUser(id: Int) async -> User {
    // Fetch user details...
}

func fetchPosts(for userID: Int) async -> [Post] {
    // Fetch posts for the user...
}

// Usage
import Foundation

let task = Task {
    async let user = fetchUser(id: 1)
    async let userPosts = fetchPosts(for: 1)

    await updateUI(user: user, userPosts: userPosts)
}

// Cancel the task
task.cancel()

Difference between `Task` and `Task.detached`

Task is a structured concurrency task that runs within the scope of the current task.
It is automatically cancelled when the parent task is cancelled.

Task.detached is a detached task that runs independently of the current task.
It is not automatically cancelled when the parent task is cancelled.

Ensure that your code is (not)running on the main thread

Explicitly running on the main thread

Task { @MainActor in 

}

Doing heavy work (background) and then updating the UI (main thread/@MainActor)

Task.detached(priority: .userInitiated) {
    await someHeavyBackgroundOperation()
    await MainActor.run {
        // Perform UI updates
    }
}

Doing heavy work on the background using nonisolated and async.

private nonisolated func doHeavyWork() async -> Bool {
  sleep(10)
  return true
}

Task {
    let result = await doHeavyWork()
}

Limitations

async/await is available starting from Swift 5.5.
async/await is not available on all platforms. It is available on iOS 15, macOS 12, watchOS 8, and tvOS 15.
async/await is not available in Objective-C code.

Conclusion

By embracing async/await, you create a better development experience and write more efficient code. Say goodbye to callback hell and welcome a cleaner, more expressive way of handling asynchronous tasks in Swift. 🚀

Resources:
https://docs.swift.org/swift-book/LanguageGuide/Concurrency.html#async-await
https://developer.apple.com/documentation/xcode/improving-app-responsiveness

@dynamicMemberLookup

Fri, 17 Oct 2025 22:36:40 +0200

Let's delve into the fascinating world of Swift's @dynamicMemberLookup. This attribute, introduced in Swift 4.2, provides a powerful mechanism for accessing properties and methods dynamically even those that aren't known until runtime.

What is `@dynamicMemberLookup`?

At its core, @dynamicMemberLookup instructs Swift to call a subscript method when accessing properties.
This method, called subscript(dynamicMember:), is required. Here's how it works:

Attribute Definition: You mark a type (such as a struct or class) with @dynamicMemberLookup.
Subscript Method: You implement the subscript(dynamicMember:) method within that type. This method takes a string parameter representing the name of the requested property and returns any value you like.

Use Case: Dynamic Properties

Let's make a simple example. Imagine we have a Person struct that reads its values from a dictionary:

@dynamicMemberLookup
struct Person {
    private let properties = [
        "name": "Wesley de Groot",
        "city": "Haarlem"
    ]

    subscript(dynamicMember member: String) -> String {
        return properties[member, default: ""]
    }
}

In this case:

The @dynamicMemberLookup attribute ensures that our type handles dynamic member lookup.
The subscript(dynamicMember:) method looks up the member name in the dictionary and returns its value.

Now, we can access properties that don't actually exist as direct properties on the Person type:

let wesley = Person()
print(wesley.name) // Prints "Wesley de Groot"
print(wesley.city) // Prints "Haarlem"
print(wesley.pet) // Prints an empty string

Even though name, city, and pet are not actual properties, they are looked up at runtime.
This feature bridges the gap between Swift's strong type safety and the more relaxed behavior of dynamic languages like PHP and JavaScript.

Conclusion

@dynamicMemberLookup is a powerfull attribute to create easier to read code, it can be used on arrays and therefore also for JSON!

Resources: https://docs.swift.org/swift-book/documentation/the-swift-programming-language/attributes#dynamicMemberLookup

SimpleNetworking

Fri, 17 Oct 2025 22:36:40 +0200

Today i write about my Swift package SimpleNetworking.
It's a simple networking library for Swift it is a wrapper around URLSession and provides a variety of functions to make easy network requests.
You can find the source code and documentation at GitHub https://github.com/0xWDG/SimpleNetworking.

Installation

Install using Swift Package Manager

dependencies: [
    .package(url: "https://github.com/0xWDG/SimpleNetworking.git", .branch("main")),
],
targets: [
    .target(name: "MyTarget", dependencies: [
        .product(name: "SimpleNetworking", package: "SimpleNetworking"),
    ]),
]

Async / Await Examples

import SimpleNetworking

class myApiService {
    // Create a shared instance of SimpleNetworking
    let networking = SimpleNetworking.shared

    init() {
        // Set base URL (optional)
        networking.set(serverURL: "https://wesleydegroot.nl")

        // Set a custom user agent (optional)
        networking.set(userAgent: "My App")

        // Set a custom authorization header (optional)
        networking.set(authorization: "MyToken")

        // Set a custom post type (optional)
        networking.set(postType: .json) // .plain, .json, .graphQL
    }

    /// Get a user (GET request)
    func getUser() async {
        let response = await networking.request(
            path: "/api/getUser", 
            method: .get
        )

        print(response.string)
    }

    /// Update a user (POST request)
    func updateUser() async {
        let response = await networking.request(
            path: "/api/updateUser", 
            method: .post([
                "firstname": "Wesley",
                "lastname": "de Groot"
            ])
        )

        print(response.string)
    }

    /// Get all users (GET request)
    func getUsers() async {
        let response = await networking.request(
            path: "/api/getUsers", 
            method: .get
        )

        struct userProfile: Codable {
            let firstname: String
            let lastname: String
        }

        // Decode the response
        let userProfiles: [userProfile]? = networkResponse.decoded()
        print(userProfiles)
    }
}

Closure Examples

import SimpleNetworking

class myApiService {
    // Create a shared instance of SimpleNetworking
    let networking = SimpleNetworking.shared

    init() {
        // Set base URL (optional)
        networking.set(serverURL: "https://wesleydegroot.nl")

        // Set a custom user agent (optional)
        networking.set(userAgent: "My App")

        // Set a custom authorization header (optional)
        networking.set(authorization: "MyToken")

        // Set a custom post type (optional)
        networking.set(postType: .json) // .plain, .json, .graphQL
    }

    /// Get a user (GET request)
    func getUser() {
        networking.request(
            path: "/api/getUser", 
            method: .get
        ) { response in
            print(response.string)
        }
    }

    /// Update a user (POST request)
    func updateUser() async {
        networking.request(
            path: "/api/updateUser", 
            method: .post([
                "firstname": "Wesley",
                "lastname": "de Groot"
            ])
        ) { response in
            print(response.string)
        }
    }

    /// Get all users (GET request)
    func getUsers() async {
        networking.request(
            path: "/api/getUsers", 
            method: .get
        ) { response in
            struct userProfile: Codable {
                let firstname: String
                let lastname: String
            }

            // Decode the response
            let userProfiles: [userProfile]? = networkResponse.decoded()
            print(userProfiles)
        }
    }
}

Debugging

Enable Debugging

import SimpleNetworking

/// Debug: print NSURLRequest (Default: false)
SimpleNetworking.shared.debug.requestURL = true
/// Debug: print sent HTTP Headers (Default: false)
SimpleNetworking.shared.debug.requestHeaders = true
/// Debug: print sent Cookies (Default: false)
SimpleNetworking.shared.debug.requestCookies = true
/// Debug: print sent Body (Default: false)
SimpleNetworking.shared.debug.requestBody = true
/// Debug: print received HTTP Headers (Default: false)
SimpleNetworking.shared.debug.responseHeaders = true
/// Debug: print received Body (Default: false)
SimpleNetworking.shared.debug.responseBody = true
/// Debug: print received JSON (if any) (Default: false)
SimpleNetworking.shared.debug.responseJSON = true

Example debug output (GET request)

Request:
  GET https://wesleydegroot.nl/

  Headers:
    Content-Type: application/json
    User-Agent: Simple Networking (https://github.com/0xWDG/SimpleNetworking)

  Cookies:

  Body:

HTTPURLResponse:
  HTTP 200
    Cache-Control: max-age=60, private, proxy-revalidate
    Content-Encoding: gzip
    Server: Apache/2
    Content-Type: text/html; charset=UTF-8
    Vary: Accept-Encoding,User-Agent
    Date: Mon, 26 Feb 2024 19:50:42 GMT

  Body:
    ... HTTP BODY ...

  Decoded JSON:
    Unable to parse JSON

Example debug output (POST request)

Request:
  POST https://wesleydegroot.nl/api/userUpdate

  Headers:
    User-Agent: Simple Networking (https://github.com/0xWDG/SimpleNetworking)
    Content-Type: application/json

  Cookies:

  Body:
    {"age":33,"firstname":"Wesley","lastname":"de Groot"}

HTTPURLResponse:
  HTTP 200
    Content-Encoding: gzip
    Content-Type: text/html; charset=UTF-8
    Vary: Accept-Encoding,User-Agent
    Cache-Control: max-age=60, private, proxy-revalidate
    Server: Apache/2
    Date: Mon, 26 Feb 2024 19:52:58 GMT

  Body:
    {"status":"user updated","code":200}

  Decoded JSON:
    ["status": user updated, "code": 200]

Wrap up

SimpleNetworking is a simple networking library for Swift it is a wrapper around URLSession and provides a variety of functions to make easy network requests.
You can find the source code and documentation at GitHub https://github.com/0xWDG/SimpleNetworking.

If you have any questions or suggestions, feel free to contact me on Twitter/X or comment below this post.

Aurora Editor

Fri, 17 Oct 2025 22:36:41 +0200

Aurora Editor: A Swift-Powered IDE for Efficient Coding

Introduction

As developers, we're always on the lookout for tools that enhance our productivity, streamline our workflows, and make coding a delightful experience. Enter Aurora Editor, a lightweight and fast IDE built by the community, for the community. Let's explore what makes this editor stand out and why it's gaining traction among programmers.

What Is Aurora Editor?

Built on Familiar Ground: Aurora Editor is not a replacement for Xcode; instead, it's an extensible, superlight editor that leverages the fundamentals of Xcode. If you're comfortable with Xcode, you'll find Aurora Editor's interface familiar and easy to navigate.
Swift-Powered Performance: Written entirely in Swift, Aurora Editor boasts lightning-fast performance on macOS. Whether you're working on a small project or a large codebase, Aurora keeps up with your pace.

Key Features

Efficiency: Aurora Editor lets you build projects swiftly and smoothly. Its lightweight design ensures that you spend less time waiting and more time coding.
Extensibility: Need additional functionality? Aurora Editor is extensible, allowing you to add custom features or integrate existing plugins seamlessly.
Intuitive Interface: Say goodbye to cluttered screens. Aurora's clean interface ensures that you focus on what matters—your code.
Language Support: Craft your projects in your favorite programming languages. Aurora supports a wide range of languages, making it versatile for various development tasks.

Why Aurora Editor?

As a developer, you might wonder why you should consider Aurora Editor alongside other popular IDEs. Here's why:

Fast: If you're a fan of speed then Aurora Editor is your go-to choice. It's designed to be fast and responsive, ensuring that you don't experience any lags or delays.
One-Stop Solution: Aurora Editor is a one-stop solution for all your coding needs. Whether you're working on a personal project or a team-based assignment, Aurora Editor has you covered.
Extensible: The ability to extend Aurora Editor's functionality is a game-changer. You can tailor the editor to your specific needs, making it a powerful tool in your arsenal.

Meet the Community

The Aurora Editor community is a vibrant group of developers who are passionate about creating a better coding experience. Whether you're a seasoned developer or a beginner, you'll find a welcoming environment where you can share ideas, seek help, and contribute to the editor's growth.
Keep an eye on the Aurora Editor community for updates, tips, and tricks that will enhance your coding journey.

Conclusion

Aurora Editor isn't just an IDE; it's a community-driven tool that prioritizes speed, simplicity, and extensibility. So, next time you're coding, consider giving Aurora Editor a spin. Who knows—you might find yourself creating masterful code with a touch of Aurora magic! ✨

Learn More About Aurora Editor

Lead maintainers: Wesley de Groot, nanashili.
Website: Aurora Editor Website
GitHub: Aurora Editor on GitHub
Twitter: Aurora Editor on Twitter
Discord: Aurora Editor Discord

Help Aurora Editor Grow

If you're passionate about Aurora Editor and want to contribute to its growth, consider joining the community, sharing your ideas, and contributing to the editor's development. Together, we can make Aurora Editor the go-to choice for developers worldwide.

Help develop Aurora Editor

If you want to help develop Aurora Editor, you can find the source code on GitHub, we are always looking for new contributors. no matter if you are a developer, designer, or just want to help out, we are always looking for new contributors.

References:
Aurora Editor Overview - Aurora Company

Translating closures to async

Fri, 17 Oct 2025 22:36:41 +0200

In this post, we will discuss how to translate closures to async in Swift.

What is `continuation`?

In Swift, a continuation is a construct that allows you to suspend and resume execution of a piece of code at a later time. It's often used in the context of asynchronous programming.

When you're dealing with asynchronous tasks, you often need to wait for some operation to complete before you can continue with the rest of your code. This is where continuation comes in.

You can think of a continuation as a placeholder for the future result of an asynchronous operation. When the operation is complete, you can "resume" the continuation with the result, allowing the rest of your code to proceed.

In Swift 5.5 and later, continuation is often used in the implementation of async/await patterns. For example, you might use a continuation to wrap a callback-based asynchronous API into a function that can be used with await.

Use Case: continuation

Imagine you have a function that takes a callback as an argument, and you want to convert it to an async function. Here's an example of what that might look like:

func fetchData(completion: @escaping (Result<Data, Error>) -> Void) {
    // Perform some asynchronous operation
    // ...
    // When the operation is complete, call the completion handler
    completion(.success(data))
}

This function takes a completion handler as an argument, and when the asynchronous operation is complete, it calls the completion handler with the result.

To convert this function to an async function, you can use a continuation. Here's how you might do that:

func fetchData() async throws -> Data {
    return try await withCheckedThrowingContinuation { continuation in
        fetchData { result in
            switch result {
            case .success(let data):
                continuation.resume(returning: data)
            case .failure(let error):
                continuation.resume(throwing: error)
            }
        }
    }
}

Example 2:

Imagine we have a function whihout Result type, and we want to convert it to an async function. Here's an example of what that might look like:

func fetchData(completion: @escaping (Data?, Error?) -> Void) {
    // Perform some asynchronous operation
    // ...
    // When the operation is complete, call the completion handler
    completion(data, error)
}

To convert this function to an async function, you can use a continuation. Here's how you might do that:

func fetchData() async throws -> Data {
    return try await withCheckedThrowingContinuation { continuation in
        fetchData { data, error in
            if let data = data {
                continuation.resume(returning: data)
            } else if let error = error {
                continuation.resume(throwing: error)
            }
        }
    }
}

`withCheckedThrowingContinuation` vs `withUnsafeContinuation`

withCheckedContinuation will add runtime checks to detect any improper use of the continuation and warn you if it were to happen. withUnsafeContinuation will perform none of these checks.

Caveats

continuation must be called exactly once.

Wrap up

Continuations are a powerful tool for working with asynchronous code in Swift. They allow you to suspend and resume execution of a piece of code at a later time, making it easier to work with asynchronous operations.

Resources: https://developer.apple.com/documentation/swift/checkedcontinuation
https://developer.apple.com/documentation/swift/withcheckedcontinuation(function:_:)

Localizing In Xcode

Fri, 17 Oct 2025 22:36:42 +0200

Localizing and Varying Text with a String Catalog

Your app's success hinges on delivering an exceptional experience to users across different locales. Localization is more than just translating text; it involves handling plurals, adapting content for specific devices, and ensuring your app speaks the user's language. In this blog post, we'll explore how to achieve this using string catalogs in Xcode.

What Is a String Catalog?

A string catalog is a powerful tool that allows you to:

Localize all your app's text.
Translate strings visually within Xcode.
Handle plurals for nouns and units.
Vary text based on specific devices.

Making Text Localizable

Before translation, you need to make your text localizable. Here's how:

Wrap User-Facing Strings:
- In SwiftUI, string literals within a view are automatically localizable:
```
// SwiftUI localizable text
Text("Welcome")
```
- For non SwiftUI, use the String(localized:) initializer:
```
// General localizable text
String(localized: "Buy a book")
```

Add Context Comments:

Assist localizers by providing context:

// Localizable text with comments
Text("Explore", comment: "The title of the tab bar item that navigates to the Explore screen.")

String(localized: "Get Started", comment: "The label on the Get Started button that appears after sign-in.")

Adding a String Catalog to Your Project

Create a String Catalog:
- Choose File > New > File in Xcode.
- Select the platform, enter "string" into the filter field, and choose String Catalog.
- Name it (e.g., "Localizable").
- Xcode will automatically track localizable strings from your code.

Multiple String Catalogs:

If your catalog grows, create multiple string catalog files within the same project.

Pass the catalog name to localization APIs:

// SwiftUI pointing to a specific string catalog
Text("Explore", tableName: "Navigation")

// General text pointing to a specific string catalog
String(localized: "Get Started", table: "MainScreen")

Adding Languages:
- To support multiple languages, add additional languages to your project.
- Xcode keeps your string catalog and app in sync during builds.

Conclusion

String catalogs simplify localization, streamline translations, and enhance the user experience.

References:

Dive into GIT

Fri, 17 Oct 2025 22:36:42 +0200

Let's dive into the world of GIT. Whether you're a seasoned developer or just starting out, understanding these commands is crucial for efficient version control and collaboration. Below, I'll introduce some essential Git commands that every developer should know:

Cloning a Repository

Clone an existing repository to your local machine using git clone <repository-url>.
It creates a copy of the entire project.
note: This does not fetch the submodules, use git clone --recurse-submodules <repository-url> to fetch the submodules.

Creating a Repository

Use git init for initializing a Repository

Adding a Remote

Use git remote add for Adding a Remote
e.g. git remote add origin https://github.com/0xWDG/repisotory.git

Staging Changes

use git add for Staging Changes
Add specific files or entire directories to the staging area using git add <file> or git add ..
A quick (and dirty) way to stage all changes is git add -A ..

Creating a Commit

use git commit for Creating a commit
After staging changes, create a commit (snapshot) with a meaningful message using git commit -m "Your message here".
Commits help track the history of your project.
If you want to add all changes and commit in one step, use git commit -am "Your message here".

Pushing Changes to Remote

use git push for Pushing changes to remote.
This shares your work with others and updates the remote branch.

Updating from Remote

Pull changes from a remote repository using git pull.
It fetches and merges the latest changes into your local branch.

Current Status

use git status for Checking the current status
It shows which files are modified, staged, or untracked.

See commit history

View the commit history with git log.
It displays information about each commit, including the author, date, and commit message.

Branching

Create a new branch using git branch <branch-name>.
Switch between branches with git checkout <branch-name>.
Delete a branch with git branch -d <branch-name>.
List all branches with git branch.

Combining Branches

Merge changes from one branch into another using git merge.
It combines the commit history of both branches.

Reverting Changes

Revert changes using git revert.
e.g. git revert <commit-hash>.
It creates a new commit that undoes the changes made in the specified commit.

Stashing Changes

Use git stash to stash changes.
It temporarily stores changes that are not ready to be committed.

Tagging

Create a tag using git tag -a <tag-name>.

💡 Tip: Use tags to mark important milestones, such as releases or versions.
e.g. git tag -a v1.0 -m "Version 1.0"

Push tags to the remote repository using git push --tags.

💡 Tip: Create the tag after the commit you want to tag.

Tagging a Specific Commit

Create a tag for a specific commit using git tag -a <tag-name> <commit-hash>.
e.g. git tag -a v1.0 9fceb02

Ignoring Files

Create a .gitignore file to ignore specific files or directories.

💡 Tip: Use wildcards to ignore files with a specific extension or pattern.
e.g. *.log or node_modules/

Syncing Forks

Sync a forked repository with the original repository using git fetch upstream.
It fetches the latest changes from the original repository.
Then merge the changes into your forked repository using git merge upstream/<branch>.
Finally, push the changes to your forked repository using git push origin <branch>.

NOTE: You should setup the original repository as a remote using git remote add upstream <repository-url>.
e.g. git remote add upstream https://github.com/0xWDG/original-repisotory.git

Script to sync fork

I use this script to sync my forked repositories with the original repository.
i have it in my ~/bin directory and it is called sync.
before using it, make sure to make it executable with chmod +x ~/bin/sync and add ~/bin to your $PATH variable.

You can use it like sync to sync the current branch or sync <branch-name> to sync a specific branch.

#/bin/zsh

if [ ! -d ".git" ]; then
    echo "Not a git repository"
    exit
fi

if [ -z "`git remote -v | grep upstream`" ]; then
    echo "Upstream remote not found"
    echo "Add upstream remote with:"
    echo "git remote add upstream https://original/path/to/repo.git"
    exit
fi

if [ -z "$1" ]; then
    BRANCH=`git branch --show-current`
else
    if [ -z "`git branch -l $1`" ]; then
        echo "Branch $1 does not exists"
        exit
    fi

    BRANCH=$1
fi

echo "Syncing with upstream/$BRANCH"
git fetch upstream
git merge upstream/$BRANCH -m "Fork Sync"
git push origin $BRANCH

Viewing Changes

Use git diff to view changes between commits, branches, or files.
It shows the differences between the working directory and the staging area.

Viewing Remote URLs

View the remote URLs with git remote -v.
It displays the fetch and push URLs for each remote.

Viewing Remote Branches

View remote branches with git branch -r.
It lists all remote branches.

Viewing Local Branches

View local branches with git branch.
It lists all local branches.

Viewing Tags

View tags with git tag.
It lists all tags.

Dangerous but useful commands:

Resetting changes on fork to match original repository

# pulls all new commits made to upstream/branch
git pull upstream $BRACNH

# this will delete all your local changes to branch
git reset --hard upstream/$BRACNH

# take care, this will delete all your changes on your forked branch
git push origin $BRACNH --force

Delete all commits

Replace $BRANCH with the name of the branch you want to delete all commits from.

# This will create a new branch called latest_branch
git checkout --orphan latest_branch

# This adds all the files in the directory to the staging area.
git add -A

# This creates a new commit. (initial commit)
git commit -a -m "Initial commit"

# This deletes the $BRANCH branch
git branch -D "$BRANCH"

# This renames the latest_branch to $BRANCH
git branch -m "$BRANCH"

# This pushes the new branch to the remote repository
git push -f origin "$BRANCH"

Resources:

What is @MainActor

Fri, 17 Oct 2025 22:36:43 +0200

In the ever-evolving world of Swift, concurrency has become a hot topic. With the introduction of Swift Concurrency, developers now have powerful tools at their disposal to write more efficient and responsive code. One such tool is the @MainActor attribute, which allows us to seamlessly execute code on the main queue.

What is `@MainActor`?

@MainActor is a global actor that utilizes the main queue for executing its work. In practical terms, this means that methods or types marked with @MainActor can safely modify the UI because they will always run on the main queue. Additionally, calling MainActor.run() allows us to push custom work to the main actor, ensuring it executes on the main queue.

Use Case: `@MainActor`

In the view model of a SwiftUI app, we often use @Published properties to update the UI. By marking the entire view model with @MainActor, we ensure that these UI updates always occur on the main queue. Here's an example:

@MainActor
class AccountViewModel: ObservableObject {
    @Published var username = "Anonymous"
    @Published var isAuthenticated = false
}

The view model is marked with @MainActor, ensuring that any UI updates triggered by username or isAuthenticated always occur on the main queue. This is particularly useful when working with SwiftUI, where UI updates must always occur on the main queue.

struct AccountView: View {
    @StateObject var viewModel = AccountViewModel()

    var body: some View {
        VStack {
            Text("Welcome, \(viewModel.username)!")
                .font(.title)
                .padding()

            Text(viewModel.isAuthenticated  ? "You are logged in." : ("You are not logged in.")
                .font(.headline)
                .padding()
        }
    }
}

In this example, both username and isAuthenticated properties update the UI. By marking the entire class with @MainActor, we ensure that these UI updates always happen on the main actor. SwiftUI even takes care of this for us when we use @StateObject or @ObservedObject inside a view – the whole view runs on the main actor.

Why Explicitly Use `@MainActor`?

You might wonder: if SwiftUI already ensures main-actor behavior, why bother adding @MainActor explicitly? Here are a few reasons:

Beyond SwiftUI: While SwiftUI handles main-actor behavior for observable objects, there are scenarios where our view models might be used outside of SwiftUI – perhaps in UIKit-based parts of our app or in more general Swift contexts. Explicitly marking them with @MainActor ensures consistent behavior across different contexts.
Async/Await: If our view models perform their own asynchronous work (e.g., downloading data from a server using async/await), @MainActor remains beneficial. It guarantees that UI updates always occur on the main actor.
Opting Out: If certain methods or computed properties should not run on the main actor, we can use nonisolated – similar to how we do with regular actors.

Global Actor Inference

Interestingly, any type containing properties of @MainActor objects also implicitly becomes @MainActor using global actor inference. Swift applies precise rules to ensure global-actor behavior works seamlessly without causing unnecessary hurdles.

In summary, @MainActor is a powerful tool for making UI updates safer and more predictable. Whether you're building SwiftUI views or working with UIKit, embracing @MainActor ensures your code dances gracefully on the main stage – the main queue.

Remember: actors are not suitable for observable objects; they must handle UI updates on the main actor. This is where @MainActor comes into play, ensuring that UI updates always occur on the main queue.

Caveats

While @MainActor is a powerful tool, it's important to use it judiciously. Overusing @MainActor can lead to performance issues, as it forces all work to run on the main queue. Always consider whether a given piece of code truly needs to run on the main queue before marking it with @MainActor.

Conclusion

Swift Concurrency has brought a new era of powerful tools to the Swift language. @MainActor is one such tool, allowing us to ensure that UI updates always occur on the main queue. By marking our types and methods with @MainActor, we can make our code safer and more predictable, ensuring that UI updates always occur on the main queue.

Resources:

https://developer.apple.com/documentation/swift/mainactor

ContentUnavailableView

Fri, 17 Oct 2025 22:36:44 +0200

In the ever-evolving world of SwiftUI, creating a seamless user experience involves handling empty states gracefully. Whether it's due to networking failures or empty search results, providing clear feedback to users is crucial. Enter ContentUnavailableView, a powerful SwiftUI component introduced in iOS 17 during WWDC 2023. In this article, we'll explore how to use it effectively and why it's a valuable addition to your toolkit.

What is `ContentUnavailableView`?

ContentUnavailableView is a specialized SwiftUI view designed specifically for presenting empty states. It's your go-to solution when you need to communicate to users that content is unavailable due to various reasons. By leveraging this view, you can maintain consistency across your app while ensuring accessibility and localization.

Use Case: Search Empty State

In this example, if there are no search results while the query is non-empty, we display the ContentUnavailableView. The resulting view looks familiar to users, as it's widely used across the system. Plus, it automatically translates into the languages your app supports.

struct ContentView: View {
    @Bindable
    var pokemon: PokemonViewModel

    var body: some View {
        NavigationStack {
            List(pokemon.pokemon, id: \.self) { pokemon in
                Text(verbatim: pokemon)
            }
            .navigationTitle("Pokémon")
            .overlay {
                if pokemon.pokemon.isEmpty {
                    ContentUnavailableView.search(text: pokemon.query)
                }
            }
            .searchable(text: $pokemon.query)
        }
    }
}

Use Case: No Internet Connection

NetworkMonitor.swift

import SwiftUI
import Network

final class NetworkMonitor: ObservableObject {
    @Published
    var isConnected = true

    let monitor = NWPathMonitor()

    init() {
        monitor.pathUpdateHandler = { [weak self] path in
            if path.status == .satisfied {
                // Internet connection is available
                self?.isConnected = true
            } else {
                // Internet connection is not available
                self?.isConnected = false
            }
        }

        // Start monitoring
        let queue = DispatchQueue(label: "Monitor")
        monitor.start(queue: queue)
    }
}

import SwiftUI

struct ContentView: View {
    @ObservedObject
    private var network = NetworkMonitor()

    @ObservedObject
    var pokemon: PokemonViewModel

    var body: some View {
        NavigationStack {
            List(pokemon.pokemon, id: \.self) { pokemon in
                Text(verbatim: pokemon)
            }
            .navigationTitle("Pokémon")
            .overlay {
                if !network.isConnected {
                    ContentUnavailableView {
                        Label(
                            "Connection issue", 
                            systemImage: "wifi.slash"
                        )
                    } description: {
                        Text("Check your internet connection")
                    } actions: {
                        Button("Refresh") {
                            pokemon.fetch()
                        }
                    }
                }
            }
        }
    }
}

Combined Use Case: No Internet Connection and Empty Search Results

NetworkMonitor.swift

import SwiftUI
import Network

final class NetworkMonitor: ObservableObject {
    @Published
    var isConnected = true

    let monitor = NWPathMonitor()

    init() {
        monitor.pathUpdateHandler = { [weak self] path in
            if path.status == .satisfied {
                // Internet connection is available
                self?.isConnected = true
            } else {
                // Internet connection is not available
                self?.isConnected = false
            }
        }

        // Start monitoring
        let queue = DispatchQueue(label: "Monitor")
        monitor.start(queue: queue)
    }
}

PokemonViewModel.swift

import SwiftUI

class PokemonViewModel: ObservableObject {
    @Published
    var query = "" {
        didSet {
            fetch()
        }
    }

    @Published
    var pokemon: [String] = ["Dragonite", "Pikachu", "Lugia"]

    func fetch() {
        if query.isEmpty {
            pokemon = ["Dragonite", "Pikachu", "Lugia"]
            return
        }

        if query.lowercased().hasPrefix("d") {
            pokemon = ["Dragonite"]
        }

        if query.lowercased().hasPrefix("p") {
            pokemon = ["Pikachu"]
        }

        if query.lowercased().hasPrefix("l") {
            pokemon = ["Lugia"]
        }
    }
}

ContentView.swift

import SwiftUI

struct ContentView: View {
    @ObservedObject
    private var network = NetworkMonitor()

    @ObservedObject
    var pokemon = PokemonViewModel()

    var body: some View {
        NavigationStack {
            List(pokemon.pokemon, id: \.self) { pokemon in
                Text(verbatim: pokemon)
            }
            .navigationTitle("Pokémon")
            .overlay {
                if !network.isConnected {
                    ContentUnavailableView {
                        Label(
                            "Connection issue", 
                            systemImage: "wifi.slash"
                        )
                    } description: {
                        Text("Check your internet connection")
                    } actions: {
                        Button("Refresh") {
                            pokemon.fetch()
                        }
                    }
                }
                if network.isConnected && pokemon.pokemon.isEmpty && !pokemon.query.isEmpty {
                    ContentUnavailableView.search(text: pokemon.query)
                }
            }
            .searchable(text: $pokemon.query)
        }
    }
}

Download the full example

Caveats

While ContentUnavailableView is a powerful tool, it's not suitable for all scenarios. especially when handling empty states or situations where your app’s content cannot be displayed, and in complex situations a custom view may be better for empty state handling.

Benefits of Using ContentUnavailableView

Consistency: By reusing a standard component, you ensure a consistent look and feel throughout your app.
Localization: The view automatically adapts to the languages your app supports.
SwiftUI Integration: It seamlessly integrates with SwiftUI's navigation stack and other components.

Conclusion

ContentUnavailableView is a valuable addition to your SwiftUI toolkit. It's a powerful tool for handling empty states gracefully, ensuring a consistent user experience across your app. By leveraging this view, you can communicate to users that content is unavailable due to various reasons, such as networking failures or empty search results. This results in a more seamless and accessible user experience.

Resources:

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

Pull-to-Refresh in SwiftUI

Fri, 17 Oct 2025 22:36:44 +0200

Pull-to-refresh is a common UI pattern in iOS apps.
It allows users to refresh the content of a view by pulling down on it.
In this post, we will learn how to implement pull-to-refresh in SwiftUI, using the refreshable modifier.

What is `Pull-to-refresh`?

Pull-to-refresh is a common UI pattern in iOS apps that allows users to refresh the content of a view by pulling down on it.

Use Case: Pull to refresh

Let’s start with a simple example where you have a List displaying items.
It should also provide a pull-to-refresh gesture to update the list of items.

import SwiftUI

struct ContentView: View {
    @State private var items = [String](repeating: "Item", count: 10)

    var body: some View {
        List {
            ForEach(items, id: \.self) { item in
                Text(item)
            }
        }
        .refreshable {
            items = [String](repeating: "Refreshed items", count: 10)
        }
    }
}

Download the sample code for Swift Playgrounds

In the example above, we attach the refreshable view modifier to the List view, configuring the pull-to-refresh gesture.

Wrap up

SwiftUI's refreshable modifier makes it easy to add pull-to-refresh to your app.

Conclusion

In this post, we learned how to implement pull-to-refresh in SwiftUI, using the refreshable modifier.

Resources:

Apple Developer Documentation

TipKit

Fri, 17 Oct 2025 22:36:45 +0200

Let's delve into the fascinating world of TipKit, a powerful framework that empowers developers to create and customize app tips.
Whether you're aiming to introduce new features, reveal hidden functionalities, or enhance user productivity, TipKit has got you covered.

What Is TipKit?

TipKit is a framework designed by Apple that enables you to seamlessly integrate contextual tips into your app.
These tips serve as educational moments, guiding users toward discovering features they might not have stumbled upon organically.
With TipKit, you can:

Customize Appearance: Tailor the look and feel of your tips to match your app's design.
Define Content: Craft engaging messages that highlight specific features or provide useful information.
Control Eligibility: Specify conditions for when tips should appear, ensuring they reach the right audience at the right time.

Creating Your First Tip

Let's dive into creating a simple tip using SwiftUI.
Imagine we want to highlight the "Save as a Favorite" feature in our app.

Here's how you can do it:

import SwiftUI
import TipKit

// Define your tip's content
struct TipKitTip: Tip {
    var title: Text {
        Text("Title")
    }
    var message: Text? {
        Text("Message")
    }
    var image: Image? {
        Image(systemName: "star")
    }
}

struct ContentView: View {
    // Create an instance of your tip
    var tipKitTip = TipKitTip()

    var body: some View {
        VStack {
            // Place the tip view near the feature you want to highlight
            TipView(tipKitTip, arrowEdge: .bottom)
            Image(systemName: "star")
                .imageScale(.large)
            Spacer()
        }
        .task {
            // Configure and load your tips at app launch
            try? Tips.configure([
                .displayFrequency(.immediate),
                .datastoreLocation(.applicationDefault)
            ])
        }
    }
}

Download the sample code for Swift Playgrounds

Best Practices for Using Tips

Be Selective: Use tips sparingly to highlight non-obvious features. Avoid overwhelming users with too many tips.
Avoid Overuse: Don't display tips every time someone uses your app. They can become distracting.
No Guided Tours: Tips are not meant for guiding users through your app step-by-step.
Effective Targeting: Use eligibility rules and display frequency to ensure tips reach the right audience.

Remember, TipKit is a powerful tool, but like any tool, it's most effective when used thoughtfully.

Resources:

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

Implementing Sign in with Apple

Fri, 17 Oct 2025 22:36:45 +0200

Sign in with Apple is a user-friendly authentication method that allows users to sign in to apps and websites using their Apple ID.
In this blog post, we'll explore how to integrate Sign in with Apple into your Swift-based iOS app for UIKit and SwiftUI based apps.

Overview

Sign in with Apple is a powerful authentication solution that simplifies user access to apps and websites.

Here's what you need to know:

Easy Sign-In: Instead of cumbersome forms and password management, users can sign in using their Apple ID. No more remembering passwords or verifying email addresses!
Privacy First: Apple prioritizes user privacy. Data collection is limited to the user's name and email address. Plus, Apple's private email relay ensures that users receive emails while keeping their address confidential.
Two-Factor Authentication: Every account using Sign in with Apple is automatically protected with two-factor authentication. Users on Apple devices can reauthenticate anytime with Face ID or Touch ID.
Cross-Platform Compatibility: Sign in with Apple works seamlessly across iOS, iPadOS, macOS, tvOS, and watchOS. It's also compatible with any browser, making it suitable for web and app development.
Antifraud Measures: Detect fake accounts with Apple's on-device machine learning. Get a privacy-friendly signal to identify genuine users.

Prerequisites

Before diving into implementation, ensure you have the following:

Apple Developer Account: You'll need an active Apple Developer account to configure Sign in with Apple.
Xcode: Make sure you have Xcode installed on your development machine.

Step-by-Step Implementation

1. Configure Your Project

Open your project in Xcode.
Navigate to the Signing & Capabilities pane.
Set a unique bundle identifier for your app.
Add your Apple ID account and assign the target to a team (enabling Sign in with Apple capability).

2. Add the Sign in with Apple Button

In your view controller or SwiftUI view, add the Sign in with Apple button. Here's how:

UIKit (View Controller)

import AuthenticationServices

class LoginViewController: UIViewController {
    func setupProviderLoginView() {
        let authorizationButton = ASAuthorizationAppleIDButton(
            type: .signIn,
            style: .whiteOutline
        )

        authorizationButton.addTarget(
            self,
            action: #selector(handleAuthorizationAppleIDButtonPress),
            for: .touchUpInside
        )

        self.addSubview(authorizationButton)
    }

    @objc func handleAuthorizationAppleIDButtonPress() {
        let appleIDProvider = ASAuthorizationAppleIDProvider()
        let request = appleIDProvider.createRequest()
        request.requestedScopes = [.fullName, .email]

        let authorizationController = ASAuthorizationController(authorizationRequests: [request])
        authorizationController.delegate = self
        authorizationController.presentationContextProvider = self
        authorizationController.performRequests()
    }
}

// MARK: - Sign in with Apple
extension LoginViewController: ASAuthorizationControllerDelegate,
                               ASAuthorizationControllerPresentationContextProviding {
    func presentationAnchor(for controller: ASAuthorizationController) -> ASPresentationAnchor {
        return self.view.window!
    }

    func authorizationController(
        controller: ASAuthorizationController,
        didCompleteWithAuthorization authorization: ASAuthorization
    ) {
        switch authorization.credential {
        case let appleIDCredential as ASAuthorizationAppleIDCredential:
            // Create an account in your system.
            let userIdentifier = appleIDCredential.user
            let fullName = appleIDCredential.fullName
            let email = appleIDCredential.email
            let JWTToken = appleIDCredential.identityToken
            let authCode = appleIDCredential.authorizationCode

            dump(appleIDCredential)
            // Close login window.

        case let passwordCredential as ASPasswordCredential:
            // Sign in using an existing iCloud Keychain credential.
            let username = passwordCredential.user
            let password = passwordCredential.password

            print(passwordCredential)
            // Close login window

        default:
            break
        }
    }

    func authorizationController(controller: ASAuthorizationController, didCompleteWithError error: Error) {
        // Handle error.
        print("Something went wrong", error)
    }

    func performExistingAccountSetupFlows() {
        // Prepare requests for both Apple ID and password providers.
        let requests = [ASAuthorizationAppleIDProvider().createRequest(),
                        ASAuthorizationPasswordProvider().createRequest()]

        // Create an authorization controller with the given requests.
        let authorizationController = ASAuthorizationController(authorizationRequests: requests)
        authorizationController.delegate = self
        authorizationController.presentationContextProvider = self
        authorizationController.performRequests()
    }
}

SwiftUI

import SwiftUI
import AuthenticationServices

struct ContentView: View {
    var body: some View {
        SignInWithAppleButton(.signIn) { request in
            request.requestedScopes = [.fullName, .email]
        } onCompletion: { result in
            switch result {
            case .success(let authorization):
                if let userCredential = authorization.credential as? ASAuthorizationAppleIDCredential {
                    dump(userCredential)
                }

            case .failure(let error):
                print("Could not authenticate: \(error.localizedDescription)")
            }
        }
        .signInWithAppleButtonStyle(.whiteOutline)
        .frame(width: 280, height: 45)
    }
}

Download SwiftUI Playground

`SignInWithAppleButton(.label)`

.continue: Continue label
signIn: Sign in with Apple label on the button.
signUp: Sign up with Apple label on the button.

`.signInWithAppleButtonStyle(.style)`

black: black button.
white: white button.
whiteOutline: white-outlined button.

`Error codes`

ASAuthorizationError.unknown: Unknown error.
ASAuthorizationError.canceled: User canceled the request.
ASAuthorizationError.failed: Authorization failed.
ASAuthorizationError.invalidResponse: Invalid response.
ASAuthorizationError.notHandled: Request not handled.
ASAuthorizationError.unknown: Unknown error.

3. User is signed in

Cache the name and email address of the user, this will be given once to the application.

Caveats

The user's name and email are only given once, this is expected behaviour.

It is recommened that you securely cache the initial ASAuthorizationAppleIDCredential containing the user info until you can validate that an account has succesfully been created on your server.
Source: https://forums.developer.apple.com/thread/121496#379297

Server-side validation may be needed, depending on your needs.

Conclusion

Sign in with Apple provides a seamless and secure authentication experience for your users.
It's easy to implement for usage in your app.

Resources

https://developer.apple.com/documentation/authenticationservices/implementing_user_authentication_with_sign_in_with_apple

Default values for UserDefaults

Fri, 17 Oct 2025 22:36:46 +0200

UserDefaults (NSUserDefaults) is a go-to database for saving users' preferences over application behavior.

What is `UserDefaults`?

UserDefaults is a simple key-value store that allows you to save small amounts of data such as user preferences, settings, and other application state information. It is commonly used to store user settings, such as the user's preferred language, theme, or notification preferences.

Use Case: `UserDefaults.register`

let userDefaults = UserDefaults.standard
userDefaults.register(
    defaults: [
        "selectedPokemon": "Pikachu",
        "pokemonCanEvolve": true
    ]
)

userDefaults.bool(forKey: "pokemonCanEvolve") // true.

Warning: The register(defaults:) method only sets the default values if the key does not exist in the user defaults, it will not save the default values to the user defaults. Therefore, you should call this method each time your app launches to ensure that the default values are set.

Caveats

UserDefaults saves data in a local plist file on disk.
This means that the user can access and modify the data if they have access to the device, therefore it is not suitable for storing sensitive information such as passwords or tokens.
Registering default values will not save the default values to disk, therefore you should call this method each time your app launches to ensure that the default values are set.
UserDefaults is not suitable for large data storage; consider using Core Data for that purpose.
NSUbiquitousKeyValueStore which is the cloud-enabled UserDefaults that can be used to synchronize data between devices using iCloud, has a limit of 1MB for the total size of the data, and a limit of 1024 keys.

Wrap up

UserDefaults is a simple way to store small amounts of data such as user preferences, settings, and other application state information. It is not suitable for storing sensitive information or large amounts of data.

Resources:
https://developer.apple.com/documentation/foundation/userdefaults

SwiftUI ViewModifiers

Fri, 17 Oct 2025 22:36:46 +0200

SwiftUI ViewModifiers are a powerful tool for customizing and enhancing views in your app. They allow you to encapsulate common view modifications into reusable, composable units, making it easy to apply the same changes to multiple views throughout your app

What is a `View modifier`?

View modifier is a very important concept of SwiftUI. If you have a chance to play around with SwiftUI you might have seen one already like .background, .padding, ...

SwiftUI already provided plenty of modifiers, but you can also create a custom one with a simple protocol, ViewModifier.

Example 1: Blue Border

struct BlueBorder: ViewModifier {
    func body(content: Content) -> some View {
        return content
            .padding(2)
            .border(.blue, width: 1)
    }
}

Use it like this:

Import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Text("Hello, World!")
                .modifier(BlueBorder())
        }
    }
}

Or you can create an extension to make it more readable:

extension View {
    @warn_unqualified_access
    func blueBorder() -> some View {
        self.modifier(BlueBorder())
    }
}

Then you can use it like this:

Text("Hello, World!")
    .blueBorder()

Example 2: Card view

struct CardBackground: ViewModifier {
    func body(content: Content) -> some View {
        content
            .padding(10)
            .background(
                Color(UIColor.systemGroupedBackground)
            )
            .cornerRadius(20)
            .shadow(
                color: Color.black.opacity(0.2),
                radius: 4
            )
    }
}

Use it like this:

Import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Text("Hello, World!")
                .modifier(CardBackground())
        }
    }
}

Or you can create an extension to make it more readable:

extension View {
    @warn_unqualified_access
    func cardBackground() -> some View {
        self.modifier(CardBackground())
    }
}

Then you can use it like this:

Import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Text("Hello, World!")
                .cardBackground()
        }
    }
}

Example 3: Custom Button

struct CustomButton: ViewModifier {
    func body(content: Content) -> some View {
        content
            .padding(10)
            .background(Color.blue)
            .foregroundColor(.white)
            .cornerRadius(20)
            .shadow(
                color: Color.black.opacity(0.2),
                radius: 4
            )
    }
}

Use it like this:

Import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Button("Hello, World!") {
                print("Hello, World!")
            }.modifier(CustomButton())
        }
    }
}

Or you can create an extension to make it more readable:

extension View {
    @warn_unqualified_access
    func customButton() -> some View {
        self.modifier(CustomButton())
    }
}

Then you can use it like this:

Import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Button("Hello, World!") {
                print("Hello, World!")
            }.customButton()
        }
    }
}

Example 4: Spoiler support

struct Spoiler: ViewModifier {
    // visibility of the spoiler warning
    @State var isHidden: Bool = true

    func body(content: Content) -> some View {
        // A ZStack is a view that overlays its children
        ZStack(
            alignment: .center, 
            content: {            
            if isHidden {
                // User can't see the content.

                // Blur the content
                content
                    .layoutPriority(1)
                    .blur(radius: 30)
                    .clipped()

                // Add a spoiler warning
                VStack {
                    Image(
                        systemName: "eye.slash.fill"
                    )
                        .foregroundColor(.white)

                    Text("Spoiler")
                        .font(.caption)
                        .bold()
                        .foregroundColor(.white)
                }
            } else {
                // User can see the content
                content
            }
        }).onTapGesture {
            withAnimation { 
                self.isHidden = !self.isHidden
            }            
        }
    }
}

Use it like this:

Import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            // In this example, 
            // we use the SF Symbol "rainbow" as the spoiler content.
            // It's animated and multi-color.
            // And resized to 250wx150h.
            Image(systemName: "rainbow")
                // Make the SF Symbol multi-color
                .renderingMode(.original)
                // Make the image resizable
                .resizable()
                // Resize to 250wx150h
                .frame(width: 250, height: 150)
                // (optional) animate the rainbow
                .symbolEffect(.variableColor)
                .modifier(Spoiler())
        }
    }
}

Or you can create an extension to make it more readable:

extension View {
    @warn_unqualified_access
    func spoiler() -> some View {
        self.modifier(Spoiler())
    }
}

Then you can use it like this:

Text("Hello, World!")
    .spoiler()

In action

Here is a visual representation of the examples above:

Download the Swift Playground here

Caveats

Watch out for missing qualifiers, we eliminated risk in the examples, but i recommend you to read this article in the resources section to understand the risks.

Conclusion

Resources:

https://developer.apple.com/documentation/swiftui/reducing-view-modifier-maintenance
This is the documentation about the View Modifiers from apple
https://www.danijelavrzan.com/posts/2023/02/card-view-swiftui/
I used this post from Danijela Vrzan to create the CardBackground example.
https://blog.eidinger.info/make-your-swiftui-view-modifiers-safer
I used this post to understand the risks of missing qualifiers in the ViewModifiers.
https://sarunw.com/posts/swiftui-viewmodifier/
I used this post to create the Spoiler example.
The code is based on the NSFW example in the post of Sarunw.

Subscripts in Swift

Fri, 17 Oct 2025 22:36:47 +0200

Subscripts provide a convenient way to access the elements of a collection, list, or sequence directly by index. Whether you’re dealing with arrays, dictionaries, or custom types, subscripts allow you to set and retrieve values without needing separate methods for each operation.

What is a `subscript`?

Subscripts are shortcuts for accessing the member elements of a collection, list, or sequence. They are used to set and retrieve values without needing separate methods for each operation.

Use Case of a `subscript`

extension Collection {
    // Support collection[safe: number]
    subscript (safe index: Index) -> Element? {
        return indices.contains(index) ? self[index] : nil
    }

    // Support collection[safe: number, default: "some default value"]
    subscript (safe index: Index, default value: Element) -> Element {
        return indices.contains(index) ? self[index] : value
    }
}

let pokemon = ["Pikachu", "Lugia", "Dragonite", "Mewtwo"]

pokemon[10] // will crash 💥
pokemon[safe: 10] // returns nil
pokemon[safe: 10, default: "Pikachu"] // returns Pikachu.

Download the Swift Playground here

Conclusion

Resources:
https://docs.swift.org/swift-book/documentation/the-swift-programming-language/subscripts/

How to monitor network in SwiftUI

Fri, 17 Oct 2025 22:36:47 +0200

Network monitoring is crucial for maintaining robust and reliable applications.
In this blog post, we’ll explore how to implement network monitoring in Swift using Apple’s native Network framework.
By leveraging this framework, you can efficiently track network connectivity, detect changes, and respond accordingly.

What is `NWPathMonitor`?

NWPathMonitor is a class that monitors changes to network connectivity.
It provides information about the current network path, such as the status of the network connection and the available interfaces.

Writing the monitor

import SwiftUI
import Network

final class NetworkMonitor: ObservableObject {
    // This will be used to track the network connectivity
    @Published
    var isConnected = true

    // This will be used to track if the network is expensive (e.g. cellular data)
    @Published
    var isExpensive = false

    @Published
    var networkType: NWInterface.InterfaceType? = .other

    // This will be used to track the network path (e.g. Wi-Fi, cellular data, etc.)
    @Published
    var nwPath: NWPath?

    // Create an instance of NWPathMonitor
    let monitor = NWPathMonitor()

    init() {
        // Set the pathUpdateHandler
        monitor.pathUpdateHandler = { [weak self] path in

            // Check if the device is connected to the internet
            self?.isConnected = path.status == .satisfied

            // Check if the network is expensive (e.g. cellular data)
            self?.isExpensive = path.isExpensive

            // Check which interface we are currently using
            self?.networkType = path.availableInterfaces.first?.type

            // Update the network path
            self?.nwPath = path
        }

        // Create a queue for the monitor
        let queue = DispatchQueue(label: "Monitor")

        // Start monitoring
        monitor.start(queue: queue)
    }

    deinit {
        // Stop monitoring
        monitor.cancel()
    }
}

Use the monitor

import SwiftUI


struct ContentView: View {
    @ObservedObject
    private var network = NetworkMonitor()

    var body: some View {
        VStack {
            Text("Hello!")
            Text("The network status is \(network.isConnected ? "Connected" : "Disconnected")")
            Text("You are using a \"\(network.isExpensive ? "Expensive" : "Normal")\" internet connection")

            HStack(spacing: 0) {
                Text("You are using \"")
                switch (network.networkType) {
                case .cellular:
                    Text("Celluar")
                case .wifi:
                    Text("Wifi")
                case .loopback:
                    Text("Loopback")
                case .other:
                    Text("Other")
                case .wiredEthernet:
                    Text("Wired")
                default:
                    Text("Unknown")
                }
                Text("\" to connect to the internet")
            }
        }.task {
            print(network.nwPath)
        }
    }
}

Download the Swift Playground here

Conclusion

Network monitoring is crucial for maintaining robust and reliable applications.
In this blog post, we explored how to implement network monitoring in Swift using Apple’s native Network framework.
By leveraging this framework, you can efficiently track network connectivity, detect changes, and respond accordingly.

Resources:
https://developer.apple.com/documentation/network

LabeledContent in SwiftUI

Fri, 17 Oct 2025 22:36:48 +0200

As developers, we often need to display a value alongside a label, and manually arranging this can be difficult.
But LabeledContent, a powerful and versatile view that simplifies this common UI pattern.

What Is `LabeledContent`?

At its core, LabeledContent is a straightforward view that combines a label and content.
It's like a dynamic duo that works together seamlessly.
Let's dive into how it works and explore some practical examples.

Basic Usage

The basic usage of LabeledContent involves providing a label and a corresponding value.
Here's a simple example:

struct ContentView: View {
    var body: some View {
        Form {
            LabeledContent("Label", value: "Content")
        }
    }
}

In the example below we use different ways to create some LabeledContent:

struct ContentView: View {
    var body: some View {
        Form {
            Section {
                // Version 1: String label & String value
                LabeledContent("Pikachu", value: "#25")

                // Version 2: String label & formatted value
                LabeledContent("Pikachu", value: 25, format: .number)

                // Version 3: String label & any View as value
                LabeledContent("Region") {
                    Image(systemName: "globe.europe.africa.fill")
                    Text("Kanto")
                }

                // Version 4: Any View as value & any View as a label
                LabeledContent {
                    VStack(alignment: .leading) {
                        Text("#025 Pikachu")
                        Text("#149 Dragonite")
                        Text("#249 Lugia")
                        Text("#145 Zapdos")
                        Text("#150 Mewtwo")
                        Text("#132 Ditto")
                    }
                } label: {
                    Text("Team")
                    Text("#1")
                }
            }
        }
    }

Download the Swift Playground here

Conclusion

In summary, LabeledContent is a powerful tool for creating well-organized and visually appealing UIs.
Whether you're displaying simple strings or complex views, it streamlines the process and adheres to design guidelines.

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

ExpressibleByStringLiteral URL

Fri, 17 Oct 2025 22:36:49 +0200

The ExpressibleByStringLiteral protocol is a powerful feature in Swift that allows us to create custom types directly from string literals. Essentially, it enables us to initialize instances of our custom types using string values. This can be incredibly useful for scenarios where we want to represent certain data types more intuitively or avoid force unwrapping when dealing with known valid strings.

Writing the extension `ExpressibleByStringLiteral`

/// Lets URLs be expressed conveniently with literal strings:
/// # Example:
///     let baseUrl: URL = "https://wesleydegroot.nl/blog"
extension URL: ExpressibleByStringLiteral {
    public init(stringLiteral string: StaticString) {
        guard let url = URL(string: "\(string)") else {
            preconditionFailure("Invalid literal URL string: \(string)")
        }
        self = url
    }
}

Use Case: `ExpressibleByStringLiteral` for URLs

let baseUrl: URL = "https://wesleydegroot.nl/blog"
print(baseUrl.absoluteString) // Output: "https://wesleydegroot.nl/blog"

Conclusion

In summary, ExpressibleByStringLiteral empowers us to make our custom types more expressive and convenient to work with. By conforming to this protocol, we can simplify our code and enhance readability.

Remember to explore other use cases and experiment with different types to harness the full potential of ExpressibleByStringLiteral in your Swift projects!

Resources:

Apple Documentation

self, Self, and Self.self in Swift

Fri, 17 Oct 2025 22:36:49 +0200

Let's dive into the fascinating world of self, Self, and Self.self in Swift.
These seemingly similar constructs have distinct meanings and use cases.

What is `self` (lowercase)?

When you're inside an instance method or property of a class, self refers to the current instance of that class.
It's like saying, "Hey, I'm talking about myself!"

class Pokemon {
    var name: String

    init(name: String) {
        self.name = name
    }

    func introduce() {
        print("Hello, my name is \(self.name).")
    }
}

let dragonite = Pokemon(name: "Dragonite")
dragonite.introduce() // Prints: "Hello, my name is Dragonite."

What is `Self` (capital 'S')?

When you're working with protocols and protocol extensions, Self (with a capital 'S') refers to the type that conforms to the protocol.
It's like saying, "Whoever adopts this protocol, listen up!"

protocol Duplicatable {
    func duplicate() -> Self
}

In the Duplicatable protocol, Self is used to specify that the duplicate() method should return an instance of the conforming type.
The exact type is not specified in the protocol itself, but will be determined by the type that conforms to the protocol.
It allows each conforming type to have a clear contract: if you conform to Duplicatable, you must implement a duplicate() method that returns an instance of your own type.

What is `Self.self`?

When you use Self.self, you're referring to the type itself (not an instance).
It's like saying, "I want to talk about the blueprint, not the actual house."

class Animal {
    static func describe() {
        print("This is an animal.")
    }
}

class Dog: Animal {
    override class func describe() {
        print("This is a dog.")
    }
}

let someAnimalType = Animal.self
someAnimalType.describe() // Prints: "This is an animal."

let someDogType = Dog.self
someDogType.describe() // Prints: "This is a dog."

Practical Use Cases

self:
- Use it within instance methods to refer to properties or methods of the current instance.
- Helpful for avoiding naming conflicts between method parameters and instance properties.
Self:
- Great for defining default implementations in protocol extensions.
- Ensures that conforming types use the same implementation.
Self.self:
- Rarely used directly but can be handy when working with metatypes (e.g., creating instances dynamically).

Wrapping Up

self is for instances.
Self is for protocols and protocol extensions.
Self.self is for talking about types themselves.

Conclusion

Understanding the differences between self, Self, and Self.self is crucial for writing clean and maintainable Swift code.

Resources:

Appril Festival 2024

Fri, 17 Oct 2025 22:36:50 +0200

As you may (or may not yet) know, I'd love to support and help the tech industry, today I'd like to highlight Appril Festival, i have volunteered a several times and it's a great event to attend, learn and network.

Appril Festival: Celebrating the Intersection of Apps, Design, and Business

Appril Festival, a vibrant celebration at the crossroads of app development, design, and business, is back! From April 17th to 26th, 2024, professionals from all corners of the Netherlands gather for a week filled with inspiration, innovation, and networking. Whether you're a product owner, designer, developer, or business enthusiast, Appril has something exciting in store for you.

What Is Appril Festival?

Appril Festival is all about connecting the dots—the product side, design aspects, and business elements—involved in creating successful apps. Here's what you can expect during this multi-day extravaganza:

Inspiring Talks: Dive into thought-provoking discussions led by industry experts. Learn about mobile businesses, app marketing insights, UX/UI design, and cutting-edge technologies.
Exciting Workshops: Participate in hands-on workshops that empower you with practical skills. From behavioral science to impactful presentations, there's something for everyone.
Tasty Lunches: Fuel your creativity with delicious lunches while mingling with fellow app enthusiasts.

My top sessions to look forward to

The future is Artificial

Speaker: Theo Palios from Unicorn Labs.

Dementia is a debilitating disease affecting millions of people worldwide, with Alzheimer’s being the most common form. Unfortunately, many individuals go undiagnosed until the advanced stages, leading to delayed treatment and increased healthcare burdens. Our startup aims to change this by introducing an innovative AI-powered application that detects early warning signals for dementia through behavioral and speech patterns analysis.

In our talk, we will delve into the problem of late diagnosis in dementia patients, highlighting its impact on individuals, families, and healthcare systems. We will also discuss the limitations of current diagnostic methods and how AI can address these challenges. Our solution involves three neural networks that analyze speech patterns to detect context, speed, and word forgetfulness, providing early warnings for Alzheimer’s and dementia.

We will share our preliminary results, demonstrating the effectiveness of our application in identifying individuals at risk of developing dementia up to five years before symptoms manifest. Our solution also provides personalized care recommendations based on individual needs, improving quality of life and reducing healthcare costs.

Join us as we explore the future of dementia diagnosis and treatment through AI-powered solutions. Together, let’s work towards a world where early intervention becomes the norm, rather than the exception.”

Weekend Fun: Scheepvaartmuseum (Maritime Museum)

By Wesley de Groot & Jake Ruston, a Appsterdam Event.

Het Scheepvaartmuseum (formerly Nederlands Scheepvaartmuseum Amsterdam) is a Dutch museum at Kattenburgerplein 1 in Amsterdam about shipping and maritime history. It is housed in the building of the former ‘s Lands Zeemagazijn and contains the second largest maritime collection in the world. It specializes in the maritime history of the Netherlands.

Sustainable solutions for our digital dependency

Speaker: Roeland Weve from Pinch.

Cloud computing does not take place in the sky.
Gigantic data centers are popping up all around us, home to new AI services and BitCoin mining operations that consume more energy than the entire country of the Netherlands annually.
Code using Python & Java (the most popular) can use up to 45x times as much energy as other programming languages.
Whether you are a programmer or user, our dependence on all this processing power is creating a new energy competition between our homes / businesses and our digital lives.
What are some examples for sustainable development? Join us April 18th where we talk to industry pioneers that are developing serious solutions to solve our addiction to energy.

Midjourney Basics: 2-hours into Midjourney

Speaker: Roeland Weve from Pinch.

In this two-hour workshop, we will lead you through the fundamentals of Midjourney, offering real-time insights into crafting beautiful artwork for various purposes, including mobile apps, websites, promotional materials, and more.
Feel encouraged to ask any questions you may have throughout the session.
By the workshop’s end, you’ll possess the skills necessary to generate impressive images effortlessly, simply by composing straightforward text prompts.

Rapid app development with FlutterFlow

Speaker: Stephan Veenstra & Stephan Mantel from Pinch.

None of the code, all of the glory

Full agenda:
https://apprilfestival.com/category/festival/2024/

Discover the (Dutch) Industry

Join Us!

Appril Festival is more than an event; it's a community. Whether you're a seasoned pro or just starting your app journey, there's a place for you. Mark your calendars, embrace the spirit of innovation, and let's celebrate the magic of apps together!

For more details and registration, visit the official Appril Festival website.

Appsterdam is partnering with Appril Festival, and we are looking forward to seeing you at one of the many events!

If case let

Fri, 17 Oct 2025 22:36:50 +0200

This concise syntax provides a convenient shortcut when you want to match a single case without writing a full-blown switch statement. Although it might seem a bit backward at first, once you grasp its power, you'll find it quite handy.

The Scenario

Imagine you're working with the Swift Result type, capturing the results of a throwing expression (such as loading data from a file). Here's how you'd typically handle it:

import Foundation

let result = Result {
    try Data(
        contentsOf: URL(
            string: "https://wesleydegroot.nl"
        )!
    )
}

switch result {
case .success(let data):
    // Do something with the data
    print(data)
case .failure(let error):
    // Handle the error
    print(error)
}

The Syntax

Now, let's introduce the if case let syntax. It allows you to directly match a specific case without the need for a full switch statement:

if case let .failure(error) = result {
    // Handle the error
    print(error)
}

Alternatively, you can use the slightly more concise form:

if case .failure(let error) = result {
    // Handle the error
    print(error)
}

Adding Conditions

You can further filter the matching cases by adding a where clause. For example:

if case let .success(data) = result, data.count > 100 {
    // Process the data (only if its count exceeds 100)
}

Beyond Switch Statements

The case let syntax isn't restricted to switch statements. You can also use it in if statements or even guard statements:

// Using an if statement
if case let .success(data) = result {
    // Handle the success case
}

// Using an alternate form
if case .success(let data) = result {
    // Handle the success case
}

// Using a guard statement
guard case let .success(data) = result, data.count > 100 else {
    return
}

// Continue with further processing

Download Swift Playground

Wrap up

In this post, you learned about the if case let syntax in Swift, which provides a concise way to match a specific case without the need for a full switch statement. This syntax is particularly useful when you're working with types like Result and want to handle the success or failure cases separately. By using if case let, you can streamline your code and make it more readable.

Conclusion

The if case let syntax in Swift is a powerful feature that allows you to match specific cases without the need for a full switch statement. This concise syntax is particularly useful when you're working with types like Result and want to handle the success or failure cases separately. By using if case let, you can streamline your code and make it more readable. Give it a try in your next project and see how it can help you write cleaner, more maintainable code.

Variadic Parameters

Fri, 17 Oct 2025 22:36:51 +0200

These versatile constructs allow us to handle a variable number of arguments of the same type within a function.

What are `Variadic Parameters`?

In Swift, variadic parameters enable a function to accept zero or more values of a specific type.
They come in handy when you want to create a function that can take any number of arguments without specifying the exact count upfront.
Imagine a scenario where you're dealing with a method that often works with individual elements, and you'd rather avoid creating an array just for a single value at the implementation level.

How to Define a Variadic Parameter

To declare a variadic parameter, use a value type followed by three dots ....

Here's an example:

mutating func add(_ newContent: Content...) {
    content.append(contentsOf: newContent)
}

In this snippet:

add(_:) is a method that can accept either a single value or multiple values at once.
The Content type represents the elements we're adding to our collection.

You can now call this method with one or more Content instances:

var posts = BlogPosts()

// Add a single content item:
posts.add(Content(title: "Blog post 1"))

// Add multiple items:
posts.add(
    Content(title: "Blog post 2"), 
    Content(title: "Blog post 3")
)

Handling Multiple Variadic Arguments

Since Swift 5.4 (shipped with Xcode 12.5), you can define multiple variadic arguments in a method:

mutating func add(_ newContent: Content..., newUsers: User...) {
    content.append(contentsOf: newContent)
    users.append(contentsOf: newUsers)
}

This flexibility allows multiple parameters to receive zero or more values.

Caveats / Limitations

While variadic parameters are powerful, they have some limitations to consider:

Empty Variadic Arguments: You can pass an empty array as a variadic argument. For instance:

struct BlogPosts {
    private(set) var content: [Content] = []

    mutating func add(_ newContent: [Content]) {
        content.append(contentsOf: newContent)
    }
}

var posts = BlogPosts()
    posts.add([])

The same applies when using variadic parameters directly:

struct BlogPosts {
    private(set) var content: [Content] = []

    mutating func add(_ newContent: Content...) {
        content.append(contentsOf: newContent)
    }
}

var posts = BlogPosts()
    posts.add()

Type Consistency: Variadic parameters must have the same type. You cannot mix different types within a single variadic argument.

Conclusion

Variadic parameters are a powerful feature in Swift that allows you to create functions that can accept a variable number of arguments.

Resources:
https://docs.swift.org/swift-book/documentation/the-swift-programming-language/functions/

Generics in Swift

Fri, 17 Oct 2025 22:36:51 +0200

Swift, offers a powerful feature called generics that greatly enhances code reusability, efficiency, and safety. In this blog post, we will dive deep into generics and explore how they can be leveraged in iOS development. Let's get started!

What are Generics?

Generics in Swift enable you to write flexible and reusable code that can work with different types of data. By using generics, you can create functions, classes, and structures that operate uniformly on a variety of types, avoiding code duplication and increasing maintainability.

Generic Types

A generic type can represent any specific type, allowing for maximum flexibility. Let's look at an example of a generic class called Stack that can store and manipulate a stack of elements of any type:

class Stack<T> {
    private var items = [T]()

    func push(item: T) {
        items.append(item)
    }

    func pop() -> T? {
        return items.popLast()
    }
}

let stackOfIntegers = Stack<Int>()
let stackOfString = Stack<String>()
let stackOfPerson = Stack<Person>()

In the code snippet above, we define a Stack class with a generic type parameter T. This parameter acts as a placeholder for any type that will be used with the Stack instance. The push function allows us to add elements to the stack, while the pop function removes and returns the topmost element from the stack.

Generic Functions

Similarly, you can define generic functions that can work with different types. Let's look at an example of a generic function for swapping two values:

func swap<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

In this code snippet, the swap function is defined with a type parameter T using the placeholder <T>. The function takes in two parameters of the same type (a and b) and swaps their values using a temporary variable.

Conclusion

Generics in Swift are a powerful feature that allows you to write flexible and reusable code that can work with different types. By using generics, you can avoid code duplication, increase maintainability, and improve efficiency in your iOS development projects. I hope this blog post has helped you understand the basics of generics in Swift and how you can leverage them in your code.

Resources:
https://docs.swift.org/swift-book/documentation/the-swift-programming-language/generics/

Handle hyperlinks in SwiftUI

Fri, 17 Oct 2025 22:36:52 +0200

If you have a SwiftUI application and you present text with a URL, have you notices how the URL is being opened by Safari and not an in-app browser, and want to change that?

What is `OpenURLAction`?

An action that opens a URL.
OpenURLAction can be used to create your own handler for opening url's in SwiftUI, this makes it possible to use your own (in-app) WebView or transform the url before you open it in a external browser.

OpenURLAction requires a return statement with an appropiate value, in the (psuedo) codeblock below you can see which results are possible and what their meaning is.

struct OpenURLAction.Result {
    /// The handler did handle the URL.
    let handled

    /// The handler discarded the URL.
    let discarded

    /// The handler asks the system to open the original URL.
    let systemAction

    /// The handler asks the system to open the modified URL.
    let systemAction(let URL)
}

Use Case: Simple url handler

requires you to have a function called handleURL()

/// Basic example
Text("Visit [my Blog](https://www.wesleydegroot.nl) for more details.")
    .environment(\.openURL, OpenURLAction { url in
        handleURL(url) // Define this method to take appropriate action.
        return .handled
    })

Use Case: Simple url handler

requires you to have a function called handleURL()

struct SafariURL: Identifiable {
    let id = UUID()
    let url: URL
}

struct ContentView: View {
    @State
    var safariURL: SafariURL?

    var body: some View {
        Text("Visit [my Blog](https://www.wesleydegroot.nl) for more details.")
            .environment(\.openURL, OpenURLAction { url in
                safariURL = SafariURL(url: url)
                return .handled
            })
            .sheet(item: $safariURL, content: { safariURL in
                SafariView(url: safariURL.url)
            })
    }

    func handleURL(url: URL) {
    /// open SFSafariViewController
    }
}

Conclusion

OpenURLAction is a great way to handle URL's in SwiftUI, it allows you to create your own handler for URL's and decide what to do with them.

Resources:

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

Loging using OSLog

Fri, 17 Oct 2025 22:36:52 +0200

OSLog is a Swift API that provides a unified logging system for all Apple platforms.
It is a replacement for the older print and NSLog functions.
OSLog is a more efficient and secure logging system that provides better performance and privacy protection.
In this article, we will explore the features of OSLog and how to use it in your Swift applications.

Installation

To use OSLog in your Swift application, you need to import the OSLog module.
You can do this by adding the following import statement to your Swift file:

import OSLog

Then you can use the Logger class to create a logger instance.
The Logger class is a wrapper around the OSLog API that provides a more convenient way to log messages.

let logger = Logger(
    subsystem: "nl.wesleydegroot.demoApp",
    category: "myCategory"
)

The subsystem parameter is a string that identifies the subsystem that the logger belongs to.
The category parameter is a string that identifies the category of the logger.

Sample Use

import OSLog

let logger = Logger(
    subsystem: "nl.wesleydegroot.demoApp",
    category: "myCategory"
)

logger.fault("This is a fault") // Shows in red
logger.error("This is a error") // Shows in yellow
logger.warning("This is a warning") // Shows in yellow
logger.info("Information") // Shows in default color
logger.debug("Debug message") // Shows in default color
logger.trace("Trace message") // Shows in default color

Caveats

Unfortunately, OSLog is only available on Apple platforms and it cannot be used within SwiftUI views.
If you need to log messages within a SwiftUI view, use the view extension below:

import SwiftUI

extension View {
    func log(_ closure: () -> Void) -> some View {
         _ = closure()
         return self
     }
}

Now you can log messages within a SwiftUI view like this:

import SwiftUI
import OSLog

struct ContentView: View {
    let logger = Logger(
        subsystem: "nl.wesleydegroot.exampleapp",
        category: "MyCategory"
    )

    var body: some View {
        Text("Hello, World!")
            .log {
                logger.info("Hello, World!")
            }
    }
}

Displaying Log Messages (in app)

If you want to display log messages in your app, you can use the OSLog API to log messages to the console.
I've created a Swift Package to make this easier, you can find it here (OSLogViewer).

How to use `OSLogViewer`:

import SwiftUI
import OSLogViewer

struct ContentView: View {
    var body: some View {
        NavigationView {
            // The default configuration will show the log messages.
            OSLogViewer()

            // Custom configuration
            // OSLogViewer(
            //    subsystem: "nl.wesleydegroot.exampleapp",
            //    since: Date().addingTimeInterval(-7200) // 2 hours
            // )
        }
    }
}

Download Swift Playground

OSLogViewer Features

Simple Interface

Beautiful export

This is the OSLog archive for exampleapp
Generated on 2/6/2024, 11:53
Generator https://github.com/0xWDG/OSLogViewer

Info message
ℹ️ 2/6/2024, 11:53 🏛️ exampleapp ⚙️ nl.wesleydegroot.exampleapp 🌐 myCategory

Error message
❗ 2/6/2024, 11:53 🏛️ exampleapp ⚙️ nl.wesleydegroot.exampleapp 🌐 myCategory

Error message
❗ 2/6/2024, 11:53 🏛️ exampleapp ⚙️ nl.wesleydegroot.exampleapp 🌐 myCategory

Critical message
‼️ 2/6/2024, 11:53 🏛️ exampleapp ⚙️ nl.wesleydegroot.exampleapp 🌐 myCategory

Log message
🔔 2/6/2024, 11:53 🏛️ exampleapp ⚙️ nl.wesleydegroot.exampleapp 🌐 myCategory

Log message
🔔 2/6/2024, 11:53 🏛️ exampleapp ⚙️ nl.wesleydegroot.exampleapp 🌐 myCategory

Wrap up

OSLog is a more efficient and secure logging system that provides better performance and privacy protection.
It is a great replacement for the older print and NSLog functions, that provides a unified logging system for all Apple platforms.

Resources:

@Environment variables

Fri, 17 Oct 2025 22:36:53 +0200

SwiftUI provides a way to pass data down the view hierarchy using @Environment variables. These variables are environment-dependent and can be accessed from any child view. They are useful for sharing common data or settings across the app, such as color schemes, locale, or accessibility settings.

When you create an @Environment variable, SwiftUI automatically manages its value for you. This means that when the environment changes, the view will automatically update to reflect the new value.

Creating an @Environment Variable

To create an @Environment variable, you can use one of the built-in environment keys provided by SwiftUI, such as .colorScheme, .locale, or .accessibilityEnabled. For example, to access the color scheme environment variable, you can use the following code:

struct ContentView: View {
    @Environment(\.colorScheme) var colorScheme

    var body: some View {
        Text("Hello, World!")
            .foregroundColor(colorScheme == .dark ? .white : .black)
    }
}

In this example, the colorScheme variable is an @Environment variable that holds the current color scheme of the app. The text color is set based on the color scheme (dark or light) using a ternary operator.

Custom @Environment Variables

You can also create custom @Environment variables to pass custom data or settings down the view hierarchy. To define a custom @Environment variable, you need to create a new type that conforms to the EnvironmentKey protocol and extend EnvironmentValues to introduce the value.

Here's an example of how you can define a custom @Environment variable:

private struct MyCustomKey: EnvironmentKey {
    // Create a default value for the custom environment key
    static let defaultValue: String = "Default Value"
}

extension EnvironmentValues {
    /// Define a custom environment variable
    var myCustomValue: String {
        get { self[MyCustomKey.self] }
        set { self[MyCustomKey.self] = newValue }
    }
}

In this example, we define a custom key MyCustomKey that holds a default string value. We then extend EnvironmentValues to introduce the custom value myCustomValue using the key.

You can now use the custom @Environment variable in your views like this:

/// Pass custom environment value
struct ContentView: View {
    var body: some View {
        VStack {
            SecondView()
                .environment(\.myCustomValue, "hello there")
        }
    }
}

/// Access custom environment value
struct SecondView: View {
    @Environment(\.myCustomValue) var customValue

    var body: some View {
        Text(customValue)
    }
}

In this example, the customValue variable is an @Environment variable that holds the custom value defined earlier. The text view displays the value of the custom environment variable.

iOS 18 and later (easier)

/// Setup environment key
extension EnvironmentValues {
    @Entry var myCustomValue: String = "Default Value"
}

/// Pass custom environment value
struct ContentView: View {
    var body: some View {
        VStack {
            SecondView()
                .environment(\.myCustomValue, "hello there")
        }
    }
}

/// Access custom environment value
struct SecondView: View {
    @Environment(\.myCustomValue) var customValue

    var body: some View {
        Text(customValue)
    }
}

Caveats

When using @Environment variables, keep in mind that they are not meant for sharing complex data structures or models across the view hierarchy. For more complex data sharing, consider using @EnvironmentObject or other data sharing techniques.

Wrap up

@Environment variables are a powerful tool in SwiftUI for sharing common data or settings across the app. By creating custom @Environment variables, you can extend this functionality to suit your app's specific needs. Just remember to use them judiciously and follow best practices to avoid potential pitfalls.

Resources:

SwiftUI Environment

@ViewBuilder in Swift

Fri, 17 Oct 2025 22:36:53 +0200

SwiftUI, Apple's declarative framework for building user interfaces, introduces several powerful tools to streamline UI development. One such tool is the @ViewBuilder attribute, which simplifies the creation of complex view hierarchies. In this article, we'll explore what @ViewBuilder is, how it works, and how you can use it to enhance your SwiftUI projects.

What is `@ViewBuilder`?

@ViewBuilder is a result builder provided by SwiftUI that allows you to construct views from closures. It enables you to write more readable and maintainable code by eliminating the need for explicit return statements in your view-building closures.

How `@ViewBuilder` Works

When you use @ViewBuilder, you can combine multiple views within a single closure without needing to return each view explicitly. This is particularly useful for creating complex layouts with conditional views.

Here's a simple example:

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Text("Hello, world!")
                .padding()
            if Bool.random() {
                Text("This is a conditional view")
            }
        }
    }
}

In this example, the VStack contains two Text views, one of which is conditionally included based on a random boolean value. The @ViewBuilder attribute allows this structure to be written cleanly and concisely.

Using @ViewBuilder in Custom Views

You can also use @ViewBuilder in your custom view initializers and methods. This allows you to create reusable components that accept multiple child views.

struct CustomContainer<Content: View>: View {
    let content: Content

    init(@ViewBuilder content: () -> Content) {
        self.content = content()
    }

    var body: some View {
        VStack {
            content
        }
    }
}

struct ContentView: View {
    var body: some View {
        CustomContainer {
            Text("Hello, world!")
            Text("This is inside a custom container")
        }
    }
}

In this example, CustomContainer is a reusable component that accepts a closure containing multiple child views. The @ViewBuilder attribute makes it easy to pass these views without needing to wrap them in a single container view.

Benefits of Using `@ViewBuilder`

Improved Readability: By removing the need for explicit return statements, @ViewBuilder makes your code cleaner and easier to read.
Conditional Views: You can easily include or exclude views based on conditions, making your UI more dynamic.
Reusable Components: Create flexible and reusable components that can accept multiple child views.

Caveats

While @ViewBuilder is a powerful tool, there are a few things to keep in mind when using it:

Limitations: @ViewBuilder can only be used with functions that return a single view. If you need to return multiple views, you'll need to use a different approach.
Performance: While @ViewBuilder can improve code readability, it may not always be the most performant option. Be mindful of how you use it in performance-critical sections of your code.
Complexity: Overusing @ViewBuilder can lead to overly complex view hierarchies. Use it judiciously to maintain code clarity.
Debugging: When debugging views that use @ViewBuilder, keep in mind that the closure-based nature of @ViewBuilder can make it harder to trace the source of issues.

Conclusion

The @ViewBuilder attribute is a powerful tool in SwiftUI that simplifies the process of building complex view hierarchies. By leveraging @ViewBuilder, you can write more readable, maintainable, and dynamic SwiftUI code. Whether you're building simple layouts or intricate interfaces, @ViewBuilder can help you achieve your goals with ease.

Resources:

CoreSpotlight

Fri, 17 Oct 2025 22:36:54 +0200

CoreSpotlight is a framework provided by Apple that allows you to index and search content within your app. It provides a way to make your app's content searchable and discoverable by users through the Spotlight search feature on iOS and macOS.

Why should i implement `CoreSpotlight`?

Implementing CoreSpotlight in your app can greatly enhance the discoverability and searchability of your app's content. By indexing your app's content using CoreSpotlight, users will be able to find relevant information from your app directly through the Spotlight search feature on iOS and macOS.

This can lead to a better user experience, as users can quickly access specific content within your app without having to open the app itself. It also allows your app to be more integrated with the overall system search functionality, making it easier for users to find and interact with your app's content.

Additionally, CoreSpotlight provides a powerful set of APIs and features that allow you to customize the search experience and provide rich metadata for your app's content. You can define searchable attributes, create custom search UI, and even deep link users to specific content within your app.

Overall, implementing CoreSpotlight can help increase the visibility and accessibility of your app's content, improving user engagement and satisfaction.

How to implement `CoreSpotlight`?

To implement CoreSpotlight in your app, you need to follow these steps:

Import CoreSpotlight: First, import the CoreSpotlight framework in your project.
Indexing Content: Identify the content within your app that you want to make searchable and index it using the CoreSpotlight APIs. You can create CSSearchableItem objects to represent the content and define searchable attributes such as title, description, keywords, and more.
Updating the Index: Whenever the content in your app changes, update the CoreSpotlight index to reflect the changes. You can add, update, or delete searchable items using the CSSearchableIndex API.
Handling Search Queries: Implement the search functionality in your app to handle search queries from the user. You can use the CSSearchQuery API to perform searches and retrieve search results based on the user's input.
Customizing Search Results: Customize the search results to provide a rich and interactive search experience for users. You can display custom UI elements, provide additional metadata, and deep link users to specific content within your app.

By following these steps, you can effectively implement CoreSpotlight in your app and make your content searchable and discoverable through the Spotlight search feature.

Example of Use Case

Here's an example of how you can implement CoreSpotlight in a simple pokedex app:

import CoreSpotlight

// Define a Pokemon struct
struct Pokemon {
    let id: String
    let name: String
    let description: String
}

// Index a pokemon
func indexPokemon(pokemon: Pokemon) {
    let attributeSet = CSSearchableItemAttributeSet(
        contentType: .content
    )
    attributeSet.title = pokemon.name
    attributeSet.contentDescription = pokemon.description
    attributeSet.keywords = ["Pokedex", pokemon.id, pokemon.name, pokemon.description]

    // Optionally set thumbnail image using the options below
    // attributeSet.thumbnailData
    // attributeSet.thumbnailURL
    // attributeSet.darkThumbnailURL

    let searchableItem = CSSearchableItem(
        uniqueIdentifier: pokemon.id,
        domainIdentifier: "nl.wesleydegroot.pokedex",
        attributeSet: attributeSet
    )

    CSSearchableIndex.default().indexSearchableItems([searchableItem]) { error in
        if let error = error {
            print("Error indexing pokemon: \(error)")
        } else {
            print("Pokemon \(pokemon.name) indexed successfully")
        }
    }
}

// Update the pokemon
func updatePokemon(pokemon: Pokemon) {
    // Update the pokemon in the app
    // ...

    // Re-index the pokemon
    indexPokemon(pokemon: pokemon)
}

// Delete a Pokemon
func deletePokemon(pokemon: String) {
    CSSearchableIndex.default().deleteSearchableItems(withIdentifiers: [pokemon]) { error in
        if let error = error {
            print("Error deleting Pokemon: \(error)")
        } else {
            print("Pokemon deleted successfully")
        }
    }
}

let pokemon: [Pokemon] = [
    Pokemon(
        id: "149",
        name: "Dragonite",
        description: "It is said that somewhere in the ocean lies an island where these gather. Only they live there."
    ),
    Pokemon(
        id: "25",
        name: "Pikachu",
        description: "When it is angered, it immediately discharges the energy stored in the pouches in its cheeks."
    ),
    Pokemon(
        id: "249",
        name: "Lugia",
        description: "Lugia’s wings pack devastating power—a light fluttering of its wings can blow apart regular houses. As a result, this Pokémon chooses to live out of sight deep under the sea."
    )
]


// Index the pokemon
pokemon.forEach { indexPokemon(pokemon: $0) }

In this example, we define a Pokemon struct representing a pokemon in the app. We then implement functions to index, update, and delete pokemon using CoreSpotlight. When a pokemon is indexed, it becomes searchable through the Spotlight search feature, allowing users to find it based on the title and content.

Caveats

When implementing CoreSpotlight in your app, there are a few things to keep in mind:

Privacy Considerations: Ensure that you handle user data and content responsibly when indexing it with CoreSpotlight. Be mindful of user privacy and only index content that users have consented to make searchable.
Indexing Performance: Indexing large amounts of content or frequently updating the index can impact the performance of your app. Consider batching updates and indexing only relevant content to optimize performance.
Search Relevance: To provide a good search experience for users, make sure that the searchable attributes of your content are relevant and accurately reflect the content. Use keywords, descriptions, and other metadata to improve search results.
User Experience: Design the search UI and search results to provide a seamless and intuitive experience for users. Consider customizing the search results to display additional information and make it easy for users to interact with the content.

Wrap up

CoreSpotlight is a powerful framework that allows you to make your app's content searchable and discoverable through the Spotlight search feature on iOS and macOS. By indexing your app's content and handling search queries effectively, you can enhance the user experience and increase the visibility of your app's content.

Resources:

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

Difference between map, flatMap, compactMap

Fri, 17 Oct 2025 22:36:55 +0200

In this post, we'll explore the differences between map, flatMap, and compactMap in Swift. These three methods are commonly used when working with collections, and understanding their distinctions is crucial for writing clean and efficient code.

What is `map`?

map is a higher-order function that transforms each element of a collection using a provided closure. It returns a new collection with the transformed elements, leaving the original collection unchanged. The closure passed to map takes an element of the collection as input and returns a transformed value.

Here's a simple example of using map to double each element of an array of integers:

let numbers = [1, 2, 3, 4, 5]

let doubledNumbers = numbers.map { $0 * 2 }

print(doubledNumbers) // Output: [2, 4, 6, 8, 10]

In this example, the closure { $0 * 2 } is applied to each element of the numbers array, resulting in a new array with each element doubled.

map() can also transform each element of a collection using a provided closure and return a new collection with the transformed elements.

let numbers = [1, 2, 3, 4, 5]
print(numbers) // Output: [1, 2, 3, 4, 5]

let strings = numbers.map { String($0) }
print(strings) // Output: ["1", "2", "3", "4", "5"]

let maybeNumbers = strings.map { Int($0) } // [1, 2, 3, 4, 5]
print(maybeNumbers) // Output: [Optional(1), Optional(2), Optional(3), Optional(4), Optional(5)]

let unwrappedNumbers = maybeNumbers.compactMap { $0 }
print(unwrappedNumbers) // Output: [1, 2, 3, 4, 5]

What is `flatMap`?

flatMap is a higher-order function that transforms each element of a collection using a provided closure and then flattens the resulting collection of collections into a single collection. It is particularly useful when working with nested collections or when you want to remove nil values from a collection.

Here's an example of using flatMap to flatten an array of arrays:

let nestedNumbers = [[1, 2], [3, 4], [5, 6]]

let flattenedNumbers = nestedNumbers.flatMap { $0 }

print(flattenedNumbers) // Output: [1, 2, 3, 4, 5, 6]

In this example, the closure { $0 } is applied to each element of the nestedNumbers array, resulting in a new array with the nested arrays flattened into a single array.

What is `compactMap`?

compactMap is a higher-order function that transforms each element of a collection using a provided closure and then removes any nil values from the resulting collection. It is particularly useful when working with collections that may contain optional values.

Here's an example of using compactMap to remove nil values from an array of optional integers:

let optionalNumbers: [Int?] = [1, nil, 3, nil, 5]

let nonNilNumbers = optionalNumbers.compactMap { $0 }

print(nonNilNumbers) // Output: [1, 3, 5]

In this example, the closure { $0 } is applied to each element of the optionalNumbers array, resulting in a new array with the nil values removed.

Use Cases

Use map when you want to transform each element of a collection.
Use flatMap when you want to transform each element of a collection and flatten the resulting collection of collections.
Use compactMap when you want to transform each element of a collection and remove any nil values.

Conclusion

In summary, map, flatMap, and compactMap are powerful tools for working with collections in Swift. By understanding their differences and use cases, you can write cleaner and more efficient code when transforming and filtering collections.

Resources:

https://docs.swift.org/swift-book/documentation/the-swift-programming-language/collectiontypes/#Iterating-Over-an-Array

Enums

Fri, 17 Oct 2025 22:36:55 +0200

In this post, we'll explore enums in Swift, a powerful feature that allows you to define a group of related values. Enums are commonly used to represent a fixed set of options or states in your code, making it easier to work with and reason about different cases.

What are `enum`s?

An enum in Swift is a data type that defines a group of related values. Each value in an enum is called a case, and you can define as many cases as needed to represent the different options or states of a particular type.

Here's an example of defining an enum in Swift:

enum CompassPoint {
    case north
    case south
    case east
    case west
}

In this example, we define an enum CompassPoint with four cases: north, south, east, and west. Each case represents a direction on a compass, and you can use these cases to work with compass directions in your code.

Using `enum`s

Once you've defined an enum, you can use it to create instances of the enum type and work with the different cases. Here's an example of using the CompassPoint enum:

let direction: CompassPoint = .north

switch direction {
    case .north:
        print("Heading north")
    case .south:
        print("Heading south")
    case .east:
        print("Heading east")
    case .west:
        print("Heading west")
}

In this example, we create an instance of the CompassPoint enum called direction and set it to .north. We then use a switch statement to check the value of direction and print a message based on the case.

Enums are a powerful tool for representing a fixed set of options or states in your code. They help make your code more readable, maintainable, and robust by providing a clear and concise way to work with related values.

Associated Values

Enums in Swift can also have associated values, which allow you to attach additional data to each case. This is useful when you need to store extra information along with the case.

Here's an example of an enum with associated values:

enum PokemonState {
    case idle
    case walking(speed: Double)
    case running(speed: Double)
    case attacking(damage: Int)
    case catched(pokemon: String)
    case fainted
}

let dragonite: PokemonState = .attacking(damage: 10)
let trainer: PokemonState = .catched(pokemon: "Pikachu")
let lugia: PokemonState = .idle

switch dragonite {
    case .idle:
        print("Dragonite is idle")
    case .walking(let speed):
        print("Dragonite is walking at speed \(speed)")
    case .running(let speed):
        print("Dragonite is running at speed \(speed)")
    case .attacking(let damage):
        print("Dragonite is attacking with damage \(damage)")
    case .catched(let pokemon):
        print("Dragonite has catched \(pokemon)")
    case .fainted:
        print("Dragonite has fainted")
} // Output: Dragonite is attacking with damage 10

switch trainer {
    case .idle:
        print("Trainer is idle")
    case .walking(let speed):
        print("Trainer is walking at speed \(speed)")
    case .running(let speed):
        print("Trainer is running at speed \(speed)")
    case .attacking(let damage):
        print("Trainer is attacking with damage \(damage)")
    case .catched(let pokemon):
        print("Trainer has catched \(pokemon)")
    case .fainted:
        print("Trainer has fainted")
} // Output: Trainer has catched Pikachu

switch lugia {
    case .idle:
        print("Lugia is idle")
    case .walking(let speed):
        print("Lugia is walking at speed \(speed)")
    case .running(let speed):
        print("Lugia is running at speed \(speed)")
    case .attacking(let damage):
        print("Lugia is attacking with damage \(damage)")
    case .catched(let pokemon):
        print("Lugia has catched \(pokemon)")
    case .fainted:
        print("Lugia has fainted")
} // Output: Lugia is idle

In this example, we define an enum PokemonState with cases representing different states of a Pokemon. Each case has an associated value that provides additional information about the state. We then create instances of the enum with different cases and use a switch statement to handle each case.

Enums with associated values are a powerful feature of Swift that allows you to model complex data structures and represent different states in your code.

Raw Values

Enums in Swift can also have raw values, which are pre-defined values associated with each case. Raw values are useful when you need to map an enum case to a specific value, such as an integer or string.

Here's an example of an enum with raw values:

enum Pokemon: Int {
    case pikachu = 25
    case dragonite = 149
    case lugia = 249
}

let pikachuId = Pokemon.pikachu.rawValue
let dragoniteId = Pokemon.dragonite.rawValue
let lugiaId = Pokemon.lugia.rawValue

print("Pikachu Pokedex number: #\(pikachuId)")
print("Dragonite Pokedex number: #\(dragoniteId)")
print("Lugia Pokedex number: #\(lugiaId)")

In this example, we define an enum Pokemon with raw values of type Int. Each case is associated with a specific integer value, and we access the raw value of each case using the rawValue property.

Enums with raw values are a convenient way to map enum cases to specific values and provide a consistent way to work with related values in your code.

Use Cases

Enums are commonly used in Swift to represent a fixed set of options or states in your code. Here are some common use cases for enums:

Representing different states of an object or system
Defining a set of options for user input
Modeling different types of data or entities
Mapping enum cases to specific values or behaviors

By using enums in your code, you can make it more readable, maintainable, and robust by providing a clear and concise way to work with related values.

Caveats

Enums in Swift are powerful tools for modeling data and representing different states in your code. However, there are some limitations and considerations to keep in mind when working with enums:

Enums with associated values can become complex and hard to manage if they have too many cases or associated data.
Raw values in enums are limited to specific types, such as integers, strings, and floating-point numbers.
Enums with raw values must have unique raw values for each case to avoid conflicts.

When using enums in your code, consider the complexity of the data you're modeling and choose the appropriate enum type (plain, associated values, or raw values) based on your needs.

Conclusion

Enums are a fundamental part of Swift that provide a flexible and expressive way to define a group of related values. By understanding how to define enums, work with associated values and raw values, and use enums in your code, you can write cleaner, more maintainable, and more robust code that is easier to reason about and work with.

Resources:
https://docs.swift.org/swift-book/documentation/the-swift-programming-language/enumerations/

What is @frozen

Fri, 17 Oct 2025 22:36:56 +0200

In this post, we'll explore the @frozen attribute in Swift, a compiler directive that can be applied to enum declarations to optimize memory layout and improve performance. By marking an enum as @frozen, you can enable certain optimizations that can make your code more efficient.

What does `@frozen` do?

When you mark an enum or struct as @frozen, you're telling the Swift compiler that the enum's memory layout is fixed and will not change (is simply a promise that the public interface of these types will never change). This allows the compiler to make certain assumptions about the enum that can lead to performance improvements.

Use Case for `@frozen`

One common use case for @frozen is when you have an enum with a fixed set of cases that you know will never change. By marking the enum as @frozen, you enable the compiler to optimize the memory layout of the enum and generate more efficient code.

Here are two examples of using @frozen with an enum:

@frozen
struct Point {
  var x: Double
  var y: Double
}

@frozen
enum Direction {
    case north
    case south
    case east
    case west
}

In this example, the Poin and Direction enum is marked as @frozen because we know that the set of cases will never change. This allows the compiler to optimize the memory layout of the enum and generate more efficient code when working with Direction instances.

Benefits of `@frozen`

By using the @frozen attribute, you can achieve the following benefits:

Improved Performance: The compiler can make certain assumptions about the enum that can lead to performance improvements, such as better memory layout and more efficient code generation.
Optimized Memory Layout: Marking an enum as @frozen allows the compiler to optimize the memory layout of the enum, reducing the size of instances and improving memory access patterns.
Predictable Behavior: By explicitly marking an enum as @frozen, you make it clear to other developers that the set of cases will not change, leading to more predictable behavior.

Example of Use Case

Here's an example of using @frozen with an enum that represents different types of shapes:

@frozen
enum Shape {
    case circle(radius: Double)
    case square(side: Double)
    case triangle(base: Double, height: Double)
}

In this example, the Shape enum is marked as @frozen because the set of cases is fixed and will not change. This allows the compiler to optimize the memory layout of Shape instances and generate more efficient code when working with shapes.

ABI Stability

The @frozen attribute is also important for maintaining ABI stability in Swift. By marking an enum as @frozen, you ensure that the memory layout of the enum is fixed and will not change in future versions of the library or framework. This is crucial for ensuring compatibility between different versions of Swift.

What is an Application Binary Interface?

An Application Binary Interface (ABI) defines how functions, data structures, and other elements are represented in binary form and interact with each other at runtime. ABI stability is important for ensuring that code compiled with different versions of a library or framework can work together without issues.

Caveats

While @frozen can provide performance benefits, there are a few caveats to keep in mind:

Immutable Set of Cases: Once you mark an enum as @frozen, you cannot add or remove cases from it. This can limit the flexibility of the enum if you need to make changes in the future.
Compatibility: The @frozen attribute is only available in Swift 5.1 and later, so if you need to maintain compatibility with older versions of Swift, you may not be able to use it.
Limited Use Cases: @frozen is most beneficial for enums with a fixed set of cases that will never change. If your enum is likely to evolve over time, using @frozen may not be appropriate.

Wrap up

In this post, we've explored the @frozen attribute in Swift and how it can be used to optimize the memory layout and improve the performance of enum declarations. By marking an enum as @frozen, you can enable certain optimizations that can make your code more efficient and predictable.

Resources:

iOS Settings URL's

Fri, 21 Nov 2025 16:15:08 +0100

This is a list of internal URLs for settings on your iPhone, iPad, ...
Please note that this list will be updated if required, if you see something which is not right, please drop me a message and i'll try to fix it.
I included a guide how to extract the newest data.

Updated for iOS 26.1 (21-NOV-2025)

iOS 18 (20-AUG-2024, 17:00 CEST)

# Apple ID

root

prefs:root=APPLE_ACCOUNT

Name, Phone Numbers, Email

prefs:root=APPLE_ACCOUNT&path=APPLE_ACCOUNT_CONTACT

Password & Security

prefs:root=APPLE_ACCOUNT&path=PASSWORD_AND_SECURITY

Payment & Shipping

prefs:root=APPLE_ACCOUNT&path=PAYMENT_AND_SHIPPING

Subscriptions

prefs:root=APPLE_ACCOUNT&path=SUBSCRIPTIONS

iCloud

root

prefs:root=CASTLE or prefs:root=APPLE_ACCOUNT&path=ICLOUD_SERVICE

Keychain

prefs:root=CASTLE&path=com.apple.Dataclass.KeychainSync or prefs:root=APPLE_ACCOUNT&path=ICLOUD_SERVICE/com.apple.Dataclass.KeychainSync

iCloud Backup

prefs:root=CASTLE&path=BACKUP or prefs:root=APPLE_ACCOUNT&path=ICLOUD_SERVICE/BACKUP

Find My

prefs:root=APPLE_ACCOUNT&path=LOCATION_SHARING

Family Sharing

prefs:root=APPLE_ACCOUNT&path=FAMILY

Hide My Email

prefs:root=APPLE_ACCOUNT&path=ICLOUD_SERVICE/PRIVATE_EMAIL_MANAGE

Wi-Fi

root

prefs:root=WIFI

Bluetooth

root

prefs:root=Bluetooth

Cellular

root

prefs:root=MOBILE_DATA_SETTINGS_ID

Cellular Data Options

prefs:root=MOBILE_DATA_SETTINGS_ID&path=CELLULAR_DATA_OPTIONS

Cellular Data (for devices with two SIMs)

prefs:root=MOBILE_DATA_SETTINGS_ID&path=MOBILE_DATA_SETTINGS

Personal Hotspot

root

prefs:root=MOBILE_DATA_SETTINGS_ID&path=INTERNET_TETHERING

Wi-Fi Password

prefs:root=MOBILE_DATA_SETTINGS_ID&path=INTERNET_TETHERING/Wi-Fi%20Password

Family Sharing

root

prefs:root=MOBILE_DATA_SETTINGS_ID&path=INTERNET_TETHERING/Family%20Sharing

[Family Member Name]

prefs:root=MOBILE_DATA_SETTINGS_ID&path=INTERNET_TETHERING/Family%20Sharing/[URL-encoded Family Member Name]

System Services

prefs:root=MOBILE_DATA_SETTINGS_ID&path=System%20Services

[plan name]

prefs:root=MOBILE_DATA_SETTINGS_ID&path=[plan name]

Reset Statistics

prefs:root=MOBILE_DATA_SETTINGS_ID#Reset%20Statistics

Personal Hotspot

root

prefs:root=INTERNET_TETHERING

Wi-Fi Password

prefs:root=INTERNET_TETHERING&path=Wi-Fi%20Password

Family Sharing

root

prefs:root=INTERNET_TETHERING&path=Family%20Sharing

[Family Member Name]

prefs:root=INTERNET_TETHERING&path=Family%20Sharing/[URL-encoded Family Member Name]

VPN

root

prefs:root=VPN

[VPN configuration]

root

prefs:root=VPN&path=[URL-encoded VPN Configuration Name]

Delete VPN

prefs:root=VPN&path=[URL-encoded VPN Configuration Name]/Delete%20VPN

Add VPN Configuration…

prefs:root=VPN&path=Add%20VPN%20Configuration%E2%80%A6

Notifications

root

prefs:root=NOTIFICATIONS_ID

App Name

prefs:root=NOTIFICATIONS_ID&path=App%20Bundle%20ID

Show Previews

prefs:root=NOTIFICATIONS_ID&path=SHOW_PREVIEW_GROUP_ID (credit to

Siri Suggestions

prefs:root=NOTIFICATIONS_ID&path=Siri%20Suggestions

Sounds

root

prefs:root=Sounds

Ringtone

prefs:root=Sounds&path=Ringtone

Text Tone

prefs:root=Sounds&path=Text_Messages

New Voicemail

prefs:root=Sounds&path=Voicemail

New Mail

prefs:root=Sounds&path=NEW_MAIL

Sent Mail

prefs:root=Sounds&path=SENT_MAIL

Calendar Alerts

prefs:root=Sounds&path=Calendar%20Alarm

Reminder Alerts

prefs:root=Sounds&path=Reminder%20Alerts

AirDrop

prefs:root=Sounds&path=AIRDROP

Do Not Disturb

root

prefs:root=DO_NOT_DISTURB

Allow Calls From

prefs:root=DO_NOT_DISTURB&path=Allow%20Calls%20From

Auto-Reply To

prefs:root=DO_NOT_DISTURB&path=DRIVER_MODE_AUTOREPLY

Auto-Reply

prefs:root=DO_NOT_DISTURB&path=DRIVER_MODE_AUTOREPLY_MESSAGE

Screen Time

root

prefs:root=SCREEN_TIME

Turn On Screen Time

prefs:root=SCREEN_TIME&path=Turn%20On%20Screen%20Time

See All Activity

prefs:root=SCREEN_TIME&path=SCREEN_TIME_SUMMARY

Downtime

prefs:root=SCREEN_TIME&path=DOWNTIME

App Limits

prefs:root=SCREEN_TIME&path=APP_LIMITS

Always Allowed

prefs:root=SCREEN_TIME&path=ALWAYS_ALLOWED

Communication Limits

prefs:root=SCREEN_TIME&path=COMMUNICATION_LIMITS

Content & Privacy Restrictions

prefs:root=SCREEN_TIME&path=CONTENT_PRIVACY

General

root

prefs:root=General

About

root

prefs:root=General&path=About

SEID

prefs:root=General&path=About/SEID

Certificate Trust Settings

prefs:root=General&path=About/CERT_TRUST_SETTINGS

Software Update

prefs:root=General&path=SOFTWARE_UPDATE_LINK

AirDrop

prefs:root=General&path=AIRDROP_LINK

AirPlay & Handoff

prefs:root=General&path=CONTINUITY_SPEC

CarPlay

prefs:root=General&path=CARPLAY

Storage

root

prefs:root=General&path=STORAGE_MGMT

AppName

prefs:root=General&path=STORAGE_MGMT/[App Bundle ID]

Background App Refresh

root

prefs:root=General&path=AUTO_CONTENT_DOWNLOAD

Background App Refresh

prefs:root=General&path=AUTO_CONTENT_DOWNLOAD/AUTO_CONTENT_DOWNLOAD

Date & Time

prefs:root=General&path=DATE_AND_TIME

Keyboard

root

prefs:root=General&path=Keyboard

Keyboards

prefs:root=General&path=Keyboard/KEYBOARDS

Hardware Keyboard

prefs:root=General&path=Keyboard/Hardware%20Keyboard

Text Replacement

prefs:root=General&path=Keyboard/USER_DICTIONARY

One Handed Keyboard

prefs:root=General&path=Keyboard/ReachableKeyboard

Language & Region

root

prefs:root=General&path=INTERNATIONAL

Device Language

prefs:root=General&path=INTERNATIONAL/DEVICE_LANGUAGE

Region

prefs:root=General&path=INTERNATIONAL/LOCALE

Calendar

prefs:root=General&path=INTERNATIONAL/CALENDAR

Numbers

prefs:root=General&path=INTERNATIONAL/NUMBERING_SYSTEM

Temperature Unit

prefs:root=General&path=INTERNATIONAL/TEMPERATURE_UNIT

Dictionary

prefs:root=General&path=DICTIONARY

VPN

root

prefs:root=General&path=VPN

[VPN Configuration Name]

root

prefs:root=General&path=VPN/[URL-encoded VPN Configuration Name]

Delete VPN

prefs:root=General&path=VPN/[URL-encoded VPN Configuration Name]/Delete%20VPN

Add VPN Configuration…

prefs:root=General&path=VPN/Add%20VPN%20Configuration%E2%80%A6

DNS

prefs:root=General&path=VPN/DNS

Profiles

root

prefs:root=General&path=ManagedConfigurationList

Install Profile

prefs:root=General&path=ManagedConfigurationList/PurgatoryInstallRequested

Legal & Regulatory

prefs:root=General&path=LEGAL_AND_REGULATORY

Reset

prefs:root=General&path=Reset

Control Center

root

prefs:root=ControlCenter

Customize Controls

prefs:root=ControlCenter&path=CUSTOMIZE_CONTROLS

Action Button

root

prefs:root=ACTION_BUTTON

Display

root

prefs:root=DISPLAY

Options

prefs:root=DISPLAY&path=APPEARANCE_OPTIONS

Night Shift

prefs:root=DISPLAY&path=BLUE_LIGHT_REDUCTION

Auto Lock

prefs:root=DISPLAY&path=AUTOLOCK

Home Screen

root

prefs:root=HOME_SCREEN

Home Screen & Dock

root

prefs:root=HOME_SCREEN_DOCK

Multitasking

prefs:root=HOME_SCREEN_DOCK&path=MULTITASKING

Accessibility

root

prefs:root=ACCESSIBILITY

VoiceOver

root

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE

Speech

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/SPEECH_TITLE

Braille

root

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/BRAILLE_TITLE

Output

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/BRAILLE_TITLE/BrailleDisplayOutput

Input

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/BRAILLE_TITLE/BrailleDisplayInput

Braille Screen Input

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/BRAILLE_TITLE/BrailleGesturesInput

Braille Tables

root

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/BRAILLE_TITLE/tableIdentifier

Language

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/BRAILLE_TITLE/tableIdentifier/DefaultLanguage

Status Cells

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/BRAILLE_TITLE/STATUS_CELL

Verbosity

root

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/VERBOSITY

Punctuation

root

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/VERBOSITY/voiceOverPunctuationGroup

Media Descriptions

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/VERBOSITY/voiceOverMediaDescriptions

Audio

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/AUDIO_TITLE

Commands

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/CUSTOMIZE_COMMANDS

Activities

root

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/ACTIVITIES

Programming

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/ACTIVITIES/Programming

Add Activity…

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/ACTIVITIES/New

Rotor

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/WEB_ROTOR

Rotor Actions

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/ROTOR_ACTIONS

Typing

root

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/TYPING_OPTIONS

Typing Style

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/TYPING_OPTIONS/Typing%20Style

Phonetic Feedback

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/TYPING_OPTIONS/Phonetic%20Feedback

Modifier Keys

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/TYPING_OPTIONS/Modifier%20Keys

Keyboard Interaction Time

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/TYPING_OPTIONS/Keyboard%20Interaction%20Time

Navigate Images

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/INCLUDE_UNLABELED_IMAGES_TITLE

Double-tap Timeout

prefs:root=ACCESSIBILITY&path=VOICEOVER_TITLE/DOUBLE_TAP_INTERVAL_TITLE

Zoom

root

prefs:root=ACCESSIBILITY&path=ZOOM_TITLE

Keyboard Shortcuts

prefs:root=ACCESSIBILITY&path=ZOOM_TITLE/ZoomKeyboardShortcuts

Zoom Controller

prefs:root=ACCESSIBILITY&path=ZOOM_TITLE/ZoomSlug

Zoom Filter

prefs:root=ACCESSIBILITY&path=ZOOM_TITLE/ZoomFilter

Magnifier

prefs:root=ACCESSIBILITY&path=MAGNIFIER_TITLE

Display & Text Size

root

prefs:root=ACCESSIBILITY&path=DISPLAY_AND_TEXT

Larger Text

prefs:root=ACCESSIBILITY&path=DISPLAY_AND_TEXT/Larger%20Text

Color Filters

prefs:root=ACCESSIBILITY&path=DISPLAY_AND_TEXT/DISPLAY_FILTER_COLOR

Motion

prefs:root=ACCESSIBILITY&path=MOTION_TITLE

Spoken Content

root

prefs:root=ACCESSIBILITY&path=SPEECH_TITLE

Speech Controller

prefs:root=ACCESSIBILITY&path=SPEECH_TITLE/SpeechController

Customize Mouse Buttons

prefs:root=ACCESSIBILITY&path=SPEECH_TITLE/SpeechController/CustomizeMouseButtons

Highlight Content

prefs:root=ACCESSIBILITY&path=SPEECH_TITLE/QuickSpeakHighlight

Typing Feedback

prefs:root=ACCESSIBILITY&path=SPEECH_TITLE/TypingFeedback

Voices

prefs:root=ACCESSIBILITY&path=SPEECH_TITLE/QuickSpeakAccents

Audio Descriptions

prefs:root=ACCESSIBILITY&path=DESCRIPTIVE_VIDEO

Touch

root

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE

AssistiveTouch

root

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/AIR_TOUCH_TITLE

Customize Top Level Menu

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/AIR_TOUCH_TITLE/AssistiveTouchCustomize

Single-Tap

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/AIR_TOUCH_TITLE/Single-Tap

Idle Opacity

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/AIR_TOUCH_TITLE/IdleOpacity

Devices

root

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/AIR_TOUCH_TITLE/AssistiveTouchMouseDevices

Bluetooth Devices…

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/AIR_TOUCH_TITLE/AssistiveTouchMouseDevices/Bluetooth%20Devices%E2%80%A6

Mouse Keys

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/AIR_TOUCH_TITLE/AssistiveTouchMouseKeys

Pointer Style

root

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/AIR_TOUCH_TITLE/ASTMousePointerCustomization

Color

root

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/AIR_TOUCH_TITLE/ASTMousePointerCustomization/Color

Customize Mouse Buttons

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/AIR_TOUCH_TITLE/ASTMousePointerCustomization/Color/CustomizeMouseButtons

Auto-Hide

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/AIR_TOUCH_TITLE/ASTMousePointerCustomization/Auto-Hide

Movement Tolerance

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/AIR_TOUCH_TITLE/Movement%20Tolerance

Force/Haptic Touch

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/ForceTouch

Touch Accommodations

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/Touch%20Accommodations

Call Audio Routing

root

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/CALL_AUDIO_ROUTING

Auto-Answer Calls

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/CALL_AUDIO_ROUTING/callAudioRoutingAutoAnswer

Back Tap

prefs:root=ACCESSIBILITY&path=TOUCH_REACHABILITY_TITLE/Back%20Tap

Switch Control

root

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle

Switches

root

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/SwitchesIdentifier

Bluetooth Devices…

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/SwitchesIdentifier/BluetoothDevicesIdentifier

Scanning Style

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/Scanning%20Style

Pause on First Item

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/Pause%20on%20First%20Item

Move Repeat

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/Move%20Repeat

Long Press

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/Long%20Press

Tap Behavior

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/Tap%20Behavior

Focused Item After Tap

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/Focused%20Item%20After%20Tap

Hold Duration

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/Hold%20Duration

Ignore Repeat

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/Ignore%20Repeat

Gliding Cursor

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/Gliding%20Cursor

Head Tracking

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/CameraPointPickerSwitch

Speech

root

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/SpeechIdentifier

Voices

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/SpeechIdentifier/VoicesIdentifier

Menu Items

root

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/CustomizeMenuIdentifier

Top Level

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/CustomizeMenuIdentifier/Top%20Level

Gestures

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/CustomizeMenuIdentifier/Gestures

Device

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/CustomizeMenuIdentifier/Device

Settings

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/CustomizeMenuIdentifier/Settings

Media Controls

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/CustomizeMenuIdentifier/Media%20Controls

Saved Gestures

prefs:root=ACCESSIBILITY&path=ScannerSwitchTitle/CustomGesturesIdentifier

Voice Control

root

prefs:root=ACCESSIBILITY&path=CommandAndControlTitle

Language

prefs:root=ACCESSIBILITY&path=CommandAndControlTitle/LANGUAGE

Customize Commands

prefs:root=ACCESSIBILITY&path=CommandAndControlTitle/CUSTOMIZE_COMMANDS

Vocabulary

prefs:root=ACCESSIBILITY&path=CommandAndControlTitle/VOCABULARY

Overlay

prefs:root=ACCESSIBILITY&path=CommandAndControlTitle/ALWAYS_SHOW_OVERLAY

Home Button

prefs:root=ACCESSIBILITY&path=HOME_CLICK_TITLE

Apple TV Remote

prefs:root=ACCESSIBILITY&path=Apple%20TV%20Remote

Keyboards

root

prefs:root=ACCESSIBILITY&path=KEYBOARDS

Full Keyboard Access

prefs:root=ACCESSIBILITY&path=KEYBOARDS/Full%20Keyboard%20Access

Key Repeat

prefs:root=ACCESSIBILITY&path=KEYBOARDS/KEY_REPEAT

Sticky Keys

prefs:root=ACCESSIBILITY&path=KEYBOARDS/STICKY_KEYS

Slow Keys

prefs:root=ACCESSIBILITY&path=KEYBOARDS/SLOW_KEYS

Hearing Devices

prefs:root=ACCESSIBILITY&path=HEARING_AID_TITLE

Sound Recognition

root

prefs:root=ACCESSIBILITY&path=SOUND_RECOGNITION_TITLE

Sounds

prefs:root=ACCESSIBILITY&path=SOUND_RECOGNITION_TITLE/Sounds

RTT

prefs:root=ACCESSIBILITY&path=RTT

Audio/Visual

prefs:root=ACCESSIBILITY&path=AUDIO_VISUAL_TITLE

Subtitles & Captioning

prefs:root=ACCESSIBILITY&path=SUBTITLES_CAPTIONING

Guided Access

root

prefs:root=ACCESSIBILITY&path=GUIDED_ACCESS_TITLE

Passcode Settings

prefs:root=ACCESSIBILITY&path=GUIDED_ACCESS_TITLE/GuidedAccessSecurityLinkList

Time Limits

root

prefs:root=ACCESSIBILITY&path=GUIDED_ACCESS_TITLE/GuidedAccessTimeRestrictionsLinkList

Sound

prefs:root=ACCESSIBILITY&path=GUIDED_ACCESS_TITLE/GuidedAccessTimeRestrictionsLinkList/GUIDED_ACCESS_TIME_RESTRICTIONS_SOUND_TITLE

Display Auto-Lock

prefs:root=ACCESSIBILITY&path=GUIDED_ACCESS_TITLE/GuidedAccessAutoLockTime

Siri

prefs:root=ACCESSIBILITY&path=SIRI_SETTINGS_TITLE

Accessibility Shortcut

prefs:root=ACCESSIBILITY&path=TRIPLE_CLICK_TITLE

Wallpaper

root

prefs:root=Wallpaper

Siri

root

prefs:root=SIRI or prefs-siri-shortcuts:root

Language

prefs:root=SIRI&path=LANGUAGE_ID

Voice

prefs:root=SIRI&path=VOICE_ID

Siri Responses

prefs:root=SIRI&path=VOICE_FEEDBACK_ID

Siri & Dictation History

prefs:root=SIRI&path=HISTORY

AppName

prefs:root=SIRI&path=[App Bundle ID]

Apple Pencil

root

prefs:root=Pencil

Passcode

root

prefs:root=PASSCODE

Require Passcode

prefs:root=PASSCODE&path=PASSCODE_REQ

Emergency SOS

root

prefs:root=EMERGENCY_SOS

Exposure Notifications

root

prefs:root=EXPOSURE_NOTIFICATION

Battery

root

prefs:root=BATTERY_USAGE

Battery Health

prefs:root=BATTERY_USAGE&path=BATTERY_HEALTH

Privacy

root

prefs:root=Privacy

Location Services

root

prefs:root=Privacy&path=LOCATION

Share My Location

root

prefs:root=Privacy&path=LOCATION/LOCATION_SHARING

[Family Member Name]

prefs:root=Privacy&path=LOCATION/LOCATION_SHARING/[URL-encoded Family Member Name]

AppName

prefs:root=Privacy&path=LOCATION/[App Bundle ID]

System Services

prefs:root=Privacy&path=LOCATION/SYSTEM_SERVICES

Tracking

prefs:root=Privacy&path=USER_TRACKING

Contacts

prefs:root=Privacy&path=CONTACTS

Calendars

prefs:root=Privacy&path=CALENDARS

Reminders

prefs:root=Privacy&path=REMINDERS

Photos

root

prefs:root=Privacy&path=PHOTOS

AppName

prefs:root=Privacy&path=PHOTOS/[App Bundle ID]

Bluetooth

prefs:root=Privacy&path=BT_PERIPHERAL

Local Network

prefs:root=Privacy&path=LOCAL_NETWORK

Microphone

prefs:root=Privacy&path=MICROPHONE

Speech Recognition

prefs:root=Privacy&path=SPEECH_RECOGNITION

Camera

prefs:root=Privacy&path=CAMERA

Health

prefs:root=Privacy&path=HEALTH

HomeKit

prefs:root=Privacy&path=WILLOW

Media & Apple Music

prefs:root=Privacy&path=MEDIALIBRARY

Motion & Fitness

prefs:root=Privacy&path=MOTION

Analytics & Improvements

prefs:root=Privacy&path=PROBLEM_REPORTING

Advertising

prefs:root=Privacy&path=ADVERTISING

Record App Activity

prefs:root=Privacy&path=PRIVACY_REPORT

App Store

root

prefs:root=STORE

App Downloads

prefs:root=STORE&path=App%20Downloads

Video Autoplay

prefs:root=STORE&path=Video%20Autoplay

Wallet

root

prefs:root=PASSBOOK

Add Card

prefs:root=PASSBOOK&path=Add%20Card

Passwords

root

prefs:root=PASSWORDS

[Search Term]

prefs:root=PASSWORDS&search=[Search Term]

Passwords & Accounts

root

prefs:root=ACCOUNTS_AND_PASSWORDS

Add Account

root

prefs:root=ACCOUNTS_AND_PASSWORDS&path=ADD_ACCOUNT

iCloud

prefs:root=ACCOUNTS_AND_PASSWORDS&path=ADD_ACCOUNT/iCloud

Google

prefs:root=ACCOUNTS_AND_PASSWORDS&path=ADD_ACCOUNT/Gmail

AOL

prefs:root=ACCOUNTS_AND_PASSWORDS&path=ADD_ACCOUNT/AOL

Outlook

prefs:root=ACCOUNTS_AND_PASSWORDS&path=ADD_ACCOUNT/Outlook

Other

root

prefs:root=ACCOUNTS_AND_PASSWORDS&path=ADD_ACCOUNT/OTHER

Add Mail Account

prefs:root=ACCOUNTS_AND_PASSWORDS&path=ADD_ACCOUNT/OTHER/Add%20Mail%20Account

Add LDAP Account

prefs:root=ACCOUNTS_AND_PASSWORDS&path=ADD_ACCOUNT/OTHER/Add%20LDAP%20Account

Add CardDAV Account

prefs:root=ACCOUNTS_AND_PASSWORDS&path=ADD_ACCOUNT/OTHER/Add%20CardDAV%20Account

Add CalDAV Account

prefs:root=ACCOUNTS_AND_PASSWORDS&path=ADD_ACCOUNT/OTHER/Add%20CalDAV%20Account

Add Subscribed Calendar

prefs:root=ACCOUNTS_AND_PASSWORDS&path=ADD_ACCOUNT/OTHER/Add%20Subscribed%20Calendar

Fetch New Data

prefs:root=ACCOUNTS_AND_PASSWORDS&path=FETCH_NEW_DATA

Mail

root

prefs:root=MAIL

Notifications

prefs:root=MAIL&path=NOTIFICATIONS

Preview

prefs:root=MAIL&path=Preview

Swipe Options

root

prefs:root=MAIL&path=Swipe%20Options

Swipe Left

prefs:root=MAIL&path=Swipe%20Options/Swipe%20Left

Swipe Right

prefs:root=MAIL&path=Swipe%20Options/Swipe%20Right

Blocked

prefs:root=MAIL&path=Blocked

Muted Thread Action

prefs:root=MAIL&path=Muted%20Thread%20Action

Blocked Sender Options

prefs:root=MAIL&path=Blocked%20Sender%20Options

Mark Addresses

prefs:root=MAIL&path=Mark%20Addresses

Increase Quote Level

prefs:root=MAIL&path=Increase%20Quote%20Level

Include Attachments with Replies

prefs:root=MAIL&path=Include%20Attachments%20with%20Replies

Signature

prefs:root=MAIL&path=Signature

Default Account

prefs:root=MAIL&path=Default%20Account

Contacts

root

prefs:root=CONTACTS

Siri & Search

prefs:root=CONTACTS&path=SIRI_AND_SEARCH

Sort Order

prefs:root=CONTACTS&path=ContactsSortOrder

Display Order

prefs:root=CONTACTS&path=PersonNameOrder

Short Name

prefs:root=CONTACTS&path=PersonShortName

My Info

prefs:root=CONTACTS&path=MeCard

Calendar

root

prefs:root=CALENDAR

Siri & Search

prefs:root=CALENDAR&path=SIRI_AND_SEARCH

Time Zone Override

prefs:root=CALENDAR&path=TimeZoneCityArray

Alternate Calendars

prefs:root=CALENDAR&path=Alternate%20Calendars

Sync

prefs:root=CALENDAR&path=Sync

Default Alert Times

prefs:root=CALENDAR&path=Default%20Alert%20Times

Start Week On

prefs:root=CALENDAR&path=com.apple.mobilecal

Default Calendar

prefs:root=CALENDAR&path=Default%20Calendar

Notes

root

prefs:root=NOTES

Siri & Search

prefs:root=NOTES&path=SIRI_AND_SEARCH

Default Account

prefs:root=NOTES&path=Default%20Account

Password

prefs:root=NOTES&path=Password

Sort Notes By

prefs:root=NOTES&path=Sort%20Notes%20By

New Notes Start With

prefs:root=NOTES&path=New%20Notes%20Start%20With

Sort Checked Items

prefs:root=NOTES&path=Sort%20Checked%20Items

Lines & Grids

prefs:root=NOTES&path=Lines%20%26%20Grids

Note Backgrounds

prefs:root=NOTES&path=Note%20Backgrounds

Access Notes from Lock Screen

prefs:root=NOTES&path=Access%20Notes%20from%20Lock%20Screen

Reminders

root

prefs:root=REMINDERS

Siri & Search

prefs:root=REMINDERS&path=SIRI_AND_SEARCH

Default List

prefs:root=REMINDERS&path=DEFAULT_LIST

Voice Memos

root

prefs:root=VOICE_MEMOS

Siri & Search

prefs:root=VOICE_MEMOS&path=SIRI_AND_SEARCH

Clear Deleted

prefs:root=VOICE_MEMOS&path=RCVoiceMemosRecentlyDeletedWindowKey

Audio Quality

prefs:root=VOICE_MEMOS&path=RCVoiceMemosAudioQualityKey

Phone

root

prefs:root=Phone

Respond with Text

prefs:root=Phone&path=Respond%20with%20Text

Silence Unknown Callers

prefs:root=Phone&path=SILENCE_CALLS

Messages

root

prefs:root=MESSAGES

FaceTime

root

prefs:root=FACETIME

Siri & Search

prefs:root=FACETIME&path=SIRI_AND_SEARCH

Safari

root

prefs:root=SAFARI

AutoFill

prefs:root=SAFARI&path=AUTO_FILL

Content Blockers

prefs:root=SAFARI&path=CONTENT_BLOCKERS

Downloads

prefs:root=SAFARI&path=DOWNLOADS

Close Tabs

prefs:root=SAFARI&path=Close%20Tabs

Hide IP Address

prefs:root=SAFARI&path=Hide%20IP%20Address

Clear History and Website Data

prefs:root=SAFARI&path=CLEAR_HISTORY_AND_DATA

Page Zoom

prefs:root=SAFARI&path=Page%20Zoom

Request Desktop Website

prefs:root=SAFARI&path=Request%20Desktop%20Website

Reader

prefs:root=SAFARI&path=Reader

Camera

prefs:root=SAFARI&path=Camera

Microphone

prefs:root=SAFARI&path=Microphone

Location

prefs:root=SAFARI&path=Location

Advanced

prefs:root=SAFARI&path=ADVANCED

News

root

prefs:root=NEWS

Acknowledgements

prefs:root=NEWS&path=Acknowledgements

Translate

root

prefs:root=TRANSLATE

Maps

root

prefs:root=MAPS

Driving

prefs:root=MAPS&path=Driving

Walking

prefs:root=MAPS&path=Walking

Transit

prefs:root=MAPS&path=Transit

Cycling

prefs:root=MAPS&path=Cycling

Compass

root

prefs:root=COMPASS

Measure

root

prefs:root=MEASURE

Siri & Search

prefs:root=MEASURE&path=SIRI_AND_SEARCH

Shortcuts

root

prefs:root=SHORTCUTS

Legal Notices

prefs:root=SHORTCUTS&path=Legal%20Notices

Health

root

prefs:root=HEALTH

Siri & Search

prefs:root=HEALTH&path=SIRI_AND_SEARCH

Home

root

prefs:root=HOMEKIT

Music

root

prefs:root=MUSIC

Cellular Data

prefs:root=MUSIC&path=com.apple.Music%3ACellularData

Dolby Atmos

prefs:root=MUSIC&path=com.apple.Music%3AAtmos

Audio Quality

prefs:root=MUSIC&path=com.apple.Music%3AAudioQuality

EQ

prefs:root=MUSIC&path=com.apple.Music%3AEQ

Optimize Storage

prefs:root=MUSIC&path=com.apple.Music%3AOptimizeStorage

Volume Limit

prefs:root=MUSIC&path=com.apple.Music%3AVolumeLimit

TV

root

prefs:root=TVAPP

Cellular

prefs:root=TVAPP&path=com.apple.videos%3AVideosPlaybackQualityCellularSetting

Wi-Fi

prefs:root=TVAPP&path=com.apple.videos%3AVideosPlaybackQualitySetting

Siri & Search

prefs:root=TVAPP&path=SIRI_AND_SEARCH

Video Definition

prefs:root=TVAPP&path=com.apple.videos%3APreferredPurchaseResolution

Photos

root

prefs:root=Photos

Cellular Data

prefs:root=Photos&path=CellularDataLinkList

Camera

root

prefs:root=CAMERA

Formats

prefs:root=CAMERA&path=CameraFormatsSettingsList

Record Video

prefs:root=CAMERA&path=Record%20Video

Record Slo-mo

prefs:root=CAMERA&path=Record%20Slo-mo

Preserve Settings

prefs:root=CAMERA&path=CameraPreserveSettingsSwitch

Books

root

prefs:root=IBOOKS

Siri & Search

prefs:root=IBOOKS&path=SIRI_AND_SEARCH

Skip Forward

prefs:root=IBOOKS&path=BKAudioBookSkipForward

Skip Back

prefs:root=IBOOKS&path=BKAudioBookSkipBackward

Acknowledgements

prefs:root=IBOOKS&path=Acknowledgements

Podcasts

root

prefs:root=com.apple.podcasts

Game Center

root

prefs:root=GAMECENTER

Add Friends

prefs:root=GAMECENTER&path=Add%20Friends

Terms and Conditions

prefs:root=GAMECENTER&path=Terms%20and%20Conditions

TV Provider

root

prefs:root=VIDEO_SUBSCRIBER

Developer

root

prefs:root=DEVELOPER_SETTINGS

Instruments/Logging

prefs:root=DEVELOPER_SETTINGS&path=DTInstrumentsSettings

Network Link Conditioner

prefs:root=DEVELOPER_SETTINGS&path=NLC

Multipath Networking

prefs:root=DEVELOPER_SETTINGS&path=MULTI_PATH_AGG

Fill Rate

prefs:root=DEVELOPER_SETTINGS&path=FILL_RATE

Ad Refresh Rate

prefs:root=DEVELOPER_SETTINGS&path=AD_REFRESH_RATE

TV Provider

prefs:root=DEVELOPER_SETTINGS&path=VideoSubscriberAccountSettings

Settings For App…

root

prefs:root=[App Bundle ID]

How to get the latest values

Get the latest values:

The steps for fetching the new values.

Open Xcode
Download iOS Simulator
Xcode -> Settings (⌘,) -> Components
Right click on the Simulator, click on show in Finder.
Right click on iOS xxxx.simruntime, click on Show package contents

Navigate to this folder in Terminal, I always like to use this particular command:

osascript -e 'tell application "Finder"'\
     -e "if (${1-1} <= (count Finder windows)) then"\
     -e "get POSIX path of (target of window ${1-1} as alias)"\
     -e 'else' -e 'get POSIX path of (desktop as alias)'\
     -e 'end if' -e 'end tell';

Type: open -R Contents/Resources/RuntimeRoot/System/Library/PreferenceManifestsInternal/PreferencesManifests.bundle/

In the plist files you'll find the values; example:

<dict>
 <key>keywords</key>
 <string>PASSCODE_KEYWORDS</string>
 <key>label</key>
 <string>TOUCH_ID__PASSCODE</string>
 <key>requiredCapabilities</key>
 <array>
     <string>touch-id</string>
 </array>
 <key>searchSectionID</key>
 <string>PASSCODE</string>
 <key>searchURL</key>
 <string>prefs:root=PASSCODE</string>
</dict>

(Semi-Automatically get the new values)

<?php
// Extract all iOS Settings URLs with their localized labels
// Please note, this script assumes that the files are in XML format.
// To convert binary plist files to XML, you can use the command:
// plutil -convert xml1 *

// Find all *.plist files in this directory
$files = glob("en.lproj/*.strings");

// This is our strings table to get the 'english' labels
$stringsTable = array();

foreach ($files as $file) {
    $fileContents = file_get_contents($file);

    // Find all '<key>...</key>' and corresponding '<string>...</string>' pairs
    preg_match_all('/<key>(.*?)<\/key>\s*<string>(.*?)<\/string>/', $fileContents, $matches, PREG_SET_ORDER);

    foreach ($matches as $match) {
        // Ensure both key and value are set
        if (!isset($match[1]) || !isset($match[2])) {
            continue;
        }

        $key = $match[1];
        $value = $match[2];
        $stringsTable[$key] = $value;
    }
}

// Find all *.plist files in this directory
$files = glob("*.plist");

$markdown = "# iOS Settings URLs\n\n";
$markdown .= "Latest update: " . date("Y-m-d H:i:s") . ".\n\n";

foreach ($files as $file) {
    if (preg_match('/Info.plist/', $file)) {
        continue;
    }

    $fileContents = file_get_contents($file);
    // Find all '<key>label</key>' and corresponding '<string>' pairs
    preg_match_all(
        '/<key>label<\/key>\s*<string>(.*?)<\/string>/',
        $fileContents, $matches1, PREG_SET_ORDER
    );

    // Find all '<key>searchURL</key>' and corresponding '<string>' pairs
    preg_match_all(
        '/<key>searchURL<\/key>\s*<string>(.*?)<\/string>/',
        $fileContents, $matches2, PREG_SET_ORDER
    );

    if (sizeof($matches1) !== sizeof($matches2)) {
        echo "Mismatched pairs in file: $file\n";
        continue;
    }

    for ($i = 0; $i < sizeof($matches1); $i++) {
        $key = $matches1[$i][1];
        $value = $matches2[$i][1];
        $label = $stringsTable[$key] ?? $key;
        $markdown .= "### {$label}\n({$value})[{$value}]\n\n";
    }
}

echo $markdown;

Why You Should Avoid Using AnyView in SwiftUI

Fri, 17 Oct 2025 22:36:57 +0200

SwiftUI, Apple's declarative framework for building user interfaces, introduces a variety of new concepts and tools for developers.
One such tool is AnyView, a type-erased wrapper for views.
While AnyView can be useful in certain scenarios, it’s generally advisable to avoid using it unless absolutely necessary.

Here’s why:

1. Performance Overhead

AnyView introduces a performance overhead because it erases the type information of the wrapped view.
This type erasure means that SwiftUI has to perform additional work to manage the view hierarchy, which can lead to slower rendering times and increased memory usage.
In performance-critical applications, this overhead can become significant.

2. Loss of Type Safety

One of Swift’s greatest strengths is its strong type system, which helps catch errors at compile time.
By using AnyView, you lose the benefits of type safety, making your code more prone to runtime errors.
This can lead to harder-to-debug issues and a less reliable codebase.

3. Reduced Readability and Maintainability

Using AnyView can make your code less readable and harder to maintain.
When you wrap a view in AnyView, you obscure the actual type of the view, making it more difficult for other developers (or even yourself) to understand what’s going on.
Clear and explicit code is easier to read, understand, and maintain.

4. Limited View Modifiers

When you use AnyView, you lose the ability to apply view-specific modifiers.
For example, if you wrap a Text view in AnyView, you can no longer use Text-specific modifiers like .font() or .foregroundColor().
This limitation can force you to unwrap the view or use less efficient workarounds.

5. Complicates View Hierarchy

AnyView can complicate your view hierarchy, making it harder to reason about the structure and behavior of your UI.
SwiftUI relies on the view hierarchy to manage state and rendering efficiently.
Introducing AnyView can disrupt this hierarchy, leading to unexpected behavior and bugs.

Alternatives to `AnyView`

Instead of using AnyView, consider these alternatives:

Conditional Views: Use conditional statements to handle different view types directly. SwiftUI’s Group and @ViewBuilder can help manage complex view hierarchies without type erasure.
See also my blog post about @ViewBuilder's for more information.
```
@ViewBuilder
var body: some View {
    if condition {
        Text("Hello, World!")
    } else {
        Image(systemName: "star")
    }
}
```

Enum-Based Views: Use enums to represent different view states and switch between them using switch statements. This approach maintains type safety and clarity.

enum ContentView {
    case text
    case image
}

var body: some View {
    switch contentView {
    case .text:
        Text("Hello, World!")
    case .image:
        Image(systemName: "star")
    }
}

Conclusion

While AnyView can be a quick fix for certain problems, it’s generally best to avoid it due to the performance overhead, loss of type safety, reduced readability, limited view modifiers, and complications in the view hierarchy.
By using alternative approaches, you can maintain the benefits of Swift’s type system and create more efficient, maintainable, and reliable SwiftUI applications.

A Guide to UI Testing in Swift

Fri, 17 Oct 2025 22:36:58 +0200

User Interface (UI) testing is a crucial aspect of app development, ensuring that your app's interface behaves as expected under various conditions.
This guide will walk you through the basics of UI testing in Swift and provide tips for creating effective tests.

What is UI Testing?

UI testing involves interacting with your app's user interface to verify that it functions correctly.
This includes checking that buttons respond to taps, text fields accept input, and views display the correct content.
UI tests simulate user interactions and can help catch bugs that might not be evident through unit tests alone.

Why UI Testing is Important

Catch UI Bugs Early: UI tests can detect issues such as layout problems, missing elements, or incorrect text before users encounter them.
Improve User Experience: By ensuring that your app's interface works as intended, you can provide a better experience for your users.
Increase Confidence in Code Changes: UI tests can help you verify that new features or changes don't break existing functionality.
Automate Testing: UI tests can be automated to run on different devices and configurations, saving time and effort during the testing process.

Key Components of UI Testing

XCUIApplication: Represents your app and provides methods to launch, terminate, and interact with it.
XCUIElement: Represents a UI element in your app, such as a button, label, or text field. You can query and interact with these elements.
XCUIElementQuery: An object that defines the search criteria a test uses to identify UI elements.
XCTAssert: Provides various assertion methods to verify that your tests produce the expected results.

Writing Effective UI Tests

Use Accessibility Identifiers: Assign unique accessibility identifiers to your UI elements.
This makes it easier to locate and interact with elements in your tests.
```
button.accessibilityIdentifier = "MyButton"
```
Launch Arguments and Environment Variables: Use launch arguments and environment variables to configure your app's state before running tests.
This can help you test different scenarios without modifying your app's code.
```
let app = XCUIApplication()
app.launchArguments.append("--UITestMode")
app.launchEnvironment["username"] = "testUser"
app.launch()
```

Wait for Elements: Use expectations to wait for elements to appear or disappear.
This ensures that your tests don't fail due to timing issues.

let label = app.staticTexts["MyLabel"]
let exists = NSPredicate(format: "exists == true")
expectation(for: exists, evaluatedWith: label, handler: nil)
waitForExpectations(timeout: 5, handler: nil)

Test Different Devices and Orientations: Run your tests on different devices and orientations to ensure your app works well across various screen sizes and configurations.

Running and Debugging UI Tests

Run Tests: You can run your UI tests by selecting the test target and clicking the "Run" button in Xcode.
Debug Tests: If a test fails, Xcode provides detailed logs and screenshots to help you diagnose the issue. Use breakpoints and the debugger to step through your test code and inspect the app's state.

UI Test functions

Basic Functionality

Testing if an element exists

XCTAssert(app.staticTexts["Welcome"].exists)

Waiting for an element to appear

"Waiting" is now built into XCTest.

let throwPokeball = app.staticTexts["The pokemon escaped!"]
XCTAssertFalse(throwPokeball.exists)

app.buttons["Catch!"].tap()
XCTAssert(throwPokeball.waitForExistence(timeout: 5))

Interacting with System Controls

Tapping buttons

Identify buttons by their accessibility label.

app.buttons["Add"].tap()

Typing text

First make sure the text field has focus by tapping on it.

let textField = app.textFields["Username"]
textField.tap()
textField.typeText("Wesley de Groot")

Dismissing alerts

app.alerts["Alert Title"].buttons["Button Title"].tap()

Dismissing action sheets

app.sheets["Sheet Title"].buttons["Button Title"].tap()

Handling system alerts

Present a location services authorization dialog to the user and dismiss it with the following code.

Before presenting the alert add a UI Interruption Handler. When this fires, dismiss with the "Allow" button.

addUIInterruptionMonitor(withDescription: "Location Services") { (alert) -> Bool in
  alert.buttons["Allow"].tap()
  return true
}

app.buttons["Request Location"].tap()
app.tap() // need to interact with the app again for the handler to fire

Sliding sliders

This will slide the value of the slider to 70%.

app.sliders.element.adjust(toNormalizedSliderPosition: 0.7)

Interacting with pickers

A picker:

app.pickerWheels.element.adjust(toPickerWheelValue: "Picker Wheel Item Title")

Tapping links in web views

app.links["Share this"].tap()

Interactions

Pull to refresh

You can simulate a pull-to-refresh action by swiping down on the screen.
(if it is not refreshing, try calling it twice)

app.tables.swipeDown()

Pushing and popping view controllers

Test if a view controller was pushed onto the navigation stack.

app.buttons["More Info"].tap()
XCTAssert(app.navigationBars["Volleyball?"].exists)

Pop a view controller by tapping the back button in the navigation bar and assert that the title in the navigation bar has changed.

app.navigationBars.buttons.elementBoundByIndex(0).tap()
XCTAssert(app.navigationBars["Volley"].exists)

Screenshots

Taking a screenshot

// Take a screenshot
let screenshot = XCUIScreen.main.screenshot()

// Attach the screenshot to the test report
let fullScreenshotAttachment = XCTAttachment(screenshot: screenshot)

// Set the attachment's lifetime to keep it around beyond the test run
fullScreenshotAttachment.lifetime = .keepAlways

// Add the attachment to the test report
add(fullScreenshotAttachment)

Setting Up UI Testing in Xcode

Create a UI Test Target: When you create a new project in Xcode, you can add a UI test target by selecting the "Include UI Tests" checkbox.
If you already have a project, you can add a UI test target by going to File > New > Target and selecting "UI Testing Bundle".

Write Your First UI Test: Xcode generates a template UI test file for you. Open this file and you'll see a basic test method.
You can start writing your own tests by using the XCUIApplication class to interact with your app.

import XCTest

class MyAppUITests: XCTestCase {

    func testExample() {
        let app = XCUIApplication()
        app.launch()

        // Interact with the UI
        let button = app.buttons["MyButton"]
        XCTAssertTrue(button.exists)
        button.tap()

        let label = app.staticTexts["MyLabel"]
        XCTAssertEqual(label.label, "Expected Text")
    }
}

Frameworks for UI Testing in Swift.

XCUITestHelper Framework benefits

XCUITestHelper by Me I've written this framework because I was missing some (for me essential) features.

XCUIApplication.setLanguage(to:)
This sets the user-interface language of the application which you are running.
XCUIApplication.wait(for:)
This wait for a defined period before continuing
XCUIApplication.navigateBack()
This navigates back (if you are using a NavigationView)
XCUIElementQuery.random
This selects a random element
XCUIElementQuery.lastMatch
This gives the last match of an predicate
XCUIElementQuery.subscript(_:)
This supports that you can use listOfElements[number]
XCUIElementQuery.type(in:text:action:)
This types some text in the inputfield and can press continue/enter.

XCAppTest Framework benefits

XCAppTest by Łukasz Rutkowski adds a ton of extra functions for testing.
I want to highlight those in particular:

XCUIElement.tapWhenReady(timeout:_:file:line:)
This taps the element when it is ready.
XCUIElement.tapIfExists(timeout:_:file:line:)
This taps the element if it exists.
XCUIElement.pressWhenReady(forDuration:timeout:_:file:line:)
This presses the element when it is ready.
XCTestCase.run(_:function:block:)
This runs a function on the element.

Bonus: Taking screenshots for the App Store

Taking screenshots for the App Store can be a tedious task.
It is possible to automate this with UI tests.
I refer to a blog post of my friend Daniel for this.

Daniel uses this function to name the screenshots:

func takeScreenshot(named name: String) {
    // Take the screenshot
    let fullScreenshot = XCUIScreen.main.screenshot()

    // Create a new attachment to save our screenshot
    // and give it a name consisting of the "named"
    // parameter and the device name, so we can find
    // it later.
    let screenshotAttachment = XCTAttachment(
        uniformTypeIdentifier: "public.png", 
        name: "Screenshot-\(UIDevice.current.name)-\(name).png",
        payload: fullScreenshot.pngRepresentation, 
        userInfo: nil)

    // Usually Xcode will delete attachments after 
    // the test has run; we don't want that!
    screenshotAttachment.lifetime = .keepAlways

    // Add the attachment to the test log, 
    // so we can retrieve it later
    add(screenshotAttachment)
}

With a bash script, you can run the tests on different simulators, languages, and appearances.
This script will create a folder structure with the screenshots for each combination.

#!/bin/bash

# The Xcode project to create screenshots for
projectName="./Libi.xcodeproj"

# The scheme to run tests for
schemeName="Libi"

# All the simulators we want to screenshot
# Copy/Paste new names from Xcode's
# "Devices and Simulators" window
# or from `xcrun simctl list`.
simulators=(
    "iPhone 8"
    "iPhone 11 Pro"
    "iPhone 11 Pro Max"
    "iPad Pro (12.9-inch) (3rd generation)"
    "iPad Pro (9.7-inch)"
)

# All the languages we want to screenshot (ISO 3166-1 codes)
languages=(
    "en"
    "de"
    "fr"
)

# All the appearances we want to screenshot
# (options are "light" and "dark")
appearances=(
    "light"
    "dark"
)

# Save final screenshots into this folder (it will be created)
targetFolder="/Users/breakthesystem/Desktop/LibiScreenshots"

## No need to edit anything beyond this point
for simulator in "${simulators[@]}"
do
    for language in "${languages[@]}"
    do
        for appearance in "${appearances[@]}"
        do
            rm -rf /tmp/LibiDerivedData/Logs/Test
            echo "📲  Building and Running for $simulator in $language"

            # Boot up the new simulator and set it to 
            # the correct appearance
            xcrun simctl boot "$simulator"
            xcrun simctl ui "$simulator" appearance $appearance

            # Build and Test
            xcodebuild \
                -testLanguage $language \
                -scheme $schemeName \
                -project $projectName \
                -derivedDataPath '/tmp/LibiDerivedData/' \
                -destination "platform=iOS Simulator,name=$simulator" \
                build test
            echo "🖼  Collecting Results..."
            mkdir -p "$targetFolder/$simulator/$language/$appearance"
            find /tmp/LibiDerivedData/Logs/Test -maxdepth 1 -type d -exec xcparse screenshots {} "$targetFolder/$simulator/$language/$appearance" \;
        done
    done

    echo "✅  Done"
done

Conclusion

UI testing is an essential part of ensuring your app's quality and reliability.
By writing effective UI tests in Swift, you can catch bugs early, improve your app's user experience, and gain confidence in your code.
With the XCTest framework and the tips provided in this guide, you'll be well on your way to mastering UI testing in Swift.

Resources:

Thanks:

Thanks Łukasz for mentioning XCAppTest!
Thanks Daniel for your Blog post

Nb: This post is using different headings and is written in a different style than the other posts.
Let me know if you like it or not.

Understanding assertions in Swift

Fri, 17 Oct 2025 22:36:58 +0200

Assertions are a powerful tool in Swift that help developers ensure their code behaves as expected during runtime. They allow you to test assumptions and catch potential issues early in the development process. In this blog post, we'll explore what assertions are, how to use them, and the different types available in Swift.

What Are Assertions?

Assertions are runtime checks that verify whether a condition is true. If the condition evaluates to false, the program terminates and prints an error message. This helps developers identify and fix bugs early, ensuring that the code behaves as intended.

Why Use Assertions?

Using assertions in your code can help:

Catch Bugs Early: By verifying assumptions, you can catch potential issues before they become harder to debug.
Improve Code Quality: Assertions make your code more robust and reliable by ensuring that it meets certain conditions.
Simplify Debugging: When an assertion fails, it provides a clear indication of what went wrong, making it easier to pinpoint the issue.

Types of Assertions in Swift

Swift provides several types of assertions, each serving a different purpose:

assert()
- Usage: assert(condition, "Message")
- Description: Checks if the condition is true. If not, it prints the message and terminates the program.
- Terminates app in release mode: No.
- When to use: Use assert() to verify assumptions that are only relevant during development.
- Example:
```
let age = 15
assert(age >= 18, "Access denied - You must be at least 18 years old.")
```
assertionFailure()
- Usage: assertionFailure("Message")
- Description: Always triggers a failure, printing the message and terminating the program.
- Terminates app in release mode: No.
- When to use: Use assertionFailure() to indicate that a specific code path should never be reached.
- Example:
```
assertionFailure("This code should never be reached.")
```
precondition()
- Usage: precondition(condition, "Message")
- Description: Checks if the condition is true. If not, it prints the message and terminates the program.
- Terminates app in release mode: Yes.
- When to use: Use precondition() for critical conditions that should never be violated.
- Example:
```
let index = -1
precondition(index >= 0, "Index must be non-negative.")
```
preconditionFailure()
- Usage: preconditionFailure("Message")
- Description: Always triggers a failure, printing the message and terminating the program.
- Terminates app in release mode: Yes.
- Example:
```
preconditionFailure("This code should never be reached.")
```
fatalError()
- Usage: fatalError("Message")
- Description: Unconditionally terminates the program and prints the message. Use it for serious errors that should never occur.
- Terminates app in release mode: Yes.
- When to use: Use fatalError() for unrecoverable errors that require immediate termination of the program.
- Example:
```
fatalError("Unrecoverable error occurred.")
```

When to Use Assertions

Debugging: Use assert() and assertionFailure() during development to catch bugs early.
Critical Conditions: Use precondition() and preconditionFailure() for conditions that must always be true, even in production.
Unrecoverable Errors: Use fatalError() for serious issues that require immediate termination of the program.

Conclusion

Assertions are a valuable tool in Swift that help ensure your code behaves as expected. By using assertions effectively, you can catch bugs early, improve code quality, and simplify debugging. Remember to choose the appropriate type of assertion based on the context and build configuration.

Resources:

https://developer.apple.com/documentation/swift/debugging-and-reflection

Safely unwrap optional values in SwiftUI bindings

Fri, 17 Oct 2025 22:36:59 +0200

Bindings are a powerful feature in SwiftUI that allow you to connect your views to your data. However, when working with optional values, you need to be careful to avoid crashes due to force unwrapping. In this blog post, we'll explore how to safely unwrap optional values in SwiftUI bindings using the Binding initializer and the nil-coalescing operator.

What is `Binding`?

Bindings in SwiftUI are a way to create a two-way connection between a view and a piece of data. They allow you to update the data from the view and reflect the changes in the view when the data changes. Bindings are typically used with @State properties to create reactive UIs.

The Problem with Optional Values

You can't directly bind an optional value to a view in SwiftUI because bindings require non-optional values. If you try to bind an optional value directly, you'll get a compiler error. For example:

@State var optionalValue: Bool?

var body: some View {
    Switch(isOn: $optionalValue) { // Error: Cannot convert value of type 'Binding<Bool?>' to expected argument type 'Binding<Bool>'
        Text("Toggle")
    }

To work around this issue, you need to safely unwrap the optional value before creating the binding.

Safely Unwrapping Optional Values

To safely unwrap an optional value in a SwiftUI binding, you unwrap the optional value using a if-let statement and then create the binding. Here's an example:

import SwiftUI

struct Person: Identifiable {
    let id: String
    var name: String
    var premiumEndDate: Date
}

@Observable
final class dataProvider {
    var person: Person?
}

struct ContentView: View {
    @State
    private var data: dataProvider = .init()

    var body: some View {
        // We safely unwrap the optional value before creating the new binding
        if let unwrapped = Binding($data.person) {
            // Use the unwrapped binding here
            Text("Premium end date is \(unwrapped.premiumEndDate)")
        } else {
            // Handle the case where the optional value is nil
            Text("Person is not a premium user")
        }
    }
}

Using the Nil-Coalescing Operator

Another way to safely unwrap optional values in SwiftUI bindings is to use the nil-coalescing operator (??).
This operator allows you to provide a default value in case the optional value is nil.

This is not supported by default for Bindings, but you can use the following workaround to achieve the same result.

import SwiftUI

func ??<T>(lhs: Binding<Optional<T>>, rhs: T) -> Binding<T> {
    Binding(
        get: { lhs.wrappedValue ?? rhs },
        set: { lhs.wrappedValue = $0 }
    )
}

Here's an example:

import SwiftUI

struct ContentView: View {
    @State
    private var optionalValue: Bool?

    var body: some View {
        // Use the nil-coalescing operator to provide a default value
        let unwrappedValue = $optionalValue ?? true

        Toggle(isOn: unwrappedValue) {
            Text("Toggle")
        }
    }
}

Caveats

When using the nil-coalescing operator to unwrap optional values in SwiftUI bindings, keep in mind that the default value you provide will be used if the optional value is nil. Make sure the default value is appropriate for your use case.

Wrap up

In this blog post, we explored how to safely unwrap optional values in SwiftUI bindings using the Binding initializer and the nil-coalescing operator. By safely unwrapping optional values, you can avoid crashes due to force unwrapping and create more robust SwiftUI views.

If you have any questions or comments, please feel free to leave them below.

Resources:

Hacktoberfest 2024

Fri, 17 Oct 2025 22:36:59 +0200

As the leaves change color and the air turns crisp, developers around the world gear up for one of the most exciting events in the open-source community: Hacktoberfest.
This annual celebration, organized by DigitalOcean, GitHub, and other partners, encourages developers to contribute to open-source projects throughout October.
If you're a (Swift) developer, Hacktoberfest is the perfect opportunity to dive into the world of open source, enhance your skills, and make meaningful contributions.
Let's explore how you can make the most of Hacktoberfest as a (Swift) developer.

What is Hacktoberfest?

Hacktoberfest is a month-long event that promotes open-source contributions.
Participants are encouraged to submit pull requests (PRs) to open-source repositories on GitHub.
By completing a certain number of PRs, participants can earn rewards.

Why Should Swift Developers Participate?

Skill Enhancement: Contributing to open-source projects allows you to work on real-world problems, enhancing your coding skills and learning new techniques.
Community Engagement: Hacktoberfest is a great way to connect with other developers, share knowledge, and collaborate on exciting projects.
Portfolio Building: Contributions to open-source projects are a valuable addition to your portfolio, showcasing your skills to potential employers.
Giving Back: Open source thrives on community contributions. By participating, you help improve the tools and libraries that you and others use daily.

Getting Started with Hacktoberfest

Sign Up: Register for Hacktoberfest on the official website.
Find Projects: Look for Swift projects that need contributions. You can filter repositories by language on GitHub to find Swift-specific projects.
Read the Guidelines: Each project has its own contribution guidelines. Make sure to read and follow them to ensure your PRs are accepted.
Start Contributing: Begin by tackling issues labeled "Hacktoberfest" or "good first issue." These are typically beginner-friendly and a great way to get started.

Tips for Successful Contributions

Communicate: Engage with project maintainers and other contributors. Ask questions if you're unsure about something.
Write Clear PRs: Ensure your pull requests are well-documented and clearly explain the changes you've made.
Test Thoroughly: Make sure your code works as expected and doesn't introduce new bugs.
Be Respectful: Open-source communities thrive on respect and collaboration. Be courteous and constructive in your interactions.

Recommended Swift Projects for Hacktoberfest

Here are a few Swift projects that welcome contributions:

AuroraEditor: Aurora Editor is a IDE built by the community, for the community, and written in Swift for the best native performance and feel for macOS.
SwiftLint: A tool to enforce Swift style and conventions.
Vapor: A web framework for Swift.
All of my SPM projects
Search on Hacktoberfest on GitHub, GitLab.

Conclusion

Hacktoberfest is a fantastic opportunity for Swift developers to contribute to the open-source community, learn new skills, and connect with like-minded individuals. Whether you're a seasoned developer or just starting out, there's a place for you in Hacktoberfest. So, roll up your sleeves, dive into some code, and make this October a month of meaningful contributions.

For more information and to register, visit the Hacktoberfest website.

Happy Hacktoberfest!

SwiftUI Development with DynamicUI

Fri, 17 Oct 2025 22:37:00 +0200

In the ever-evolving landscape of mobile app development, flexibility and efficiency are key.
One tool that stands out in achieving these goals is DynamicUI, a Swift Package designed to create SwiftUI user interfaces dynamically from JSON files.
Let's explore how DynamicUI can transform your development process.

What is DynamicUI?

DynamicUI is a Swift Package that allows developers to define their SwiftUI user interfaces using JSON files.
This approach enables the creation of dynamic and flexible UIs without the need for hardcoding every element.

Key Features

JSON-Driven UI: DynamicUI reads JSON files to construct SwiftUI views, making it easy to update and modify the UI without changing the code.
Flexibility: By using JSON to define the UI, developers can quickly adapt to changing requirements and design specifications¹.
Ease of Integration: Adding DynamicUI to your project is straightforward. You can include it as a dependency in your Package.swift file and start using it with minimal setup¹.

How to Use DynamicUI

Integrating DynamicUI into your SwiftUI project is simple. Here’s a quick example to get you started:

import DynamicUI

struct ContentView: View {
    var body: some View {
        if let jsonURL = Bundle.main.url(forResource: "layout", withExtension: "json"),
           let jsonData = try? Data(contentsOf: jsonURL),
           let dynamicView = try? DynamicUI(jsonData: jsonData) {
            dynamicView
        } else {
            Text("Failed to load UI")
        }
    }
}

In this example, DynamicUI reads a JSON file named layout.json from the app bundle and constructs the corresponding SwiftUI view. This approach allows for rapid UI changes by simply updating the JSON file.

Benefits of Using DynamicUI

Rapid Prototyping: With DynamicUI, you can quickly prototype different UI layouts by modifying the JSON file, making it ideal for iterative design processes.
Reduced Code Complexity: By defining the UI in JSON, you can keep your Swift codebase clean and focused on business logic rather than UI details.
Enhanced Collaboration: Designers and developers can work more closely together, with designers providing JSON files that developers can directly use to build the UI.
UI Updates from the Cloud: DynamicUI can be extended to fetch JSON files from a server, enabling real-time updates to the UI without requiring app updates¹.

Caveats

As of writing, DynamicUI does support (basic) support for callbacks, and not all modifiers are supported yet, i'd recommend to check out the GitHub repository to find out if your feature is working, and i'd love if you can make a contribution if you see something what you can improve.

Conclusion

DynamicUI is a powerful tool for any SwiftUI developer looking to enhance their development workflow. By leveraging JSON to define user interfaces, DynamicUI offers a flexible and efficient way to create dynamic and responsive UIs.

For more details and to get started with DynamicUI, visit the GitHub repository.

Simplifying multiplatform Colors

Fri, 17 Oct 2025 22:37:01 +0200

Sometimes you are building for multiple platforms and you want to use the same color across all of them.
This is where the Colors package comes in handy.
It provides a set of predefined system colors that you can use in your SwiftUI projects.

Installation

To use the Colors package in your project, add the following dependency to your Package.swift file:

dependencies: [
    .package(url: "https://github.com/0xWDG/Colors", branch: "main")
]

Then, add Colors as a dependency for your target:

targets: [
    .target(
        name: "YourTarget",
        dependencies: [
            .product(name: "Colors", package: "Colors")
        ]
    )
]

Finally, import the Colors module in your Swift files:

import Colors

Use the predefined colors in your SwiftUI views:


import SwiftUI
import Colors

struct ContentView: View {
    var body: some View {
        VStack {
            Text("Hello, World!")
                .foregroundColor(Color.label)
            Text("Hello, World!")
                .foregroundColor(Color.systemTeal)
            Text("Hello, World!")
                .foregroundColor(Color.systemGray3)
            Text("Hello, World!")
                .foregroundColor(Color.quaternaryLabel)
        }
    }
}

Which colors are available?

Color	Light Mode	Dark Mode	(Original) Platforms
.lightText	#ffffffff	#ffffffff	iOS
.darkText	#000000ff	#000000ff	iOS
.placeholderText	#3d3d42ff	#eaeaf4ff	iOS
.label	#000000ff	#ffffffff	iOS, tvOS
.secondaryLabel	#3d3d42ff	#eaeaf4ff	iOS, tvOS
.tertiaryLabel	#3d3d42ff	#eaeaf4ff	iOS, tvOS
.quaternaryLabel	#3d3d42ff	#eaeaf4ff	iOS, tvOS
.systemBackground	#ffffffff	#000000ff	iOS
.secondarySystemBackground	#f2f2f7ff	#1c1c1eff	iOS
.tertiarySystemBackground	#ffffffff	#2b2b2dff	iOS
.systemFill	#77777fff	#77777fff	iOS
.secondarySystemFill	#77777fff	#77777fff	iOS
.tertiarySystemFill	#75757fff	#75757fff	iOS
.quaternarySystemFill	#72727fff	#75757fff	iOS
.systemGroupedBackground	#f2f2f7ff	#000000ff	iOS
.secondarySystemGroupedBackground	#1c1c1eff	#ffffffff	iOS
.tertiarySystemGroupedBackground	#f2f2f7ff	#2b2b2dff	iOS
.systemGray	#8e8e93ff	#8e8e93ff	iOS, tvOS, visionOS
.systemGray2	#adadb2ff	#636366ff	iOS, visionOS
.systemGray3	#c6c6ccff	#474749ff	iOS, visionOS
.systemGray4	#d1d1d6ff	#3a3a3dff	iOS, visionOS
.systemGray5	#e5e5eaff	#2b2b2dff	iOS, visionOS
.systemGray6	#f2f2f7ff	#1c1c1eff	iOS, visionOS
.separator	#3d3d42ff	#545459ff	iOS, tvOS, visionOS
.opaqueSeparator	#c6c6c6ff	#38383aff	iOS, tvOS
.link	#007affff	#0a84ffff	iOS, tvOS, visionOS
.systemBlue	#007affff	#0a84ffff	iOS, tvOS
.systemCyan	#32ade6ff	#64d2ffff	iOS, tvOS
.systemMint	#00c7beff	#63e6e2ff	iOS, tvOS
.systemPurple	#af51ddff	#bf59f2ff	iOS, tvOS
.systemGreen	#33c659ff	#30d159ff	iOS, tvOS
.systemYellow	#ffcc00ff	#ffd60aff	iOS, tvOS
.systemOrange	#ff9300ff	#ff9e0aff	iOS, tvOS
.systemPink	#ff2d54ff	#ff385eff	iOS, tvOS
.systemRed	#ff3a30ff	#ff443aff	iOS, tvOS
.systemTeal	#59c6f9ff	#63d1ffff	iOS, tvOS, macOS
.systemIndigo	#5956d6ff	#5e5be5ff	iOS, tvOS, macOS
.scrubberTexturedBackground	#ffffffff	#ffffffff	macOS
.textBackgroundColor	#ffffffff	#1e1e1eff	macOS
.controlTextColor	#000000ff	#ffffffff	macOS
.quaternaryLabelColor	#000000ff	#ffffffff	macOS
.findHighlightColor	#ffff00ff	#ffff00ff	macOS
.highlightColor	#ffffffff	#b5b5b5ff	macOS
.shadowColor	#000000ff	#000000ff	macOS
.windowFrameTextColor	#000000ff	#ffffffff	macOS
.windowBackgroundColor	#edededff	#333333ff	macOS
.keyboardFocusIndicatorColor	#0066f4ff	#19a8ffff	macOS
.separatorColor	#000000ff	#ffffffff	macOS
.selectedControlColor	#b2d6ffff	#3f638cff	macOS
.controlBackgroundColor	#ffffffff	#1e1e1eff	macOS
.secondaryLabelColor	#000000ff	#ffffffff	macOS
.tertiaryLabelColor	#000000ff	#ffffffff	macOS
.gridColor	#e5e5e5ff	#191919ff	macOS
.alternateSelectedControlTextColor	#ffffffff	#ffffffff	macOS
.unemphasizedSelectedContentBackgroundColor	#dbdbdbff	#444444ff	macOS
.textColor	#000000ff	#ffffffff	macOS
.systemBrown	#a3845eff	#aa8e68ff	iOS
.selectedContentBackgroundColor	#0063e0ff	#0059d1ff	macOS
.selectedTextColor	#000000ff	#ffffffff	macOS
.labelColor	#000000ff	#ffffffff	macOS
.placeholderTextColor	#000000ff	#ffffffff	macOS
.unemphasizedSelectedTextBackgroundColor	#dbdbdbff	#444444ff	macOS
.disabledControlTextColor	#000000ff	#ffffffff	macOS
.headerTextColor	#000000ff	#ffffffff	macOS
.linkColor	#0068d8ff	#3f9bffff	macOS
.selectedTextBackgroundColor	#b2d6ffff	#3f638cff	macOS
.unemphasizedSelectedTextColor	#000000ff	#ffffffff	macOS
.controlColor	#ffffffff	#ffffffff	macOS
.selectedControlTextColor	#000000ff	#ffffffff	macOS
.underPageBackgroundColor	#969696ff	#282828ff	macOS
.selectedMenuItemTextColor	#ffffffff	#ffffffff	macOS

Simplifying App Onboarding with OnboardingKit

Fri, 17 Oct 2025 22:37:01 +0200

Creating a smooth and engaging onboarding experience is crucial for any app.
OnboardingKit, a SwiftUI package available on GitHub, provides a comprehensive solution to help developers create these experiences effortlessly.
In this article, we'll explore the features of OnboardingKit and how you can use it to enhance your app's onboarding process.

What is OnboardingKit?

OnboardingKit is a SwiftUI package designed to simplify the creation of onboarding experiences for iOS and macOS apps.
It offers a set of customizable views that you can use to create welcome screens, "what's new" screens, and other onboarding screens.
This package is particularly useful for developers looking to provide a seamless introduction to their app's features and updates.

Key Features

Welcome Screen: OnboardingKit allows you to create a welcome screen that can be displayed when the app is launched for the first time. This screen can include a series of slides, each highlighting different features of your app.
What's New Screen: You can use OnboardingKit to inform users about new features or updates in your app. This screen can be shown after an app update to keep users informed about the latest changes.
Customizable Views: The views provided by OnboardingKit are highly customizable. You can easily change the content, colors, and layout to match your app's design.
Helper Class: OnboardingKit includes a helper class that provides information about your app, such as the app name, version number, and build number. This can be useful for displaying dynamic content in your onboarding screens.

Installation

To install OnboardingKit, you can use Swift Package Manager. Add the following dependency to your Package.swift file:

dependencies: [
    .package(url: "https://github.com/0xWDG/OnboardingKit.git", .branch("main"))
]

Then, import OnboardingKit in your Swift files:

import OnboardingKit

Welcome Screem

Here's a basic example of how to use OnboardingKit to create a welcome screen:

import SwiftUI
import OnboardingKit

struct ContentView: View {
    @State private var showWelcomeScreen = {
        if UserDefaults.standard.bool(forKey: "hasSeenIntroduction") {
            return false
        }
        return true
    }()

    private var features: [WelcomeCell] = [
        WelcomeCell(image: "star", title: "Welcome", subtitle: "To %APP_NAME%")
    ]

    var body: some View {
        TabView {
            // Your tab view code
        }
        .sheet(isPresented: $showWelcomeScreen) {
            WelcomeScreen(show: $showWelcomeScreen, items: features) {
                UserDefaults.standard.setValue(true, forKey: "hasSeenIntroduction")
            }
        }
    }
}

In this example, the WelcomeScreen view is displayed as a sheet when the app is launched for the first time.
The WelcomeCell struct is used to define the content of each slide in the welcome screen.

What's new screen

OnboardingKit also supports also a "what's new" screen only, which you can pop up only when the app version changes:

import SwiftUI
import OnboardingKit

struct ContentView: View {
    @State private var showWhatsNew = {
        if let dictionary = Bundle.main.infoDictionary,
           let dVersion = dictionary["CFBundleShortVersionString"] as? String,
           let whatsNew = UserDefaults.standard.value(forKey: "whatsNew") as? String,
           whatsNew == dVersion {
            return false
        }
        return true
    }()

    var body: some View {
        TabView {
            // Your tab view code
        }
        .sheet(isPresented: $showWhatsNew) {
            WhatsNew(show: $showWhatsNew, text: "This is new!")
        }
    }
}

In this example, the WhatsNew view is displayed only if the app version has changed since the last launch.

Conclusion

OnboardingKit is a powerful tool for creating engaging and informative onboarding experiences in your SwiftUI apps.
By leveraging its customizable views and helper classes, you can ensure that your users have a smooth introduction to your app's features and updates.
Whether you're building a welcome screen or a "what's new" screen, OnboardingKit makes the process straightforward and efficient.

For more information and to get started with OnboardingKit, visit the OnboardingKit GitHub repository.

Simplifying Game Controller Integration with GameControllerKit

Fri, 17 Oct 2025 22:37:02 +0200

In the ever-evolving world of game development, integrating game controllers across multiple platforms can be a difficult task.
Enter GameControllerKit, a Swift package designed to streamline this process for developers working on iOS, macOS, and tvOS.
Let's dive into what makes this toolkit a game-changer.

What is GameControllerKit?

GameControllerKit is an open-source Swift package that simplifies the process of connecting and interacting with game controllers.
Whether you're developing for iOS, macOS, or tvOS, this toolkit provides a unified API to handle game controller inputs, control lights, and manage haptic feedback.

Key Features

Easy Connection Management: GameControllerKit makes it straightforward to interact with game controllers. The package handles the (dis)connections of game controllers, allowing developers to focus on gameplay rather than handling game controller conntections and setups.
Unified Input Handling: With a simple and intuitive API, developers can easily read inputs from various game controllers. This includes buttons, joysticks, and other control mechanisms, ensuring a seamless gaming experience across different devices.
Advanced Control Options: Beyond basic input handling, GameControllerKit allows developers to control the lights and haptics of connected controllers. This feature can be used to enhance the gaming experience by providing visual and tactile feedback to players.
Cross-Platform Support: One of the standout features of GameControllerKit is its support for multiple Apple platforms. Whether you're developing a game for iOS, macOS, or tvOS, this toolkit ensures consistent controller behavior across all devices.

Getting Started

To get started with GameControllerKit, you can add it to your project using Swift Package Manager. Here’s a quick guide:

Add the Package: In Xcode, go to File > Swift Packages > Add Package Dependency and enter the repository URL: https://github.com/0xWDG/GameControllerKit.
Import the Package: In your Swift files, import GameControllerKit to access its features:
```
import GameControllerKit
```

React to Controllers: Use the provided API to connect to game controllers and handle inputs:

let controller = GameControllerKit()
gameController.set(handler: { button, pressed, controller in
    // Handle controller input
})

Demo Application

import SwiftUI
import GameControllerKit

struct ContentView: View {
    /// The game controller kit
    @State
    var gameController = GameControllerKit()

    /// Log
    @State
    var log: [String] = []

    var body: some View {
        VStack {
            Button {
                gameController.set(color: .GCKRandom)
            } label: {
                Text("Random Color")
            }

            Text("Controller: \(gameController.controller?.productCategory ?? "None"), " +
                 "\((gameController.controllerType ?? .generic).description)")
            Text("Last action:\n\(String(describing: gameController.lastAction)).")

            GCKControllerView()
                .environmentObject(gameController)

            List {
                ForEach(log.reversed(), id: \.self) { text in
                    Text(text)
                }
            }
        }
        .padding()
        .onAppear {
            gameController.set(handler: handler)
        }
    }

    /// Handler
    ///
    /// - Parameters:
    ///   - action: action
    ///   - pressed: is the button pressed?
    ///   - controller: which controller?
    public func handler(
        action: GCKAction,
        pressed: Bool,
        controller: GCKController
    ) {
        log.append(
            "\(String(describing: action))(\(action.position.arrowRepresentation)) \(pressed ? "Pressed" : "Unpressed"), " +
            "Controller #id \(String(describing: controller.playerIndex.rawValue))"
        )

        if action == .buttonA && pressed {
            // set to a random color
            gameController.set(color: .GCKRandom)
        }
    }
}

Screenshots:

iOS

MacOS

tvOS

Conclusion

GameControllerKit is a powerful tool for game developers looking to integrate game controllers into their projects with ease. Its simple API, cross-platform support, and advanced control options make it an invaluable resource for creating immersive gaming experiences. Whether you're a seasoned developer or just starting out, GameControllerKit can help you take your game to the next level.

Check out the GameControllerKit repository to learn more and start integrating it into your projects today!

Enhancing SwiftUI with CachedAsyncImage

Fri, 17 Oct 2025 22:37:02 +0200

In the world of mobile app development, performance and user experience are paramount.
One common challenge developers face is efficiently loading and caching images.
Enter CachedAsyncImage, a Swift Package designed to simplify this process.
Let's dive into what makes CachedAsyncImage a valuable tool for iOS and macOS developers.

What is CachedAsyncImage?

CachedAsyncImage is a Swift Package that extends the capabilities of SwiftUI's AsyncImage by adding caching functionality. This means that images loaded from the web can be stored locally, reducing the need for repeated network requests and improving app performance.

Key Features

Asynchronous Image Loading: Just like AsyncImage, CachedAsyncImage loads images asynchronously, ensuring that your app's UI remains responsive.
Built-in Caching: By default, CachedAsyncImage uses URLCache.shared to store images. This can be customized to use different caching mechanisms if needed.
Simple Integration: Integrating CachedAsyncImage into your project is straightforward. You can add it as a dependency in your Package.swift file and start using it with minimal setup¹.

How to Use CachedAsyncImage

Using CachedAsyncImage is as simple as replacing AsyncImage with CachedAsyncImage in your SwiftUI views.
Here’s a quick example:

import SwiftUI
import CachedAsyncImage

struct ContentView: View {
    var body: some View {
        VStack {
            CachedAsyncImage(
                url: URL(
                    string: "https://wesleydegroot.nl/assets/avatar/avatar.webp"
                )
            ) { image in
                image
                    .resizable()
                    .frame(width: 250, height: 250)
            } placeholder: {
                ProgressView()
            }
        }
        .padding()
    }
}

Or a more advanced example:

import CachedAsyncImage

struct ContentView: View {
    let imageURL = URL(string: "https://wesleydegroot.nl/assets/avatar/avatar.webp")!

    var body: some View {
        CachedAsyncImage(url: imageURL) { phase in
            switch phase {
            case .empty:
                ProgressView()
            case .success(let image):
                image
                    .resizable()
                    .aspectRatio(contentMode: .fit)
            case .failure:
                Image(systemName: "photo")
            @unknown default:
                EmptyView()
            }
        }
        .frame(width: 100, height: 100)
    }
}

In this example, CachedAsyncImage handles the image loading and caching seamlessly.
The phase parameter allows you to manage different states (loading, success, failure) effectively.

Benefits of Using CachedAsyncImage

Improved Performance: By caching images, you reduce the number of network requests, leading to faster load times and a smoother user experience.
Reduced Data Usage: Caching images locally means less data is consumed, which is beneficial for users on limited data plans.
Enhanced User Experience: With faster image loading times, users are less likely to experience delays or interruptions while using your app.

Conclusion

CachedAsyncImage is a powerful tool for any SwiftUI developer looking to enhance their app's performance and user experience. By integrating this package, you can ensure that images are loaded efficiently and cached effectively, providing a seamless experience for your users.

For more details and to get started with CachedAsyncImage, visit the GitHub repository.

Thanks

CachedAsyncImage is based on swiftui-cached-async-image.

Inspect: A Powerful Tool for SwiftUI Developers

Fri, 17 Oct 2025 22:37:03 +0200

As SwiftUI continues to evolve, developers are constantly seeking tools to streamline their workflow and enhance their debugging capabilities.
One such tool that stands out is Inspect, a Swift Package designed to provide deeper insights into SwiftUI views.
Let's explore what makes Inspect an essential addition to your development toolkit.

What is Inspect?

Inspect is a Swift Package that allows developers to access the underlying *Kit elements of SwiftUI views.
This capability is particularly useful for debugging and testing, as it provides a way to inspect and manipulate the internal components of SwiftUI views.

Key Features

Deep Inspection: Inspect enables you to delve into the underlying UIKit or AppKit elements of SwiftUI views, offering a granular level of detail that is not typically accessible¹.
Enhanced Debugging: By exposing the internal structure of SwiftUI views, Inspect makes it easier to identify and resolve issues, leading to more robust and reliable applications¹.

How to Use Inspect

Integrating Inspect into your SwiftUI project is simple. Here’s a quick example to get you started:

import SwiftUI
import Inspect

struct ContentView: View {
#if os(macOS)
    let PlatformImageView = NSImageView.self
#else
    let PlatformImageView = UIImageView.self
#endif

    var body: some View {
        VStack {
            Image(systemName: "star")
                .inspect(PlatformImageView) { view in
                    print(view)
                }
        }
        .padding()
    }
}

In this example, .inspect() is used to access the underlying UIImageView or NSImageView element of the Image view.

In the following example, .inspectVC() is used to access the UITabBarController or NSTabViewController of a List view:

import SwiftUI
import Inspect

struct ContentView: View {
    var body: some View {
        List {
            Text("Item 1")
            Text("Item 2")
            Text("Item 3")
            Text("Item 4")
            Text("Item 5")
        }
        .inspectVC({ $0.tabBarController }) { view
            print(view)
        }
        .padding()
    }
}

Benefits of Using Inspect

Improved Debugging: With the ability to inspect underlying elements, you can quickly identify and fix issues, leading to more stable and reliable applications.
Enhanced Testing: Inspect provides a way to verify the internal state and structure of your views, making it easier to write comprehensive tests.
Greater Control: By exposing the underlying elements, Inspect gives you more control over your SwiftUI views, allowing for more precise adjustments and customizations.

Conclusion

Inspect is a powerful tool for any SwiftUI developer looking to enhance their debugging and testing capabilities. By providing access to the underlying *Kit elements of SwiftUI views, Inspect offers a level of insight and control that can significantly improve your development workflow.

For more details and to get started with Inspect, visit the GitHub repository.

SwiftLeeds 2024 (day 1)

Fri, 17 Oct 2025 22:37:03 +0200

It's that time of year again!
SwiftLeeds 2024 is here, and in this post, i'll be sharing my thoughts on the first day of the conference.

Agenda:

From Side Project to Going Indie - Antoine van der Lee.
Multi-Platform Libraries with Swift for WebAssembly - Max Desiatov.
Building an Accessibility Culture, One Step at a Time - Bas Broek.
Speeding up protocol conformances in Swift - Noah Martin.
Hidden engineering challenges of A/B Testing - Anastasia Petrova.
Swift Concurrency is new and different and hard and you can do it - Matt Massicotte.
Crafting better App Icons - Flora Damiano.
How LEGO can inspire us to build better UI Libraries - Joseph El Mallah.

From Side Project to Going Indie - Antoine van der Lee

Key Takeaways:

Prepare
- Mindset
  - Never quit because it becomes challenging
  - Learn by shipping
- Goals & Planning
  - Goals visualize progress; progress leads to motivation
  - A tool to not do too much: you’ve already reached your goal
  - Write all tasks out, it is easier to track.
  - Create issues for everything, even when the task is already completed.
  - The first step is the hardest, break it into smaller steps
Get into action
- Development Practices
  - Creating and Utilizing a Personal SDK for Reusability (Benefit of Isolation and Focus)
  - Tests will save you time
- Marketing & Audience Growth
  - REPURPOSE YOUR KNOWLEDGE GAINS
  - Learn something, Blog about it, Repurpose on social media, Apply to your product
  - Only ~2% of your followers will see your post
  - Use automation to repost evergreen content
  - Ensure to at least have 3 posts per day
  - Repost for different timezones
  - Create a Personality (Make your personal account likable)
- Financial Strategies
  - Make sure to know how to measure important metrics
    - Monthly Recurring Revenue (MRR)
    - Annual Recurring Revenue (ARR)
    - Gross vs. Net
  - Define Your Offering
    - Build a recurring income with auto-renewing subscription (if it makes sense)
    - Be careful with lifetime
      - Your product grows and evolves; the lifetime price remains the same
    - Offer a free experience to add opportunities to upsell
Reflect
- Sustaining Your Indie Career
  - Time management and prioritization becomes even more important
  - Everything impacts your income, so it’s easy to overwork
  - Planning your days is crucial, you might need to force yourself to take time off
  - Always Remember Your Core Values
    - You do what you love
    - You’ve got flexible working hours
    - More time with your family

More information on going-indie.com.

Multi-Platform Libraries with Swift for WebAssembly - Max Desiatov

Key Takeaways:

WebAssembly Text Format (.wat extension) used for debugging
WebAssembly binary modules (.wasm extension) used for distribution
With WASI syscalls you can interact with the host environment (e.g. filesystem, network, this requires explicit permissions)
Wasm is a virtual instruction set designed for security and efficiency
WASI defines API and ABI for accessing the host system
Apps can embed a Wasm runtime for plugins-like functionality

Resources:
Demo code available on GitHub: https://github.com/apple/swift-for-wasm-examples
WasmKit source repository: https://github.com/swiftwasm/wasmkit
Join the conversation at "Swift for WebAssembly" Forums section: https://forums.swift.org/c/related-projects/swift-for-webassembly/71

Building an Accessibility Culture, One Step at a Time - Bas Broek

Key Takeaways:

Accessibility is an us problem.
What's (not) accessibility?
- ☑️ Localisation
- ☑️ Dynamic Type
- ☑️ Autocomplete
- ☑️ Dark mode
- ☑️ Sensory feedback

Speeding up protocol conformances in Swift - Noah Martin

Key Takeaways:

Don't use protocola (and conformances) if not needed.

For more info see this topic on the Swift Forums, or read more about it on the blog of Emerge Tools.

Hidden engineering challenges of A/B Testing - Anastasia Petrova

Key Takeaways:

A/B testing makes customer support harder and FAQ's unreliable
Removing A/B testing can be tricky if it is based on (a lot of) if #available(..) modifiers.
a good way to update/enroll isn't using willEnterForgeground.
Most experiments fail.
1 of 8 experiments succeed.
A/B testing is an expensive way of saying "I disagree with your idea".

Swift Concurrency is new and different and hard and you can do it - Matt Massicotte

Matt shared his thoughts on Swift Concurrency and how developers can leverage it in their projects.

Key Takeaways:

Switch over to Swift6 concuccency mode if you start a new project.

Do you want to know more about concurrency visit Matt's website or browse Concurrency tags on this blog.

Crafting better App Icons - Flora Damiano

Key Takeaways:

Make it Versatile
- Ensure the effectiveness of your icon design across various platforms and sizes.
  The icon will be displayed in multiple locations throughout the platform, emphasizing the importance of maintaining both legibility and uniqueness.
- Complex icons that attempt to incorporate too much information often suffer from poor scalability.
  Prioritize the simplicity of lines and shapes during the conceptual stage and favor ideas that can be conveyed through a singular object.
- Avoid the pitfall of attempting to represent diverse functionalities within a single icon, as this can lead to confusion.
  Using high-contrasted colors and vibrant shades of the same color is a common approach to ensure recognizability even in smaller usages of your design.
Make it Consistent
- Establishing a strong and consistent design language is a potent means of leaving a lasting impression on users.
  Effective app icon design serves as an extension of the application's essence. Ensuring alignment between the app's purpose and visual representation enhances the overall user experience, fostering memorability.
- A straightforward approach to achieving this synergy is incorporating dominant colors from the app or branding into the icon.
  providing a foundational and consistent element. Additionally, consider transforming existing graphic elements into iconography, further reinforcing the cohesive design language. By maintaining consistency in these visual aspects, you enhance the overall effectiveness and impact of your app icon.
- When you have a multiplatform app or a bundle with multiple apps, consistency will play a big role in how effective the App Icon design is.
  Keeping the same visual language also increases recognizability through platforms and markets. This is crucial also when changes to your icons are applied over time.
Make it Original
Make it Memorable

There are some key attributes that you have to make sure that your file matches:

Always provide a squared image as an App Icon, don’t apply a corner radius. The system will automatically apply a mask for the platform you are designing for.
Work in sRBG or P3 color space. Xcode runs in P3 color space and sRBG almost matches this spectrum, but working in different spaces will result in an inconsistency in colors applied. Since you are working on display only, remember to work on the resolution of 72 dpis.
Don’t apply transparency in your background layer. Your app icon will be displayed in different screen scenarios, and having transparency on the background will result in color changes and inconsistency, plus color readability and Xcode errors.
PNG file format works best with Xcode and raster quality.

To ensure consistency with the system, you will need to provide 3 different variants of your App Icon: Light Mode, Dark Mode, and Tinted

Resources:

How LEGO can inspire us to build better UI Libraries - Joseph El Mallah

Key Takeaways:

Create Composable Views instead of a view for each element you want to show.
Composable makes it easier to:
- Change the requirements
- Localize
- Layout direction
- Accessibility
- Test
https://developer.apple.com/videos/play/wwdc2024/10146/

Wrapping Up

That's a wrap for day 1 of SwiftLeeds 2024!

SwiftLeeds 2024 (day 2)

Fri, 17 Oct 2025 22:37:04 +0200

It's that time of year again!
SwiftLeeds 2024 is here, and in this post, i'll be sharing my thoughts on the second (and last) day of the conference.

Agenda:

The Roast of your App's Design - Hidde van der Ploeg.
From Quantum to Code: A Teacher's Journey into Mobile Development - Chloe Jenner.
Cut costs, not corners - Master modularization with SPM - Antonio Markotić.
The Art of Functional State Management - Araks Avoyan.
Fixing Image Performance for The Worst iPhone - Aviel Gross.
Scalable Continuous Integration for iOS - Alberto De Bortoli.
What Not to Do: Rocky Road to Banner View - Maria Kharybina.
Refactoring Fear - Josh Holtz.

The Roast of your App's Design - Hidde van der Ploeg

Hidde shared his insights on how to improve your app's design by roasting it.

Key Takeaways:

Make sure your app is accessible to everyone.
Make sure your app is usable by everyone.
Don't make your app too complex, it should be easy to navigate in.
If you don’t know typography, don’t do custom fonts.
Make use of the system colors and their options (.secondary, .tertiary, .quaternary, .quinary).
Use ContentUnavailableView when there is no content to show.
When apps have great navigation, it's often unnoticed because people can focus on the content and experience.
Look at the Human Interface Guidelines for inspiration and guidance.
Explore navigation design in iOS and HIG: Navigation.

From Quantum to Code: A Teacher's Journey into Mobile Development - Chloe Jenner

Chloe discussed her transition from quantum physics to mobile development in a poetic and inspiring talk.
This talk was a great reminder that it's never too late to change careers and pursue your passion.
View the talk on YouTube.

Cut costs, not corners - Master modularization with SPM - Antonio Markotić

Antonio talked about the benefits of modularization with Swift Package Manager.

Key Takeaways:

Modularization can help you reduce build times and dependencies.
Modularization can help you cut costs on CI/CD.

Modularized iOS app

Pros	Cons
Faster build times	Initial setup can be time-consuming
Loosley coupled code	Module inconsistency
Adding new feature	Possible circular references
Reusability
Testobility
Parallel development

The Art of Functional State Management - Araks Avoyan

Araks shared her expertise on functional state management in iOS apps.

Key features of Functional programming

Immutability.
we don't directly change our data. We create a new copy of the data with the changes we want to make. This makes our code more predictable and easier to reason about.
Combine.
Combine is Apple's framework for reactive programming. It allows us to work with asynchronous data streams in a declarative way.
Cons of combine: unpredictable future from apple (async, await, Swift 6).

Fixing Image Performance for The Worst iPhone - Aviel Gross

Aviel discussed strategies for improving image performance on older iPhone models.

Key Takeaways:

It can be tricky to load a large number of images in a performant way on older devices.
Sometimes it is better to use a framework like Nuke or Kingfisher instead of relying on SwiftUI's built-in image loading.
It can be smart to (pre)load blurred images first and then replace them with the full resolution image.

Scalable Continuous Integration for iOS - Alberto De Bortoli

Alberto shared his insights on building scalable continuous integration pipelines for iOS projects.
Key Takeaways:

There is no one-size-fits-all solution for continuous integration.
You can also host your own CI server on a Mac (mini).
Using Terraform you can easily deploy more CI's when needed on AWS.

What Not to Do: Rocky Road to Banner View - Maria Kharybina

Maria discussed the challenges she faced while implementing a banner view in an iOS app.

Key Takeaways:

What NOT to do:
- ignore advantages of chosen framework.
- start looking for solution before defining a problem
- only solve the current problem
- change the requirements for the component as you go
- forget about testing
What to do:
- think before coding
- spend more time on assessment and planning
- share your wins and fails with the community

Refactoring Fear - Josh Holtz

Josh shared his experiences with his stutter and how it has affected his life and career.
This talk was a great reminder that everyone has their own struggles and that it's important to be kind to yourself and others.

Wrapping Up

That's a wrap for day 2 of SwiftLeeds 2024!

Understanding Package.swift

Fri, 17 Oct 2025 22:37:05 +0200

If you're diving into Swift development, you've likely encountered Package.swift.
This file is the cornerstone of Swift Package Manager (SPM), Apple's tool for managing Swift code dependencies.
Let's explore what makes Package.swift so essential and how you can leverage it in your projects.

What is Package.swift?

Package.swift is a manifest file that defines the structure and dependencies of a Swift package.
It uses Swift syntax to describe the package's configuration, making it both powerful and easy to read.
This file is crucial for managing dependencies, building libraries, and sharing code across different projects.

Key Components of Package.swift/Table of Contents

Package Description: The top-level structure that includes metadata about the package, such as its name, platforms, and Swift tools version.
Platforms (Optional): Defines the platforms which your package supports.
Products: Defines the executables and libraries produced by the package. These can be used by other packages or applications.
Dependencies: Lists external packages that your package depends on. SPM will fetch and manage these dependencies for you.
Targets: The basic building blocks of a package. Each target can define a module or a test suite.
Resources (Optional): Bundles resources with the package, such as images or sound files.
Advanced Topics: [Not required] Version-specific Package.swift files, publishing your Swift package, and more.

Why Use Swift Package Manager?

Simplified Dependency Management: SPM handles the downloading and linking of dependencies, ensuring compatibility and reducing conflicts.
Integration with Xcode: Xcode has built-in support for SPM, making it easy to add and manage packages directly within your project.
Cross-Platform Support: SPM supports macOS, iOS, watchOS, and tvOS, allowing you to share code across different platforms.

Creating your first Package (Using the terminal)

Creating a New Package:
```
mkdir MyPackage
cd MyPackage
swift package init
```
This command creates a new package with a default Package.swift file.

Swift Generates necessary files:

Creating library package: MyPackage
Creating Package.swift
Creating .gitignore
Creating Sources/
Creating Sources/MyPackage/MyPackage.swift
Creating Tests/
Creating Tests/MyPackage/
Creating Tests/MyPackageTests/MyPackageTests.swift

A look into Package.swift:

// swift-tools-version:5.6
import PackageDescription

let package = Package(
    name: "MyPackage",
    products: [
        .library(
            name: "MyPackage",
            targets: ["MyPackage"]),
    ],
    dependencies: [
        // Dependencies for package (if any)
    ],
    targets: [
        .target(
            name: "MyPackage",
            dependencies: []),
        .testTarget(
            name: "MyPackageTests",
            dependencies: ["MyPackage"]),
    ]
)

Building and Testing:
Use the following commands to build and test your package:
```
swift build
swift test
```

Naming Conventions

// swift-tools-version:5.6
import PackageDescription

let package = Package(
    name: "MyPackage",
    products: [
        .library(
            name: "MyPackage", // This is the name which will be used in the import statement
            targets: ["MyPackage"]),
    ]
)

What does Apple do: Apple hosts their packages, in most cases, such that the last url component and the package name match. These identifiers are formed using kebab-case, and start with the swift- prefix. See the results of this query for all their packages that fit this format. Looking at swift-async-algorithms, one sees that the last path component matches the the package name, while the product name is different: SwiftAlgorithms

Platforms

You can also define on which platforms your package works, this makes it easier for the users of your package to see if your package is compatible with the platform they are developing on.
The supported platforms types (2024) are:

    platforms: [
        .macOS(.v10_15),
        .iOS(.v13)
    ]

Products

Products are the executables and libraries produced by the package.
You can define the products in the Package.swift file as follows:

    products: [
        .library(
            name: "MyPackage",
            targets: ["MyPackage"]
        )
    ]

Dependencies

Sometimes you want to use a package from someone else to help you with your project (e.g. SimpleNetworking) to make our network calls easier.

You can use a specific version of a package by specifying the version in the Package.swift file:

    dependencies: [
        .package(
            url: "https://github.com/0xWDG/SimpleNetworking.git",
            from: "1.0.0"
        )
    ]

You can use a specific branch of a package by specifying the branch in the Package.swift file:

    dependencies: [
        .package(
            url: "https://github.com/0xWDG/SimpleNetworking.git", 
            branch: "main"
        )
    ]

You can use a specific commit of a package by specifying the commit in the Package.swift file:

    dependencies: [
        .package(
            url: "https://github.com/0xWDG/SimpleNetworking.git",
            .revision("68726dd")
        )
    ]

Targets

Targets are the basic building blocks of a package, defining a module or a test suite.
Targets can depend on other targets in this package and products from dependencies.

    targets: [
        // Targets are the basic building blocks of a package, defining a module or a test suite.
        // Targets can depend on other targets in this package and products from dependencies.
        .target(
            name: "MyPackage"
        ),
        .testTarget(
            name: "MyPackageTests",
            dependencies: ["MyPackage"]
        )
    ]

Resources

Bundling resources with a Swift Package

Swift Packages can contain resources that are bundled with the package.
Resources can include images, sounds, or any other files that your package needs to function correctly.

Adding resources to a Swift Package

You can add resources by updating your target definition:

Process all resources found in the Resources directory:

.target(
    name: "MyPackage",
    resources: [
        .process("Resources/")
    ]
)

Only add a specific file:

.target(
    name: "MyPackage",
    resources: [
        .process("Resources/image.png")
    ]
)

Copy all resources found in the Resources directory:

.target(
    name: "MyPackage",
    resources: [
        .copy("Resources/")
    ]
)

Copy a specific file:

.target(
    name: "MyPackage",
    resources: [
        .copy("Resources/image.png")
    ]
)

As demonstrated in the code example, there are several ways of adding resources. For most use cases, using the process rule will be sufficient. It’s essential to realize Xcode might optimize your files.
For example, it might optimize images for a specific platform. If using the original files is necessary, consider using the copy rule.

Excluding specific resources
If needed, you can exclude specific resources using the exclude definition:

.target(
    name: "MyPackage",
    exclude: ["Readme.md"],
    resources: [
        .process("Resources/")
    ]
)

Accessing resources in code using the module bundle

You can access any resources using the Bundle.module accessor.
Note that the module property will only become available if there are any resources rules defined in the package target.
It’s important to note that the following code won’t work for SwiftUI in packages:

var body: some View {
    Image("sample_image", bundle: .module)
}

Instead, you’ll have to rely on UIKit/Appkit and load the image as follows:

import SwiftUI

struct ContentView: View {

    var image: UIImage {
        return UIImage(named: "sample_image", in: .module, compatibleWith: nil)!
    }

    var body: some View {
        Image(uiImage: image)
    }
}

This is unfortunate, you can also use this extension to load images in SwiftUI:

import SwiftUI

extension Image {
    init(packageResource name: String, ofType type: String) {
        #if canImport(UIKit)
        guard let path = Bundle.module.path(forResource: name, ofType: type),
              let image = UIImage(contentsOfFile: path) else {
            self.init(name)
            return
        }
        self.init(uiImage: image)
        #elseif canImport(AppKit)
        guard let path = Bundle.module.path(forResource: name, ofType: type),
              let image = NSImage(contentsOfFile: path) else {
            self.init(name)
            return
        }
        self.init(nsImage: image)
        #else
        self.init(name)
        #endif
    }
}

Source: Eneko Alonso.

You can then use the extension as follows:

var body: some View {
    Image(packageResource: "sample_image", ofType: "png")
}

For any other resources, you can rely on accessing resources directly using the Bundle:

Bundle.module.url(forResource: "sample_text_resource", withExtension: "txt")

Advanced Topics

Version-specific Package.swift Files

Benefits of Version-specific Package.swift Files

Backward Compatibility: Maintain support for older Swift versions while adopting new features in newer versions.
Granular Control: Tailor your package configuration to specific Swift versions, ensuring optimal performance and compatibility.
Future-proofing: Prepare your packages for upcoming Swift releases without disrupting existing users.

Create a version-specific `Package.swift`

To create a version-specific Package.swift file, you simply rename the file to include the Swift version it targets.
The format is Package@swift-<MAJOR>.<MINOR>.<PATCH>.swift. Here are some examples:

Package@swift-5.7.swift: Applies to all patch versions of Swift 5.7.
Package@swift-5.7.1.swift: Applies exclusively to Swift 5.7.1.
Package@swift-5.swift: Applies to all minor and patch versions of Swift 5.

Example Structure

Let's say you want to support Swift 5.6 and Swift 5.7 with different configurations. You would create two files:

Package@swift-5.6.swift

// swift-tools-version:5.6
import PackageDescription

let package = Package(
    name: "MyPackage",
    platforms: [
        .macOS(.v10_15),
        .iOS(.v13)
    ],
    products: [
        .library(
            name: "MyPackage",
            targets: ["MyPackage"]),
    ],
    dependencies: [
        // Dependencies for Swift 5.6
    ],
    targets: [
        .target(
            name: "MyPackage",
            dependencies: []),
        .testTarget(
            name: "MyPackageTests",
            dependencies: ["MyPackage"]),
    ]
)

Package@swift-5.7.swift

// swift-tools-version:5.7
import PackageDescription

let package = Package(
    name: "MyPackage",
    platforms: [
        .macOS(.v11),
        .iOS(.v14)
    ],
    products: [
        .library(
            name: "MyPackage",
            targets: ["MyPackage"]),
    ],
    dependencies: [
        // Dependencies for Swift 5.7
    ],
    targets: [
        .target(
            name: "MyPackage",
            dependencies: []),
        .testTarget(
            name: "MyPackageTests",
            dependencies: ["MyPackage"]),
    ]
)

Publishing your Swift Package

To publish your Swift package you can simply create a new tag on your Git repository.
As you’ve seen in the dependencies section, you can add references to dependencies using Git URLs.
To enable developers to explore packages more easily, Dave Verwer and Sven A. Schmidt have founded the Swift Package Index. You can start adding your package(s).

Wrap-up

Swift Packages are super cool and can help you manage your dependencies in a more structured way.
Setting up a Swift Package for the first time can be a bit overwhelming, but once you get the hang of it, it's a breeze.
i hope this article helped you understand the basics of Package.swift and how you can leverage it in your projects.
if you have any questions or feedback, feel free to reach out to me on Mastodon, Twitter, or comment down below.

References

Translation framework in Swift

Fri, 17 Oct 2025 22:37:05 +0200

Exploring the Translation Framework in Swift

With the release of iOS 17.4, Apple introduced the Translation framework, a powerful tool that allows developers to integrate text translation capabilities directly into their Swift applications. This framework leverages CoreML models to perform on-device translations, ensuring fast and secure translations without the need for an internet connection.

Key Features

On-Device Translation: Unlike third-party services that require an internet connection, the Translation framework performs translations on-device, enhancing speed and security.
Built-in UI: The framework offers a built-in user interface for translations, making it easy to integrate without extensive customization.
Customizable Experience: For developers who need more control, the framework provides APIs to customize the translation process.

Getting Started

To demonstrate how to use the Translation framework, let's build a simple SwiftUI app that translates text input by the user.

Using the Built-in User Interface

We can achive this by using the .translationPresentation(isPresented:text:) view modifier provided by the translation framework.
This modifier presents a built-in translation UI that allows users to input text and view the translated output. it also provides a callback to handle the translated text if needed.

There are two ways to use the built-in UI:

Only show the translation

.translationPresentation(isPresented: $showTranslation, text: text)

Handle the translated text

.translationPresentation(isPresented: $showTranslation, text: text) { translatedText in
    text = translatedText
}

Example code

import SwiftUI
import Translation

struct ContentView: View {
    /// Text to be translated
    @State
    var text = "Swift programming is fun! You should try it yourself, it even has a translation framework now!"

    /// Should we show the translation UI
    @State
    var showTranslation = false

    var body: some View {
        NavigationStack {
            VStack {
                // Display the text to be translated
                Text(text)
                    .font(.title3)
                    .multilineTextAlignment(.center)
            }

            // Show translation UI
            .translationPresentation(
                isPresented: $showTranslation, 
                text: text
            ) { translatedText in
                // Optional: Handle the translated text
                text = translatedText
            }

            // Add a button to show the translation UI
            .toolbar {
                Button {
                    // Toggle the translation UI
                    showTranslation.toggle()
                } label: {
                    Image(systemName: "translate")
                }
            }
        }
    }
}

Using your own User Interface

The Translation framework also provides APIs to create a custom translation experience. By using the view modifier, you can initiate translation tasks and handle the translated text within your app's UI.

Inline translation using the `.translationTask(_:action:)` view modifier (user initiated translation)

The .translationTask(_:action:) view modifier allows you to create a custom translation experience where users can initiate translation tasks by interacting with your app's UI.

struct ContentView: View {
    /// Source text for translation
    @State
    private var sourceText = "Swift programming is fun! You should try it yourself, it even has a translation framework now!"

    /// Source text for translation
    var sourceLanguage: Locale.Language?

    /// Target language for translation
    var targetLanguage: Locale.Language?

    /// Translated text
    @State
    private var targetText: String?

    /// Translation session configuration
    @State
    private var configuration: TranslationSession.Configuration?

    var body: some View {
        VStack {
            Text(targetText ?? sourceText)
            Button("Translate") {
                guard configuration == nil else {
                    configuration?.invalidate()
                    return
                }

                // Create a new translation session configuration
                configuration = TranslationSession.Configuration(
                    source: sourceLanguage,
                    target: targetLanguage
                )
            }
            // Start translation task
            .translationTask(configuration) { session in
                Task { @MainActor in
                    do {
                        // Perform translation
                        let response = try await session.translate(sourceText)

                        // Update target text
                        targetText = response.targetText
                    } catch {
                        // code to handle error
                    }
                }
            }
        }
    }
}

Inline translation using the `.translationTask(source:target:action:)` view modifier (automatic translation)

.translationTask(source:target:action:) view modifier allows you to create a custom translation experience where users do not need to initiate translation tasks.

import SwiftUI
import Translation

struct ContentView: View {
    /// Source text for translation
    @State
    private var sourceText = "Swift programming is fun! You should try it yourself, it even has a translation framework now!"

    /// Source language for translation
    var sourceLanguage: Locale.Language?

    /// Target language for translation
    var targetLanguage: Locale.Language?

    /// Translated text
    @State
    private var targetText: String?

    var body: some View {
        Text(targetText ?? sourceText)
            // Start translation task
            .translationTask(
                source: sourceLanguage,
                target: targetLanguage
            ) { session in
                Task { @MainActor in
                    do {
                        // Perform translation
                        let response = try await session.translate(sourceText)

                        // Update target text
                        targetText = response.targetText
                    } catch {
                        // code to handle error
                    }
                }
            }
    }
}

Conclusion

The Translation framework in Swift opens up new possibilities for creating multilingual applications with ease. By leveraging on-device translations, developers can provide a seamless and secure user experience. Whether you use the built-in UI or customize the translation process, this framework is a valuable addition to your development toolkit.

Building an Asynchronous Button in SwiftUI

Fri, 17 Oct 2025 22:37:06 +0200

Sometimes, we need to perform asynchronous tasks when a button is tapped in a SwiftUI application. For example, fetching data from a network request, saving data to a database, or performing any long-running operation. In this tutorial, we'll explore how to create an asynchronous button in SwiftUI that performs an asynchronous task when tapped.

Why Use Asynchronous Buttons?

Asynchronous tasks are essential for operations that take time to complete, such as network requests, file I/O, or any long-running computations. By using asynchronous buttons, we can keep the UI responsive and provide feedback to users while the task is being performed.

Creating an Async Button

In this code snippet, we'll create an AsyncButton view that performs an asynchronous task when tapped. The button will display a loading indicator while the task is in progress and disable user interaction to prevent multiple taps.
This is a simple example of how to create an asynchronous button in SwiftUI:

import SwiftUI

/// A button that performs an asynchronous task when tapped.
struct AsyncButton<Label: View>: View {
    /// The asynchronous action to perform when the button is tapped.
    var action: () async -> Void

    /// The label of the button.
    @ViewBuilder
    var label: () -> Label

    /// Whether the task is currently being performed.
    @State
    private var isPerformingTask = false

    var body: some View {
        Button(action: {
            // When the button is tapped, we are performing a task
            isPerformingTask = true

            // Perform the task asynchronously
            Task {
                // Perform the asynchronous task
                await action()

                // After the task is completed, we are no longer performing a task
                isPerformingTask = false
            }
        }) {
            HStack {
                // Show a loading indicator while the task is in progress
                if isPerformingTask {
                    ProgressView()
                        .controlSize(.mini)
                }

                // Show the label of the button
                label()
            }
        }
        // Disable the button while the task is in progress
        .disabled(isPerformingTask)
    }
}

/// Example usage:
struct ContentView: View {
    var body: some View {
        AsyncButton(action: fetchData) {
            Text("Fetch Data")
        }
    }

    func fetchData() async { // <2>
        // Simulate a network request
        try? await Task.sleep(nanoseconds: 2 * 1_000_000_000)
        print("Data fetched")
    }
}

Improving the Async Button

The AsyncButton view can be further customized to handle errors and provide feedback to the user. For example, we can display an error message if the task fails or show a success message when the task completes successfully. We can also add animations to enhance the user experience.

Here's an improved version of the AsyncButton view that handles errors and provides feedback to the user:

import SwiftUI

/// A button that performs an asynchronous task when tapped.
struct AsyncButton<Label: View>: View {
    /// The asynchronous action to perform when the button is tapped.
    var action: () async throws -> Void

    /// The label of the button.
    @ViewBuilder
    var label: () -> Label

    /// Whether the task is currently being performed.
    @State
    private var isPerformingTask = false

    /// The error message to display if the task fails.
    @State
    private var errorMessage: String?

    /// Whether to show the alert.
    @State
    private var showAlert = false

    var body: some View {
        Button(action: {
            // When the button is tapped, we are performing a task
            isPerformingTask = true

            // Perform the task asynchronously
            Task {
                do {
                    // Perform the asynchronous task
                    try await action()

                    // If the task completes successfully, clear the error message (if any)
                    errorMessage = nil
                } catch {
                    // If the task fails, display the error message
                    errorMessage = error.localizedDescription
                }

                // After the task is completed, we are no longer performing a task
                isPerformingTask = false

                // Show the alert if there is an error
                showAlert = errorMessage != nil
            }
        }) {
            HStack {
                // Show a loading indicator while the task is in progress
                if isPerformingTask {
                    // Use a mini progress view
                    ProgressView()
                        .controlSize(.mini)
                }

                // Show the button label
                label()
            }
        }
        // Disable the button while the task is in progress
        .disabled(isPerformingTask)
        // Show an alert with the error message if the task fails
        .alert(isPresented: $showAlert) {
            // Display an alert with the error message
            Alert(
                title: Text("Error"), 
                message: Text(errorMessage ?? ""), 
                dismissButton: .default(Text("OK"))
            )
        }
    }
}

Conclusion

Creating an asynchronous button in SwiftUI is straightforward and enhances the user experience by keeping the UI responsive. By leveraging Swift's concurrency model, we can perform tasks asynchronously and handle errors gracefully. This approach ensures that our applications remain smooth and user-friendly, even when performing complex operations.

Resources

Exploring the .inspector Modifier in SwiftUI

Fri, 17 Oct 2025 22:37:06 +0200

SwiftUI continues to evolve, bringing new and powerful tools to developers.
One such tool is the .inspector modifier, introduced to enhance the user interface by providing context-dependent presentations.
This article will delve into what the .inspector modifier is, how it works, and how you can use it to create more dynamic and interactive SwiftUI applications.

What is the `.inspector` Modifier?

The .inspector modifier in SwiftUI allows you to present additional information or controls related to a view in a context-dependent manner.
This means that the inspector can appear differently based on the environment it is used in.
For instance, in a compact environment, it might appear as a sheet, while in a regular environment, it could display as a trailing column in your view hierarchy.

How to Use the `.inspector` Modifier

Using the .inspector modifier is straightforward and similar to other presentation modifiers in SwiftUI, such as .sheet. Here’s a basic example to illustrate its usage:

struct ContentView: View {
    @State
    private var showInspector = false

    var body: some View {
        VStack {
            Button("Show Inspector") {
                showInspector.toggle()
            }
        }
        .inspector(isPresented: $showInspector) {
            Text("Inspector Content")
                .padding()
        }
    }
}

In this example, a button toggles the visibility of the inspector. When the button is pressed, the inspector slides in from the trailing edge of the UI, displaying the specified content.

Customizing the Inspector

The .inspector modifier is highly customizable.
You can add any SwiftUI view inside the inspector, making it a versatile tool for various use cases.
Here’s an example with more complex content:

struct ContentView: View {
    @State
    private var showInspector = false

    var body: some View {
        VStack {
            Button("Show Inspector") {
                showInspector.toggle()
            }
        }
        .inspector(isPresented: $showInspector) {
            VStack {
                Text("Inspector Title")
                    .font(.headline)
                Divider()
                Text("Detailed information goes here.")
                Button("Close") {
                    showInspector = false
                }
            }
            .padding()
        }
    }
}

This example demonstrates how you can include multiple views within the inspector, such as text, dividers, and buttons, to create a more detailed and interactive inspector.

Practical Applications

The .inspector modifier is particularly useful in applications where you need to provide additional context or controls without navigating away from the current view.
For example, in a photo editing app, you could use an inspector to show editing tools and options.
In a note-taking app, it could display metadata or additional settings related to the selected note.

Conclusion

The .inspector modifier in SwiftUI is a powerful addition that allows developers to create more interactive and context-aware applications.
By understanding and utilizing this modifier, you can enhance the user experience and provide more detailed and accessible information within your apps.

Understanding reducers in Swift

Fri, 17 Oct 2025 22:37:07 +0200

Reducers are a powerful concept in Swift, allowing developers to transform sequences of values into a single result.
This technique is particularly useful when you need to perform operations like summing numbers, concatenating strings, or combining complex data structures.
In this blog post, we'll explore what reducers are, how they work, and some practical examples of their use in Swift.

What is a Reducer?

A reducer is a function that takes a sequence of values and combines them into a single value.
This is done by iteratively applying a closure that specifies how to combine each element of the sequence with an accumulating value.
The most common use of reducers in Swift is through the reduce function, which is available on all types that conform to the Sequence protocol.

The `reduce` Function

The reduce function in Swift is defined as follows:

func reduce<Result>(
    _ initialResult: Result,
    _ nextPartialResult: (Result, Self.Element) throws -> Result
) rethrows -> Result

initialResult: The initial value to start the accumulation.
nextPartialResult: A closure that combines the accumulating value with each element of the sequence.

Here's a simple example of using reduce to sum an array of numbers:

let numbers = [1, 2, 3, 4, 5]
let sum = numbers.reduce(0) { $0 + $1 }
print(sum) // Outputs: 15

In this example, 0 is the initial value, and the closure { $0 + $1 } specifies that each element should be added to the accumulating value².

Practical Examples

Summing Nested Values:
Suppose you have an array of mailboxes, each containing a number of unread messages. You can use reduce to calculate the total number of unread messages:

struct Mailbox {
    let unreadMessages: Int
}

let mailboxes = [Mailbox(unreadMessages: 5), Mailbox(unreadMessages: 10), Mailbox(unreadMessages: 15)]
let totalUnreadCount = mailboxes.reduce(0) { $0 + $1.unreadMessages }
print(totalUnreadCount) // Outputs: 30

Concatenating Strings:
You can also use reduce to concatenate an array of strings into a single string:

let words = ["Swift", "is", "awesome"]
let sentence = words.reduce("") { $0 + " " + $1 }
print(sentence) // Outputs: " Swift is awesome"

Combining Complex Data Structures:
For more complex data structures, reduce can be used to merge dictionaries:

let dicts = [
    ["key1": "value1"],
    ["key2": "value2"],
    ["key3": "value3"]
]
let combinedDict = dicts.reduce([:]) { $0.merging($1) { (current, _) in current } }
print(combinedDict) // Outputs: ["key1": "value1", "key2": "value2", "key3": "value3"]

Key Differencesbetween `reduce` and `map`

Purpose:
map: Transforms each element of a sequence into a new element.
reduce: Combines all elements of a sequence into a single value.
Return Type:
map: Returns a new array with the transformed elements.
reduce: Returns a single value.
Usage:
map: Useful when you need to apply the same operation to each element and get a new array.
reduce: Useful when you need to summarize the elements into a single result.

Conclusion

Reducers are a versatile and powerful tool in Swift, enabling you to transform sequences into single values efficiently. Whether you're summing numbers, concatenating strings, or merging dictionaries, the reduce function provides a clean and expressive way to achieve your goals. By mastering reducers, you can write more concise and readable code, making your Swift programming even more effective³.

Creating a dynamic user interface for extensions in Aurora Editor

Fri, 17 Oct 2025 22:37:07 +0200

As some of you may know, I have been working on a IDE called Aurora Editor.
It is a editor that is built using Swift and SwiftUI and is designed to be extensible and native.
In this post, I will go trough the process I went to create a dynamic user interface for extensions in Aurora Editor.

This is an (my first) in-depth post, let's get started!
I hope it will be helpful for you, and i'd love to get feedback on this post.

The problem

It all started with a problem, how can a extension developer create a user interface for their extensions in Aurora Editor?
I first started with a simple solution, using a SwiftUI view, from a Swift extension.

import SwiftUI

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

// This is the view that will be displayed trough a extension window
ExtensionsManager.shared.sendEvent(
    event: "openWindow",
    parameters: [
        "view": ExtensionView()
    ]
)

This works great, but it does not allow views from a JavaScript extension to be displayed.
I needed a way to create a dynamic user interface that could be used by both native (Swift) and JavaScript extensions.

I first started with a WebView that would display the user interface, from a HTML string in a JavaScript extension, this is a working example from Aurora Editor.

// This is the view that will be displayed trough a extension window
AuroraEditor.respond("openWindow", {
  view: "<html><body><h1>Hello, World!</h1></body></html>",
});

This works fine, but it is not really native and it might not be the best solution because we want a (near) native experience.

What if I can use ... what can be used to create a dynamic user interface?

SwiftUI: Unfortunately, SwiftUI cannot be shared between JavaScript and Swift
JavaScript: No this would mean we need to create a custom and difficult to maintain bridge between JavaScript and SwiftUI
JSON: This is a good idea, it is easy to parse and can? be used to create a dynamic user interface, let's try this!

The birth of `DynamicUI`

So JSON it is! I created a new struct called DynamicUI that can be used to create a dynamic user interface.

We need to create a way to convert JSON to a SwiftUI view.

We can probably achive this by following these steps:

Read the JSON (Data or String).
Parse the JSON.
Create a SwiftUI view from the parsed JSON.
Return the SwiftUI view.
Done!

Sounds easy right? Let's try it!

We can't start with the list of steps above, we need to do them in a slightly different order.

Create a struct for the Dynamic UI Builder (Element definition in the JSON).
Create a view for the Dynamic UI Element (SwiftUI view for the element).
Create a DynamicUI? (Display the UI).
Create a DynamicUI. (Convert JSON to SwiftUI view).
Use the DynamicUI.
Use the DynamicUI in Aurora Editor.

Step 1: Creating a struct for the Dynamic UI Element

We need to create a struct that can be used to create a dynamic user interface element.

import SwiftUI

public struct DynamicUIComponent: Codable, Hashable {
    public let type: String
    public let title: String?
    public let text: String?
    public let defaultValue: AnyCodable?
}

Hey, what is AnyCodable?
AnyCodeable is a type-erased codable value, it can be used to store any codable value (e.g. String, Int, Bool, ...).

We have a struct that can be used to create a dynamic user interface element. Full source code

Step 2: Create a Dynamic UI Element

We now need to create a view that can be used to create a dynamic user interface element.
We create a new struct so we can pass all parameters required, and can append modifiers to the view.

In this example, we will create a DynamicText element (to display text).
I left out the .dynamicUIModifiers() (modifier parser) code, since this will make the sample code to complex.

import SwiftUI

public struct DynamicText: View {
    /// The component to display
    private let component: DynamicUIComponent

    /// Initialize the DynamicText
    init(_ component: DynamicUIComponent) {
        self.component = component
    }

    /// Generated body for SwiftUI
    public var body: some View {
        Text(.init(component.title ?? ""))
            .dynamicUIModifiers(component.modifiers)
    }
}

Step 3: Create a DynamicUI?

Can we already create a dynamic user interface element using the DynamicUIComponent and DynamicText or do we need to create more? Unfortunately, we need to create more.
We need to create a way to convert to parse the JSON and type-erease it.
We create a new struct called InternalDynamicUI that can be used to create a dynamic user interface.

struct InternalDynamicUI: View {
    /// JSON Data
    public var json: Data?

    @State
    /// This state is used to store the layout
    private var layout: [DynamicUIComponent]?

    @State
    /// This state is used to store the error message
    private var error: String?

    /// Initialize the InternalDynamicUI
    var body: some View {
        VStack {
            if let layout = layout {
                buildView(for: layout)
            } else if let error = error {
                Text(error)
            } else {
                ProgressView()
                    .frame(width: 150, height: 150)
                    .padding()

                Text("Generating interface...")
            }
        }
        .onAppear {
            decodeJSON()
        }
    }

    /// Decode the JSON data
    private func decodeJSON() {
        do {
            if let json = json {
                self.layout = try JSONDecoder().decode(
                    [DynamicUIComponent].self,
                    from: json
                )
            }
        } catch {
            self.error = "Error decoding JSON: \(error)"
        }
    }

    /// Build a SwiftUI View based on the components
    /// - Parameter components: [UIComponent]
    /// - Returns: A SwiftUI View
    func buildView(for components: [DynamicUIComponent]) -> some View {
        return ForEach(components, id: \.self) { component in
            switch component.type {
            case "Text":
                DynamicText(component)
                    .environment(\.internalDynamicUIEnvironment, self)

            default:
                EmptyView()
            }
        }
    }
}

private struct InternalDynamicUIKey: EnvironmentKey {
    static let defaultValue: InternalDynamicUI = defaultValue
}

extension EnvironmentValues {
    var internalDynamicUIEnvironment: InternalDynamicUI {
        get { self[InternalDynamicUIKey.self] }
        set { self[InternalDynamicUIKey.self] = newValue }
    }
}

Step 4: Create a DynamicUI

We have now created all components needed to create our dynamic user interface.

We can now create a new struct called DynamicUI that can be used to create a dynamic user interface.

We create 2 initializers for the DynamicUI struct, one for JSON Data and one for JSON String.

public struct DynamicUI: View {
    /// DynamicUIComponent state change handler
    public typealias Handler = (DynamicUIComponent) -> Void

    /// JSON data
    public var json: Data?

    /// Initialize DynamicUI
    ///
    /// - Parameter json: JSON Data
    public init(json: Data? = nil) {
        self.json = json
    }

    /// Initialize DynamicUI
    /// 
    /// - Parameter json: JSON String
    public init(json: String? = nil) {
        // Convert the JSON string to data
        self.json = json?.data(using: .utf8)
    }

    /// Generated body for SwiftUI
    public var body: some View {
        AnyView(InternalDynamicUI(json: json))
    }
}

Step 5: Use the DynamicUI

We can now use the DynamicUI to create a dynamic user interface.

import SwiftUI

struct ContentView: View {
    var body: some View {
        DynamicUI(
            json: """
            [
                {
                    "type": "Text",
                    "title": "Hello, World!"
                }
            ]
            """
        )
    }
}

Step 6: Use the DynamicUI in Aurora Editor

We can now use the DynamicUI in Aurora Editor to create a dynamic user interface for extensions.

We can pass the JSON string to the DynamicUI and display the user interface.

// This is the view that will be displayed trough a extension window
AuroraEditor.respond("openWindow", {
  view: "[{\"type\":\"Text\",\"title\":\"Hello, World!\"}]"
});

We can also pass the JSON as a object to the DynamicUI and display the user interface.

// This is the view that will be displayed trough a extension window
AuroraEditor.respond(
    "openWindow", 
    {
      view: [{
        "type": "Text",
        "title": "Hello, World!"
      }]
    }
);

Playground

I have created a playground app that can be used to test the DynamicUI framework.

Conclusion

Creating a dynamic user interface for extensions in Aurora Editor was a challenge, but it is really fun, it need some more improvements but the basics are there.
I think i can improve some parts to make more use of @ViewBuilder.

Resources:

Understanding Sendable in Swift

Fri, 17 Oct 2025 22:37:08 +0200

With the introduction of Swift 5.5, Apple brought significant enhancements to concurrency, including the Sendable protocol and the @Sendable attribute. These additions are crucial for ensuring thread safety in concurrent programming.
Let's dive into what Sendable is, why it's important, and how you can use it in your Swift projects.

What is Sendable?

The Sendable protocol in Swift indicates that a type is safe to be used concurrently.
This means that instances of a Sendable type can be safely passed between different threads without causing data races or other concurrency issues.

Why is Sendable Important?

Concurrency introduces the challenge of ensuring that data accessed by multiple threads remains consistent and free from race conditions.
The Sendable protocol helps the Swift compiler enforce these safety guarantees.
By marking types as Sendable, you tell the compiler that these types can be safely shared across different threads.

Using @Sendable

The @Sendable attribute can be applied to closures and functions to indicate that they are safe to be executed concurrently.
When you mark a closure or function with @Sendable, the compiler enforces certain rules to ensure thread safety.
For example, any values captured by a @Sendable closure must themselves be Sendable.

Here's a simple example:

import Foundation

let task = Task { @Sendable in
    // This closure is marked as @Sendable
    print("Running a sendable task")
}

In this example, the closure passed to Task is marked with @Sendable, ensuring that any captured values are safe for concurrent use.

Conforming to Sendable

To make a custom type conform to Sendable, you need to ensure that all its stored properties are also Sendable.
Here's an example of a struct conforming to Sendable:

struct MyData: Sendable {
    let value: Int
}

let data = MyData(value: 42)

In this case, MyData is a simple struct with a single Int property, which is inherently Sendable.

Sendable in closures

When you use a closure that captures values, you need to ensure that those values are Sendable.

Here's an example:

import Foundation

let value = 42

let closure: @Sendable () -> Int = {
    return value
}

let result = closure()

print(result) // Output: 42

Practical Applications

Using Sendable and @Sendable is particularly useful in scenarios involving actors and tasks.
For instance, when you pass data between different actors or tasks, ensuring that the data is Sendable helps maintain thread safety and prevents potential concurrency issues.

Conclusion

The introduction of the Sendable protocol and the @Sendable attribute in Swift marks a significant step forward in making concurrent programming safer and more reliable. By understanding and utilizing these features, you can write more robust and thread-safe Swift code.

References:

Mastering animations in SwiftUI

Fri, 17 Oct 2025 22:37:08 +0200

SwiftUI, Apple's declarative framework for building user interfaces, offers powerful and flexible tools for creating animations. Whether you're looking to add subtle transitions or complex, interactive animations, SwiftUI has you covered. In this blog post, we'll explore the basics of animations in SwiftUI, delve into more advanced techniques, and provide practical examples to help you get started.

Understanding Animations in SwiftUI

Animations in SwiftUI can be broadly categorized into two types: implicit and explicit animations.

Implicit Animations: These are the simplest form of animations in SwiftUI. You define them using the .animation() modifier. When you apply this modifier to a view, any changes to animatable properties (like position, size, or color) will automatically animate from their old values to the new ones.

 struct ImplicitAnimationView: View {
     @State
     private var scale: CGFloat = 1.0

     var body: some View {
         VStack {
             Spacer()
             Circle()
                 .fill(Color.blue)
                 .frame(width: 100 * scale, height: 100 * scale)
                 .animation(.easeInOut(duration: 1.0), value: scale)
             Spacer()
             Button("Animate") {
                 scale = scale == 1.0 ? 2.0 : 1.0
             }
             .padding()
         }
     }
 }

Explicit Animations: These give you more control over the animation process. You use the withAnimation function to explicitly define when and how the animation should occur.

 struct ExplicitAnimationView: View {
     @State
     private var rotation: Double = 0

     var body: some View {
         VStack {
             Spacer()
             Rectangle()
                 .fill(Color.green)
                 .frame(width: 100, height: 100)
                 .rotationEffect(.degrees(rotation))
             Spacer()
             Button("Rotate") {
                 withAnimation(.easeInOut(duration: 1.0)) {
                     rotation += 45
                 }
             }
             .padding()
         }
     }
 }

Advanced Animation Techniques

SwiftUI also supports more advanced animations, such as spring animations and custom transitions.

Spring Animations: These animations simulate the effect of a spring, providing a more natural and dynamic feel. You can customize the stiffness and damping of the spring to achieve the desired effect.

 struct SpringAnimationView: View {
     @State
     private var offset: CGFloat = 0

     var body: some View {
         VStack {
             Spacer()
             Circle()
                 .fill(Color.red)
                 .frame(width: 100, height: 100)
                 .offset(y: offset)
                 .animation(.spring(response: 0.5, dampingFraction: 0.6, blendDuration: 0), value: offset)
             Spacer()
             Button("Bounce") {
                 offset = offset == 0 ? 300 : 0
             }
             .padding()
         }
     }
 }

Custom Transitions: Transitions define how a view appears and disappears. SwiftUI provides several built-in transitions, but you can also create custom transitions by combining existing ones.

 struct CustomTransitionView: View {
     @State
     private var showDetail = false

     var body: some View {
         VStack {
             Spacer()
             if showDetail {
                 Rectangle()
                     .fill(Color.purple)
                     .frame(width: 200, height: 200)
                     .transition(.asymmetric(insertion: .scale, removal: .opacity))
             }
             Spacer()
             Button("Toggle Detail") {
                 withAnimation {
                     showDetail.toggle()
                 }
             }
             .padding()
         }
     }
 }

Practical Examples

Let's look at a practical example that combines several animation techniques to create a more complex and interactive UI.

struct ComplexAnimationView: View {
    @State
    private var isAnimating = false

    var body: some View {
        VStack {
            Spacer()
            HStack {
                ForEach(0..<5) { index in
                    Circle()
                        .fill(isAnimating ? Color.red : Color.blue)
                        .frame(width: 50, height: 50)
                        .offset(y: isAnimating ? -100 : 0)
                        .animation(
                            .easeInOut(duration: 1.0)
                                .repeatForever(autoreverses: true)
                                .delay(Double(index) * 0.2),
                            value: isAnimating
                        )
                }
            }
            Spacer()
            Button("Start Animation") {
                isAnimating.toggle()
            }
            .padding()
        }
    }
}

In this example, we create a row of circles that bounce up and down with a delay between each circle, creating a wave-like effect. The animation repeats indefinitely, reversing direction each time.

Conclusion

SwiftUI's animation capabilities are both powerful and easy to use, allowing you to create engaging and dynamic user interfaces with minimal code. By understanding the basics of implicit and explicit animations, and exploring more advanced techniques like spring animations and custom transitions, you can bring your SwiftUI apps to life.

For more detailed information and examples, you can refer to the Apple Developer Documentation and other resources like Hacking with Swift.

Building Calendo

Fri, 17 Oct 2025 22:37:09 +0200

In this blog post, we'll explore the process of building Calendo, a calendar app that helps users view their schedules quickly and efficiently. We'll cover the key features of Calendo, the technologies used to develop it, and how you can get started with building your own calendar app.

The app idea "Calendo"

I really like to schedule my day, and I wanted to create a calendar app that would help me view my schedule quickly and efficiently. I wanted to create an app that would be easy to use, visually appealing, and provide a seamless experience for managing appointments and events.

Building Calendo

Creating the User Interface

I wanted to create a clean and intuitive user interface for Calendo, I wanted to prototype the app quickly and therefore I decided to use SwiftUI.

The main screen of Calendo displays a monthly calendar view with the current month and year at the top. Users can scroll through the calendar to view different months and tap on specific dates to view their appointments.

Textual representation of the view i wanted.

< August 2024 >              [action]

Wk  Mon  Tue  Wed  Thu  Fri  Sat  Sun 
31  29   30   31   1    2    3    4
32  5    6    7    8    9    10   11
33  12   13   14   15   16   17   18
34  19   20   21   22   23   24   25
35  26   27   28   29   30   31   1
36  2    3    4    5    6    7    8
=====================================
┌───────────────────────────────────┐
│ 03 August 2024 - All day          │
│ Wesley's 34th Birthday            │
└───────────────────────────────────┘
┌───────────────────────────────────┐
│ 07 August 2024 - 19:00 - 23:00    │
│ Weekly Meeten en Drinken          │
| Cafe BAX, Ten Katestraat 119.     |
└───────────────────────────────────┘
┌───────────────────────────────────┐
│ 14 August 2024 - 19:00 - 23:00    │
│ Weekly Meeten en Drinken          │
| Cafe BAX, Ten Katestraat 119.     |
└───────────────────────────────────┘

....

I wanted the days of the past and future to be dimmed out, and the current day to be highlighted.
I also wanted to display appointments for each day in a list below the calendar view.
A textual representation of the view i wanted for birthdays.

< Back                   ✏️
Wesley's 34th Birthday

        PHOTO  🎈
      OF CONTACT

Saturday, 3 August 2024
All day
Recurring, yearly.

 ┌───────────────────────────┐
 | Calendar:       Birthdays |
 | Notifications:         No |
 | Recurring:         Yearly |
 | Show as:             Free |
 | Status:       Appointment |
 └───────────────────────────┘

A textual representation of the view i wanted for appointments.

< Back                   ✏️
Weekly Meeten en Drinken

Wednesday, 7 August 2024
19:00 - 23:00
Recurring, weekly.

┌───────────────────────────┐
| MAP VIEW         MAP VIEW |
| MAP VIEW         MAP VIEW |
├─────────────┐    MAP VIEW |
| Look Around |    MAP VIEW |
| Look Around |    MAP VIEW |
├─────────────┴─────────────┤
| Addres....     [NAVIGATE] |
└───────────────────────────┘

┌───────────────────────────┐
| Calendar:        Calendar |
| Notifications:         No |
| Recurring:         Weekly |
| Show as:             Busy |
| Status:       Appointment |
└───────────────────────────┘

Implementing Core Features

I wanted Calendo to have the following core features:

Viewing Appointments: Users can view their appointments for a specific day by tapping on a date in the calendar.
Adding Appointments: Users can add new appointments by tapping on a date in the calendar and entering the details.
Editing Appointments: Users can edit existing appointments by tapping on an appointment in the list view.

I also wanted to include additional features like:

Lookaround, a feature that provides you with a 360-degree view of the location of your appointment.
Scroll trough your appointments and update the higlighted day in the calendar.

Problems encountered

I encountered several challenges while building Calendo, including:

Slow performance when loading large datasets.
Optimized data loading by using pagination (minus and plus one month).
Crashes due to specific appointments.
Fixed crashes by handling edge cases in the appointment data.
Slow performance when scrolling through the calendar.
Improved snappyness by doing certain calculations on the background, and only push the update back to the @Published variable.
Incorrect display of calendar view
On smaller screens, the calendar view was not displayed correctly.
I use a GeometryReader to calculate the size of the calendar view and adjust the layout accordingly.
But on smaller screens the text size was bigger than the available space, so i had to adjust the font size based on the available space.

Translations

Calendo is available in multiple languages.

English with help from Jake Ruston
Dutch (Nederlands)
German (Deutsch)
French (Français)
Greek (Ελληνικά) with help from Theo Palios
Italian (Italiano) with help from AngelK90
Portuguese (Português)
Spanish (Español)
Chinese (中文)
Arabic (العربية)

German, French, Italian, Portugese, Spanish, Chinese, Arabic are translated using Apple's Localisation framework, read more about it here (Translation framework in Swift).

Download Calendo

You can download Calendo from the AppStore!.

Updates:

Interested in the development of Calendo? Read my previous next about Fixing slow scrolling in Calendo or search on the Tag: Calendo.

Technologies/Frameworks Used

Foundation
Foundation is the base layer of all Apple frameworks, providing basic functionality like data storage, networking, and more.
SwiftUI
SwiftUI is Apple's declarative framework for building user interfaces across all Apple platforms.
Swift
Swift is a Apple's programming language.
EventKit
EventKit is a framework that allows you to access and manipulate calendar events and reminders.
EventKitUI
EventKitUI is a framework that provides a user interface for viewing and editing calendar events and reminders.
MapKit
MapKit is a framework that allows you to embed Apple Maps directly into your app.
OSLog
OSLog is a unified logging system that provides a way to log messages from your app.
OSLogViewer
OSLogViewer is a tool that allows you to view and filter OSLog messages on your device.
OnboardingKit
OnboardingKit is a library that provides a customizable onboarding experience for your app.
Admob_SwiftUI
Admob_SwiftUI is a library that allows you to easily integrate Google AdMob ads into your SwiftUI app.

Deep linking in SwiftUI

Fri, 17 Oct 2025 22:37:10 +0200

Deep linking is a powerful feature that allows users to navigate directly to specific content within your app using URLs. In SwiftUI, implementing deep linking can enhance user experience by providing seamless navigation and quick access to desired content. This blog post will guide you through the process of setting up deep linking in your SwiftUI application.

What is Deep Linking?

Deep linking involves using URLs to link directly to specific pages or content within a mobile application. This can be particularly useful for marketing campaigns, notifications, or any scenario where you want to direct users to a specific part of your app.

Setting Up Deep Linking in SwiftUI

Define URL Schemes:
To start, you need to define URL schemes in your app's Info.plist file. This allows your app to recognize and handle specific URL patterns.

<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>demoApp</string>
        </array>
        <key>CFBundleURLName</key>
        <string>nl.wesleydegroot.example</string>
    </dict>
</array>

Handle Incoming URLs:
Next, you need to handle incoming URLs in your SwiftUI app. This can be done by implementing the onOpenURL modifier, which allows you to respond to URL events.

@main
struct demoApp: App {
    @StateObject
    private var router = Router()

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(router)
                .onOpenURL { url in
                    router.handleDeepLink(url: url)
                }
        }
    }
}

Routing Logic:
Create a router class to manage navigation based on the incoming URL.

class Router: ObservableObject {
    @Published
    var currentView: String?

    func handleDeepLink(url: URL) {
        guard let host = url.host else { return }
        switch host {
        case "home":
            currentView = "home"
        case "profile":
            currentView = "profile"
        default:
            break
        }
    }
}

Navigating to Views:
Use the currentView property to navigate to the appropriate view in your SwiftUI app.

struct ContentView: View {
    @EnvironmentObject
    var router: Router

    var body: some View {
        VStack {
            if router.currentView == "home" {
                HomeView()
            } else if router.currentView == "profile" {
                ProfileView()
            } else {
                DefaultView()
            }
        }
    }
}

Benefits of Deep Linking

Improved User Experience: Users can access specific content directly, reducing the number of steps needed to find what they are looking for.
Enhanced Engagement: Deep links can be used in marketing campaigns to drive users to specific promotions or content.
Seamless Navigation: Users can resume their activity from where they left off, even if they are returning to the app after a long time.

Deep linking via a notification

Deep linking can also be used in combination with notifications to direct users to specific content within your app. When a user taps on a notification, they can be taken directly to the relevant page or screen.

let content = UNMutableNotificationContent()
    content.title = String(localized: "Your profile is 50% complete")
    content.body = String(localized: "Click here to complete your profile")
    content.userInfo = ["url": "demoApp://profile"]

let request = UNNotificationRequest(
    identifier: "DemoApp-ProfileSetupNotification", 
    content: content,
    trigger: UNTimeIntervalNotificationTrigger(
        timeInterval: 3600,
        repeats: false
    )
)

UNUserNotificationCenter.current().add(request)

Conclusion

Implementing deep linking in SwiftUI can significantly enhance the usability and engagement of your app. By following the steps outlined above, you can set up deep linking to provide a more intuitive and efficient user experience. Happy coding!

Navigation in SwiftUI

Fri, 17 Oct 2025 22:37:10 +0200

Navigating the World of SwiftUI: A Comprehensive Guide

SwiftUI, Apple's declarative framework for building user interfaces, has revolutionized the way developers create apps for iOS, macOS, watchOS, and tvOS. One of the core components of SwiftUI is its navigation system, which allows users to move seamlessly between different views. In this blog post, we'll explore the various navigation tools available in SwiftUI, including NavigationView, NavigationLink, and the newer NavigationStack introduced in iOS 16.

1. Understanding NavigationView

NavigationView is the foundational component for navigation in SwiftUI. It provides a container that manages a stack of views, allowing users to push and pop views as they navigate through the app.

import SwiftUI

struct ContentView: View {
    var body: some View {
        NavigationView {
            VStack {
                Text("Home View")
                NavigationLink(destination: DetailView()) {
                    Text("Go to Detail View")
                }
            }
            .navigationTitle("Home")
        }
    }
}

struct DetailView: View {
    var body: some View {
        Text("Detail View")
            .navigationTitle("Detail")
    }
}

In this example, NavigationView wraps the content, and NavigationLink creates a link to the DetailView. When the link is tapped, the DetailView is pushed onto the navigation stack.

2. Using NavigationLink

NavigationLink is a powerful tool that allows you to create links between views. It can be used in various ways, including programmatically.

NavigationLink(destination: Text("New View")) {
    Text("Tap to navigate")
}

You can also use NavigationLink with more complex views and data passing.

struct Item: Identifiable {
    var id = UUID()
    var name: String
}

struct ContentView: View {
    let items = [Item(name: "Item 1"), Item(name: "Item 2")]

    var body: some View {
        NavigationView {
            List(items) { item in
                NavigationLink(destination: Text(item.name)) {
                    Text(item.name)
                }
            }
            .navigationTitle("Items")
        }
    }
}

3. Introducing NavigationStack

With iOS 16, Apple introduced NavigationStack, which provides more flexibility and control over navigation. It allows for programmatic navigation and supports complex navigation paths.

import SwiftUI

struct ContentView: View {
    @State private var path = NavigationPath()

    var body: some View {
        NavigationStack(path: $path) {
            VStack {
                Button("Go to Detail") {
                    path.append("Detail")
                }
            }
            .navigationDestination(for: String.self) { value in
                if value == "Detail" {
                    DetailView()
                }
            }
        }
    }
}

struct DetailView: View {
    var body: some View {
        Text("Detail View")
    }
}

In this example, NavigationStack is used with a NavigationPath to manage the navigation state. The navigationDestination modifier specifies the destination view for each type of data in the path.

I go into more detail about NavigationStack in my NavigationStack post.

4. Best Practices for Navigation in SwiftUI

Avoid Nesting NavigationViews: Nesting NavigationView inside another NavigationView can lead to unexpected behavior. Instead, use a single NavigationView at the root of your view hierarchy.
Use Navigation Titles: Always set a navigation title for your views to provide context to the user.
Handle Deep Links: Ensure your app can handle deep links by properly managing the navigation state.

Conclusion

SwiftUI's navigation system is both powerful and flexible, allowing developers to create intuitive and seamless user experiences. Whether you're using NavigationView for simple navigation or NavigationStack for more complex scenarios, understanding these tools is essential for building modern SwiftUI apps.

It's a wrap (2024)

Fri, 17 Oct 2025 22:37:11 +0200

On 03 February 2024 I launched this (new) website, i wanted to post some more then once in 2 years,
in 2024 I've released 64 articles!

February

In February I've released 11 articles

New Website (1 min) [Tags: Website]
Welcome to the new website! We hope you like it. We've been working hard to make it as easy to use as possible. If you have any feedback, please let me know. This website is built with PHP. T...
Snippet: @EnvironmentVariable (1 min) [Tags: Swift, Observable, MacOS, EnvironmentVariable, propertyWrapper]
If you are creating commandline apps you sometimes need to acces the operating system environment variables, while you can use getenv(name) it can come in handy to use a property wrapper if you need...
OTP Code Generation with CryptoKit: A Swift Approach (2 min) [Tags: Swift, CryptoKit, TOTP]
In the realm of secure authentication, One An OTP is a temporary password that is valid for a single use or a short period. It ensures that even if an attacker intercepts the password, they won't ...
Implementing Admob in SwiftUI (6 min) [Tags: Swift, Admob]
Recently i was working on a project that required me to implement Admob in a SwiftUI app. I encountered some issues while implementing Admob in SwiftUI, so i decided to make a library Admob The Ad...
Xcode shortcuts (3 min) [Tags: Xcode, shortcuts]
As developers, we're always on the quest for efficiency. Whether you're a seasoned Xcode user or just starting out, harnessing the power of keyboard shortcuts can significantly enhance your coding ...
SwiftUI property wrappers (5 min) [Tags: SwiftUI, propertyWrapper]
Let's dive into the fascinating world of SwiftUI property wrappers. These powerful constructs allow you to manage data, state, and environment information in your SwiftUI views. 🚀 State: Thing...
iCloud Drive Tips & Tricks (5 min) [Tags: iCloud]
iCloud Drive is Apple's cloudiCloud Drive simplifies file management, collaboration, and access across your Apple ecosystem. Whether you're a student, professional, or creative, harness the power o...
async/await (4 min) [Tags: async, await, Swift]
Let's delve into the fascinating world of Swift's async/await. This powerful feature, introduced in Swift 5.5, revolutionizes asynchronous programming, making it more intuitive and readable. Buckl...
@dynamicMemberLookup (2 min) [Tags: dynamicMemberLookup, Swift]
Let's delve into the fascinating world of Swift's @dynamicMemberLookup. This attribute, introduced in Swift 4.2, provides a powerful mechanism for accessing properties and methods dynamically even th...
SimpleNetworking (5 min) [Tags: SimpleNetworking, Swift, SwiftPM]
Today i write about my Swift package SimpleNetworking. It's a simple networking library for Swift it is a wrapper around URLSession and provides a variety of functions to make easy network request...
Aurora Editor (3 min) [Tags: Aurora Editor, Swift]
As developers, we're always on the lookout for tools that enhance our productivity, streamline our workflows, and make coding a delightful experience. Enter Aurora Editor, a lightweight and fast ...

March

In March I've released 13 articles

Translating closures to async (4 min) [Tags: Async, Swift]
In this post, we will discuss how to translate closures to async in Swift. In Swift, a continuation is a construct that allows you to suspend and resume execution of a piece of code at a later time...
Localizing In Xcode (1 min) [Tags: Xcode, Swift, Localization]
Your app's success hinges on delivering an exceptional experience to users across different locales. Localization is more than just translating text; it involves handling plurals, adapting content ...
Dive into GIT (6 min) [Tags: git]
Let's dive into the world of GIT. Whether you're a seasoned developer or just starting out, understanding these commands is crucial for efficient version control and collaboration. Below, I'll intro...
What is @MainActor (4 min) [Tags: MainActor]
In the ever @MainActor is a global actor that utilizes the main queue for executing its work. In practical terms, this means that methods or types marked with @MainActor can safely modify the UI bec...
ContentUnavailableView (4 min) [Tags: SwiftUI, ContentUnavailableView]
In the ever ContentUnavailableView is a specialized SwiftUI view designed specifically for presenting empty states. It's your go In this example, if there are no search results while the query is n...
Pull-to-Refresh in SwiftUI (1 min) [Tags: SwiftUI]
PullIt allows users to refresh the content of a view by pulling down on it. In this post, we will learn how to implement pull Pull Let’s start with a simple example where you have a List display...
TipKit (2 min) [Tags: TipKit, Swift]
Let's delve into the fascinating world of TipKit, a powerful framework that empowers developers to create and customize app tips. Whether you're aiming to introduce new features, reveal hidden fun...
Implementing Sign in with Apple (5 min) [Tags: Sign in with Apple, SwiftUI]
Sign in with Apple is a userIn this blog post, we'll explore how to integrate Sign in with Apple into your Swift Sign in with Apple is a powerful authentication solution that simplifies user access ...
Default values for UserDefaults (1 min) [Tags: Swift, UserDefaults]
UserDefaults (NSUserDefaults) is a go UserDefaults is a simple key `swift let userDefaults = UserDefaults.standard userDefaults.register( defaults: [ "selectedPokemon": "Pikachu", ...
SwiftUI ViewModifiers (5 min) [Tags: SwiftUI, ViewModifiers]
SwiftUI ViewModifiers are a powerful tool for customizing and enhancing views in your app. They allow you to encapsulate common view modifications into reusable, composable units, making it easy to ...
Subscripts in Swift (1 min) [Tags: Swift]
Subscripts provide a convenient way to access the elements of a collection, list, or sequence directly by index. Whether you’re dealing with arrays, dictionaries, or custom types, subscripts allow ...
How to monitor network in SwiftUI (3 min) [Tags: SwiftUI, Network]
Network monitoring is crucial for maintaining robust and reliable applications. In this blog post, we’ll explore how to implement network monitoring in Swift using Apple’s native Network framew...
LabeledContent in SwiftUI (2 min) [Tags: SwiftUI, LabeledContent]
As developers, we often need to display a value alongside a label, and manually arranging this can be difficult. But LabeledContent, a powerful and versatile view that simplifies this common UI pat...

April

In April I've released 6 articles

ExpressibleByStringLiteral URL (1 min) [Tags: Swift, ExpressibleByStringLiteral]
The ExpressibleByStringLiteral protocol is a powerful feature in Swift that allows us to create custom types directly from string literals. Essentially, it enables us to initialize instances of our ...
self, Self, and Self.self in Swift (2 min) [Tags: Swift, self]
Let's dive into the fascinating world of self, Self, and Self.self in Swift. These seemingly similar constructs have distinct meanings and use cases. When you're inside an instance method or prope...
Appril Festival 2024 (5 min) [Tags: Conference, Appril Festival, Appsterdam]
As you may (or may not yet) know, I'd love to support and help the tech industry, today I'd like to highlight Appril Festival, i have volunteered a several times and it's a great event to attend, lea...
If case let (3 min) [Tags: Swift]
This concise syntax provides a convenient shortcut when you want to match a single case without writing a full Imagine you're working with the Swift Result type, capturing the results of a throwing ...
Variadic Parameters (3 min) [Tags: Swift]
These versatile constructs allow us to handle a variable number of arguments of the same type within a function. In Swift, variadic parameters enable a function to accept zero or more values of a s...
Generics in Swift (3 min) [Tags: Swift, Generics]
Swift, offers a powerful feature called generics that greatly enhances code reusability, efficiency, and safety. In this blog post, we will dive deep into generics and explore how they can be levera...

May

In May I've released 1 articles

Handle hyperlinks in SwiftUI (2 min) [Tags: SwiftUI, Hyperlink]
If you have a SwiftUI application and you present text with a URL, have you notices how the URL is being opened by Safari and not an in An action that opens a URL. OpenURLAction can be used to creat...

July

In July I've released 3 articles

Loging using OSLog (4 min) [Tags: Swift, OSLog]
OSLog is a Swift API that provides a unified logging system for all Apple platforms. It is a replacement for the older print and NSLog functions. OSLog is a more efficient and secure logging system t...
@Environment variables (3 min) [Tags: Environment, SwiftUI]
SwiftUI provides a way to pass data down the view hierarchy using @Environment variables. These variables are environment When you create an @Environment variable, SwiftUI automatically manages its ...
@ViewBuilder in Swift (3 min) [Tags: ViewBuilder, Swift]
SwiftUI, Apple's declarative framework for building user interfaces, introduces several powerful tools to streamline UI development. One such tool is the @ViewBuilder attribute, which simplifies the ...

August

In August I've released 5 articles

CoreSpotlight (6 min) [Tags: CoreSpotlight, Swift]
CoreSpotlight is a framework provided by Apple that allows you to index and search content within your app. It provides a way to make your app's content searchable and discoverable by users through t...
Difference between map, flatMap, compactMap (2 min) [Tags: Swift, map, flatmap, compactMap]
In this post, we'll explore the differences between map, flatMap, and compactMap in Swift. These three methods are commonly used when working with collections, and understanding their distinctions is...
Enums (7 min) [Tags: Swift, Enums]
In this post, we'll explore enums in Swift, a powerful feature that allows you to define a group of related values. Enums are commonly used to represent a fixed set of options or states in your code,...
What is @frozen (4 min) [Tags: Swift, Frozen]
In this post, we'll explore the @frozen attribute in Swift, a compiler directive that can be applied to enum declarations to optimize memory layout and improve performance. By marking an enum as @fro...
iOS Settings URL's (93 min) [Tags: Swift, iOS, Settings]
This is a list of internal URLs for settings on your iPhone, iPad, ... Please note that this list will be updated if required, if you see something which is not right, please drop me a message and i...

September

In September I've released 4 articles

Why You Should Avoid Using AnyView in SwiftUI (3 min) [Tags: SwiftUI, AnyView]
SwiftUI, Apple's declarative framework for building user interfaces, introduces a variety of new concepts and tools for developers. One such tool is AnyView, a typeWhile AnyView can be useful in c...
A Guide to UI Testing in Swift (9 min) [Tags: Swift, UITest, XCUITest]
User Interface (UI) testing is a crucial aspect of app development, ensuring that your app's interface behaves as expected under various conditions. This guide will walk you through the basics of ...
Understanding assertions in Swift (2 min) [Tags: Assert, Swift]
Assertions are a powerful tool in Swift that help developers ensure their code behaves as expected during runtime. They allow you to test assumptions and catch potential issues early in the developme...
Safely unwrap optional values in SwiftUI bindings (3 min) [Tags: SwiftUI, Binding]
Bindings are a powerful feature in SwiftUI that allow you to connect your views to your data. However, when working with optional values, you need to be careful to avoid crashes due to force unwrappi...

October

In October I've released 12 articles

Hacktoberfest 2024 (2 min) [Tags: Hacktoberfest]
As the leaves change color and the air turns crisp, developers around the world gear up for one of the most exciting events in the openThis annual celebration, organized by DigitalOcean, GitHub, and...
SwiftUI Development with DynamicUI (2 min) [Tags: SwiftPM, DynamicUI]
In the everOne tool that stands out in achieving these goals is DynamicUI, a Swift Package designed to create SwiftUI user interfaces dynamically from JSON files. Let's explore how DynamicUI can t...
Simplifying multiplatform Colors (1 min) [Tags: SwiftPM, Colors]
Sometimes you are building for multiple platforms and you want to use the same color across all of them. This is where the Colors package comes in handy. It provides a set of predefined system c...
Simplifying App Onboarding with OnboardingKit (4 min) [Tags: SwiftPM, OnboardingKit]
Creating a smooth and engaging onboarding experience is crucial for any app. OnboardingKit, a SwiftUI package available on GitHub, provides a comprehensive solution to help developers create these...
Simplifying Game Controller Integration with GameControllerKit (3 min) [Tags: SwiftPM, GameControllerKit]
In the everEnter GameControllerKit, a Swift package designed to streamline this process for developers working on iOS, macOS, and tvOS. Let's dive into what makes this toolkit a game GameControll...
Enhancing SwiftUI with CachedAsyncImage (2 min) [Tags: SwiftPM, CachedAsyncImage]
In the world of mobile app development, performance and user experience are paramount. One common challenge developers face is efficiently loading and caching images. Enter CachedAsyncImage, a S...
Inspect: A Powerful Tool for SwiftUI Developers (2 min) [Tags: SwiftPM, Inspect]
As SwiftUI continues to evolve, developers are constantly seeking tools to streamline their workflow and enhance their debugging capabilities. One such tool that stands out is Inspect, a Swift Pac...
SwiftLeeds 2024, Day 1 (2 min) [Tags: SwiftLeeds]
It's that time of year again! SwiftLeeds 2024 is here, and in this post, i'll be sharing my thoughts on the first day of the conference. Key Takeaways: ...
SwiftLeeds 2024, Day 2 (3 min) [Tags: SwiftLeeds]
It's that time of year again! SwiftLeeds 2024 is here, and in this post, i'll be sharing my thoughts on the second (and last) day of the conference. Hidde shared his insights on how to improve...
Understanding Package.swift (9 min) [Tags: SwiftPM, Package.swift]
If you're diving into Swift development, you've likely encountered Package.swift. This file is the cornerstone of Swift Package Manager (SPM), Apple's tool for managing Swift code dependencies. ...
Translation framework in Swift (4 min) [Tags: Swift, Translation, Framework]
With the release of iOS 17.4, Apple introduced the Translation framework, a powerful tool that allows developers to integrate text translation capabilities directly into their Swift applications. T...
Building an Asynchronous Button in SwiftUI (5 min) [Tags: SwiftUI, Asynchronus]
Sometimes, we need to perform asynchronous tasks when a button is tapped in a SwiftUI application. For example, fetching data from a network request, saving data to a database, or performing any lon...

November

In November I've released 4 articles

Exploring the .inspector Modifier in SwiftUI (3 min) [Tags: Inspector, SwiftUI]
SwiftUI continues to evolve, bringing new and powerful tools to developers. One such tool is the .inspector modifier, introduced to enhance the user interface by providing contextThis article will...
Understanding reducers in Swift (3 min) [Tags: Swift, reduce]
Reducers are a powerful concept in Swift, allowing developers to transform sequences of values into a single result. This technique is particularly useful when you need to perform operations like ...
Creating a dynamic user interface for extensions in Aurora Editor (8 min) [Tags: Aurora Editor, In-depth]
As some of you may know, I have been working on a IDE called Aurora Editor. It is a editor that is built using Swift and SwiftUI and is designed to be extensible and native. In this post, I will ...
Understanding Sendable in Swift (3 min) [Tags: Swift, Sendable]
With the introduction of Swift 5.5, Apple brought significant enhancements to concurrency, including the Sendable protocol and the @Sendable attribute. These additions are crucial for ensuring threa...

December

In December I've released 5 articles

Mastering animations in SwiftUI (4 min) [Tags: SwiftUI, Animation]
SwiftUI, Apple's declarative framework for building user interfaces, offers powerful and flexible tools for creating animations. Whether you're looking to add subtle transitions or complex, interact...
Building Calendo (5 min) [Tags: Calendo]
In this blog post, we'll explore the process of building Calendo, a calendar app that helps users view their schedules quickly and efficiently. We'll cover the key features of Calendo, the technolog...
Deep linking in SwiftUI (3 min) [Tags: SwiftUI, Navigation]
Deep linking is a powerful feature that allows users to navigate directly to specific content within your app using URLs. In SwiftUI, implementing deep linking can enhance user experience by providi...
Navigation in SwiftUI (3 min) [Tags: SwiftUI, Navigation]
SwiftUI, Apple's declarative framework for building user interfaces, has revolutionized the way developers create apps for iOS, macOS, watchOS, and tvOS. One of the core components of SwiftUI is it...
It's a wrap (2024) (1 min) [Tags: Wrapped, 2024]
On 03 February 2024 I launched this (new) website, i wanted to post some more then once in 2 years, in 2024 I've released 64 articles! In February I've released 11 articles In March I'v...

Reading minutes per month

February: 37 minutes
March: 39 minutes
April: 17 minutes
May: 2 minutes
July: 10 minutes
August: 112 minutes
September: 17 minutes
October: 39 minutes
November: 17 minutes
December: 16 minutes

The total reading time of all articles is about 306 minutes (5.1 hours)!

Apple version numbers

Fri, 17 Oct 2025 22:37:11 +0200

As you may know, Apple releases new versions of its operating systems every year. The version numbers are not always the same across all platforms, and they don't always follow the same pattern. Here is a list of the version numbers for Apple's operating systems, starting from 2007.

Year	iOS	iPadOS	macOS	tvOS	visionOS	watchOS	Xcode	iPhone	Watch
2025	26	26	26: Sequoia	26	26	26	26	??	??
2024	18	18	15: Sequoia	18	2	11	16	16	10
2023	17	17	14: Sonoma	17	1	10	15	15	9
2022	16	16	13: Ventura	16		9	14	14	8
2021	15	15	12: Monterey	15		8	13	13	7
2020	14	14	11: Big Sur	14		7	12	12	6
2019	13	13	10.15: Catalina	13		6	11	11	5
2018	12		10.14: Mojave	12		5	10	XR & XS	4
2017	11		10.13: High Sierra	11		4	9	8 & X	3
2016	10		10.12: Sierra	10		3	8	7	2
2015	9		10.11: El Capitan	9		2	7	6s	1
2014	8		10.10: Yosemite			1*	6	6
2013	7		10.9: Mavericks				4.6 & 5.0	5s & 5c
2012	6		10.8: Mountain Lion				4.3, 4.4, 4.5	5
2011	5		10.7: Lion				4 & 4.1	4s
2010	4						3.2	4
2009	3		10.6: Snow Leopard				5?	3GS
2008	2						3.1	3G
2007	1		10.5: Leopard				3	2G

Accessibility in SwiftUI

Fri, 17 Oct 2025 22:37:12 +0200

Accessibility in app development is all about making sure everyone, regardless of their abilities, can use your app. Apple’s SwiftUI framework makes integrating accessibility features more streamlined. Here, we'll explore key strategies to make your SwiftUI apps more inclusive.

Understanding Accessibility

Accessibility isn't just a checklist; it’s a mindset. Think of it as designing for the broadest range of human abilities and environments. It's about empathy, respecting your users, and enabling them to interact with your app seamlessly.

Best Practices for Accessibility

Use Dynamic Type for adjustable text sizes.
Ensure sufficient contrast between text and background colors.
Provide text labels for color-coded information.
Make interactive elements large enough for easy tapping.

Important modifiers

.accessibilityLabel(_:): Provides a descriptive label for UI elements.
.accessibilityValue(_:): Represents the current value of an interactive element.
.accessibilityHint(_:): Offers hints about how to use a UI element.
.accessibilityAction(_:_:): Allows you to define custom actions for accessibility.
.accessibilitySortPriority(_:): Sets the sort priority of an accessibility element.

Accessibility in SwiftUI: Getting Started

SwiftUI simplifies the process with built-in accessibility modifiers.
Let’s cover some of the fundamental elements.

1. Labeling and Identifying Elements

The .accessibility(label:) modifier help users with assistive technologies understand your UI.

Text("Play")
    .accessibilityLabel(label: Text("Play button"))
    .accessibilityIdentifier("play_button")

.accessibilityIdentifier(_:) is useful for UI testing.

2. Providing Hints

Hints can help users understand the purpose of interactive elements.
The .accessibilityHint(_:) modifier provides additional information.

Button(action: {
    // Action
}) {
    Image(systemName: "trash")
}
.accessibilityHint(Text("Deletes the current item"))

3. Grouping Elements

Use the .accessibilityElement(children:) modifier to logically group UI elements together, improving navigation.

VStack {
    Text("Name")
    TextField("Enter your name", text: $name)
}
.accessibilityElement(children: .combine)

4. Hide non-essential Elements

Use the .accessibilityHidden(_:) modifier to hide non-essential elements from assistive technologies.

Text("I am here only for the fancy design!")
    .accessibilityHidden(true)

5. Accessibility speach language

Use the .accessibilityLanguage modifier to set the language of the accessibility label.

let attributedString = AttributedString(
    "Nederland is bekend om zijn tulpen en windmolens.",
    attributes: AttributeContainer([
        .accessibilitySpeechLanguage: "nl_NL"
    ])
)

Text(attributedString)

6. Accessibility Actions

You can create custom actions that VoiceOver users can trigger using the .accessibilityAction(named:_:) modifier.

Image(systemName: "heart")
    .accessibilityAction(named: Text("Like song")) {
        // Handle action
    }

7. Accesibility Announcements

Use AccessibilityNotification to provide custom announcements for VoiceOver users.

@State
private var isLoading = false

var body: some View {
    VStack {
        Button("Search catalog") {
            isLoading = true
        }

        if isLoading {
            ProgressView()
        }
    }
    // Track state changes
    .onChange(of: isLoading) { _, isLoading in
        if isLoading {
            UIAccessibility.post(
                notification: .announcement, 
                argument: "Search in progress"
            )
        }
    }
}

8. Accessibility focus state

Use the @AccessibilityFocusState and .accessibilityFocused(_:) modifier to manage the focus state of an element.

@AccessibilityFocusState
private var isEmailFocused: Bool

@State
private var email = ""

var body: some View {
    Form {
        TextField("Email", text: $email, prompt: Text("Email"))
            // Binds the focus state of this TextField to the 'isEmailFocused' property.
            .accessibilityFocused($isEmailFocused)
            // The border color changes based on whether the TextField is focused:
            .border(isEmailFocused ? .red : .clear)
    }
}

Sample taken from: https://appt.org/en/docs/swiftui/samples/accessibility-focus-indicator

9. Accessibility sort priority

Use the accessibilitySortPriority(_:) modifier to set the sort priority of an accessibility element.

VStack {
    Text("First Element")
        .accessibilitySortPriority(2) // Reads second
    Text("Second Element")
        .accessibilitySortPriority(3) // Reads first
    Text("Third Element")
        .accessibilitySortPriority(1) // Reads third
}
.accessibilityElement(children: .contain) // Groups the stack's children

10. Accessibility traits

Use the accessibilityAddTraits(_:) modifier to set the traits of an accessibility element.

// Button Trait
Text("Tap Me")
    .accessibilityAddTraits(.isButton)

// Header Trait
Text("Section Header")
    .font(.headline)
    .accessibilityAddTraits(.isHeader)

// Link Trait
Text("Visit Website")
    .foregroundColor(.blue)
    .underline()
    .accessibilityAddTraits(.isLink)

// Image Trait
Image(systemName: "star.fill")
    .accessibilityAddTraits(.isImage)

// Custom Checkbox Trait
@State
private var isSelected: Bool = false

var body: some View {
    CustomCheckbox(isSelected: $isSelected)
        .accessibilityAddTraits(isSelected ? [.isSelected] : [])
}

11. Accessibility value

Use the accessibilityValue(_:) modifier to set the value of an accessibility element.

@State
private var progress: Double = 0

var body: some View {
    MySlider(value: $progress)
        .accessibilityValue("\(progress)")
}

12. Dynamic Type

Support Dynamic Type by using the font modifier with the .largeTitle, .title, .headline, .body, or .caption text styles.

Text("Hello, World!")
    .font(.largeTitle)

14. Autocomplete

Autocompletion is an accessibility feature that helps users complete text input.
Use the .searchSuggestions(_:) modifier to provide search suggestions.

ProductList()
    .searchable(text: $text)
    // Provide search suggestions
    .searchSuggestions {
        Text("🍎").searchCompletion("apple")
        Text("🍐").searchCompletion("pear")
        Text("🍌").searchCompletion("banana")
    }

15. Dark Mode

Dark mode is an accessibility feature that helps users with light sensitivity or visual impairments.

@Environment(\.colorScheme)
var colorScheme

var body: some View {
    HStack {
        if colorScheme == .dark {
            // Show moon icon (dark mode)
            Image(systemName: "moon.fill")
        } else {
            // Show sun icon (light mode)
            Image(systemName: "sun.max.fill")
        }

        Text(colorScheme == .dark ? "In dark mode" : "In light mode")
    }   
}

16. Sensory Feedback

Sensory feedback, like haptic feedback, can help users with visual impairments navigate your app.
This can be achived using the UIImpactFeedbackGenerator and UINotificationFeedbackGenerator classes.

Button("Tap Me for Haptic Feedback") {
    UIImpactFeedbackGenerator(style: .heavy)
        .impactOccurred()

    // Action
}

Button("Tap Me for Success") {
    UINotificationFeedbackGenerator()
        .notificationOccurred(.success)

    // Action
}

Testing Accessibility

Regularly test your app's accessibility using tools like VoiceOver.
Navigate through your app and ensure that every element makes sense and that there are no barriers to interaction.

Conclusion

Accessibility is integral to creating inclusive, user-friendly apps. With SwiftUI's robust accessibility features, there's no excuse for not making your app usable by everyone. It's about designing with empathy and making sure your app stands out by being accessible to all.

Tip:

Use the Accessibility Inspector in Xcode to check your app's accessibility, and enable and disable accessibility features to see how your app behaves.

Resources:

Contact Provider Extension

Fri, 17 Oct 2025 22:37:12 +0200

The ContactProvider framework lets your app create (business) contacts on the user's device.
It is the prefered way to add contacts to the user's address book without interferring with their (personal) address book.

In this post we will create a simple app that uses the ContactProvider framework to add a business contact to the user's address book.

How are we going to setup our application?

We want these features:

Adding a contact.
Reset the contacts database.
Sync to the contact provider extension (yes for this demo we'll do it manually).

We need a way to easily add and fetch contacts from our app's "database".
We will create an observable object that will hold the contacts.

Required actions for the app and extension

In our app we need to do the following actions:

We need to tell the system that we are able to provide contacts.

let manager = try ContactProviderManager()
try await manager.enable()

We need to synchronize the contacts with the system.

let manager = try ContactProviderManager()
try await manager.signalEnumerator()

In our extension we need to conform to the ContactItemEnumerator protocol.

enumeratecontent(in:for:) for syncing the initial contacts.
enumeratechanges(startingat:for:) for syncing the changes.

Building the app

Add the `Contact Provider Extension` in your app.

To enable ContactProvider in your app, you need to add the Contact Provider Extension to your app.

Setup an App Group

To enable communication between your app and the Contact Provider Extension, you need to setup an App Group.
For this example we will use the group.nl.wesleydegroot.contactproviderdemo App Group.

Building the main application

import ContactProvider

struct ContentView: View {
    /// The database that holds the contacts.
    @ObservedObject
    var database = ContactItemDatabase()

    @State var firstName: String = ""
    @State var lastName: String = ""
    @State var email: String = ""
    @State var phoneNumber: String = ""

    /// The contact provider manager.
    let manager = try! ContactProviderManager()

    var body: some View {
        VStack {
            Button("Send to contact provider") {
                Task {
                    // Synchronise contacts
                    await synchroniseContacts() 
                }
            }
            .buttonStyle(.borderedProminent)
            Button("Reset Database") {
                Task {
                    // Reset the database
                    database.reset() 

                    // Reset all previously known contacts.
                    try? await manager.reset() 
                }
            }
            .buttonStyle(.borderedProminent)

            List {
                ForEach(database.contactItemsJSON, id: \.firstName) { item in
                    Text("\(item.firstName) \(item.lastName)")
                }
            }

            GroupBox {
                TextField("First name", text: $firstName)
                TextField("Last name", text: $lastName)
                TextField("Email", text: $email)
                TextField("Phone number", text: $phoneNumber)

                Button("Add") {
                    saveToDatabase()
                }
            }
            .task {
                randomContact()
            }
            .background(.secondary)
        }
        .padding()
        .task {
            do {
                // May prompt the person to enable the default domain.
                try await manager.enable()
            } catch {
                // Handle the error.
            }
        }
    }

    func saveToDatabase() {
        database.save(
            .init(
                firstName: firstName,
                lastName: lastName,
                phoneNumber: phoneNumber == "" ? nil : phoneNumber,
                emailAddress: email == "" ? nil : email
            )
        )

        Task {
            randomContact()
        }
    }

    func randomContact() {
        firstName = ["John", "Jane", "Wesley", "Alice", "Bob"].randomElement()!
            lastName = ["Doe", "Smith", "de Groot", "Johnson", "Williams"].randomElement()!
            email = "\(firstName.lowercased()).\(lastName.lowercased())@example.com"
            phoneNumber = "+31612345678"
    }

    func synchroniseContacts() async {
        do {
            try await manager.signalEnumerator()
        } catch {
            // Handle the error.
            print(error)
        }
    }
}

Building the "middleware" `ContactItemDatabase`

import Foundation
import Contacts
import ContactProvider

class ContactItemDatabase: ObservableObject {
    // The items that will be synchronised to the Contact Provider extension.
    @Published public var contactItems: [ContactItem] = []

    // The items that will be saved to the database.
    @Published public var contactItemsJSON: [ContactItemJSON] = []

    // The url of our shared database. (App Group)
    private let fileURL = FileManager.default.containerURL(
        // App Group identifier.
        forSecurityApplicationGroupIdentifier: "group.nl.wesleydegroot.contactproviderdemo"
    )?.appendingPathComponent("ContactItems").appendingPathExtension("json")

    // The JSON struct that will be saved to the database.
    struct ContactItemJSON: Codable, Hashable {
        /// The identifier of the contact.
        var identifier: String = UUID().uuidString

        /// The first name of the contact. (givenName)
        var firstName: String

        /// The last name of the contact.
        var lastName: String

        /// The phone number of the contact.
        var phoneNumber: String?

        /// The email address of the contact.
        var emailAddress: String?
    }

    init() {
        guard let fileURL else {
            print("Could not find file URL; is the App Group identifier correct?")
            return
        }

        // Load the contents of our json (database) file.
        if let data = try? Data(contentsOf: fileURL) {
            let decoder = JSONDecoder()
            // Decode the JSON data from our ContactItemJSON struct.
            if let decoded = try? decoder.decode([ContactItemJSON].self, from: data) {
                // Save the decoded data to our contactItemsJSON array.
                // And remove any duplicates Array(Set(...)).
                contactItemsJSON = Array(Set(decoded)) 

                // Walk trough our contacts
                for item in contactItemsJSON {
                    // Create a new contact.
                    let contact: CNMutableContact = .init()

                    // Set the first name of the contact.
                    contact.givenName = item.firstName

                    // Set the last name of the contact.
                    contact.familyName = item.lastName

                    // If the contact has a phone number, add it to the contact.
                    if let phoneNumber = item.phoneNumber {
                        contact.phoneNumbers = [
                            .init(
                                label: "Mobile",
                                value: CNPhoneNumber(stringValue: phoneNumber)
                            )
                        ]
                    }

                    // If the contact has an email address, add it to the contact.
                    if let emailAddress = item.emailAddress {
                        contact.emailAddresses = [
                            .init(
                                label: "Email",
                                value: emailAddress as NSString
                            )
                        ]
                    }

                    // Create a new contact item identifier, from the contact identifier.
                    let identifier: ContactItem.Identifier = .init(item.identifier)

                    // Add the contact to the contactItems array.
                    contactItems.append(
                        .contact(contact, identifier)
                    )
                }
            }
        }
    }

    /// Reset the database.
    func reset() {
        // Remove all `ContactItem` items.
        contactItems.removeAll()

        // Remove all `ContactItemJSON` items.
        contactItemsJSON.removeAll()

        // Save the empty array to the database.
        try? JSONEncoder().encode(contactItemsJSON).write(to: fileURL!)
    }

    func save(_ contactItem: ContactItemJSON) {
        // Append the new contact to the contactItemsJSON array.
        contactItemsJSON.append(contactItem)

        // Save the new contact to the database.
        try? JSONEncoder().encode(contactItemsJSON).write(to: fileURL!)
    }
}

Building the ContactProvider Extension

import Foundation
import ContactProvider
import Contacts
import OSLog

@main
class Provider: ContactProviderExtension {
    private let rootContainerEnumerator: ProviderRootContainerEnumerator

    required init() {
        rootContainerEnumerator = ProviderRootContainerEnumerator()
    }

    func configure(for domain: ContactProviderDomain) {
        rootContainerEnumerator.configure(for: domain)
    }

    func enumerator(for collection: ContactItem.Identifier) -> ContactItemEnumerator {
        return rootContainerEnumerator
    }

    func invalidate() async throws {
        // TODO: Stop any enumeration and cleanup as the extension will be terminated.
    }
}

class ProviderRootContainerEnumerator: ContactItemEnumerator {
    /// The database that holds the contacts.
    private let database = ContactItemDatabase()

    func configure(for domain: ContactProviderDomain) {
        // TODO: If needed, configure your enumerator for the domain.
    }

    func enumerateContent(in page: ContactItemPage, for observer: ContactItemContentObserver) async {
        // Send the current contacts to the observer.
        observer.didEnumerate(self.database.contactItems)

        // Signal that we are done with the enumeration.
        observer.didFinishEnumeratingContent(upTo: "<currentDatabaseGenerationMarker>".data(using: .utf8)!)
    }


    func enumerateChanges(startingAt syncAnchor: ContactItemSyncAnchor, for observer: ContactItemChangeObserver) async {
        // Send the changes to the observer.
        observer.didUpdate(self.database.contactItems)

        // In this demo we dont support "remove" altough it can be implemented by giving the identifiers for the deleted items
        // observer.didDelete(self.database.deletedItemIdentifiers)

        // Signal that we are done with the enumeration.
        observer.didFinishEnumeratingChanges(
            upTo: ContactItemSyncAnchor(generationMarker: "<lastChangeGenerationMarker>".data(using: .utf8)!, offset: 0),
            moreComing: false
        )
    }

    func invalidate() async {
        // TODO: Stop the enumeration and cleanup as the extension will be terminated.
    }
}

Wrap up

You can download the full project from https://github.com/0xWDG/ContactProviderDemo.

Conclusion

ContactProvider is a great way to add contacts to the user's address book without interferring with their (personal) address book.
The finish signals are a bit confusing, but once you get the hang of it, it is a great way to add contacts to the user's address book.

Resources:

Using MetricKit

Fri, 17 Oct 2025 22:37:13 +0200

In this post, I will show you how to use MetricKit to collect and analyze performance data from your app.

What is MetricKit?

MetricKit is a framework introduced in iOS 13 that allows you to collect and analyze performance data from your app.
It provides a set of APIs to access metrics such as CPU usage, memory usage, disk I/O, and network I/O.
You can use this data to identify performance bottlenecks, optimize your app, and improve the user experience.

What metrics can you collect?

MetricKit provides APIs to collect the following metrics:

Diagnostics for crashes
Hangs
Energy
Disk writes

How to use MetricKit?

To use MetricKit in your app, you need to follow these steps:

Step 1: Import MetricKit

import MetricKit

Step 2: Register for metric updates

To receive metric updates, you need to create a class that conforms to the MXMetricManagerSubscriber protocol and register your class with the MXMetricManager singleton object in your app's main entry point.

@main
struct DinnerConnectApp: App {
    private var metrics = MetricSubscriber()

    var body: some Scene {
        WindowGroup {
            MyAppView()
                .onAppear {
                    MXMetricManager.shared.add(metrics)
                }
        }
    }
}

Step 3: Implement the MetricSubscriber protocol

We create a MetricSubscriber class that conforms to the MXMetricManagerSubscriber protocol to receive metric payloads.

class MetricSubscriber: NSObject, MXMetricManagerSubscriber {
    func didReceive(_ payloads: [MXMetricPayload]) {
        print("didReceive MXMetricPayload")
        guard let firstPayload = payloads.first else { return }

        if let jsonString = String(
            data: firstPayload.jsonRepresentation(), 
            encoding: .utf8
        ) {
            print(jsonString)
        } else {
            print("Failed to encode")
        }
    }

    func didReceive(_ payloads: [MXDiagnosticPayload]) {
        print("didReceive MXDiagnosticPayload")
        guard let firstPayload = payloads.first else { return }

        if let jsonString = String(
            data: firstPayload.jsonRepresentation(), 
            encoding: .utf8
        ) {
            print(jsonString)
        } else {
            print("Failed to encode")
        }
    }
}

Debugging MetricKit

MetricKit will only work on a real device, not on the simulator.
To send a metric payload to your app, you can go to Debug > Simulate MetricKit Payloads in Xcode.

References/resources:

iOS App States

Fri, 17 Oct 2025 22:37:14 +0200

When you're developing an iOS app, it's important to understand the different states that your app can be in, to handle them correctly and provide a smooth user experience. In this post, we'll take a look at the different app states in iOS and how you can work with them.

Not Running

The app is not running. This is the initial state of the app when it's not launched or has been terminated by the system.

Inactive

The app is running in the foreground but is not receiving events. This can happen when the app is transitioning to a different state, such as when a phone call or SMS message is received, pr when Control Center or Notification Center is displayed.

Active

The app is running in the foreground and is receiving events. This is the normal state for the app when it's active and the user is interacting with it.

Background

The app is running in the background (not visible for the user) and performing background tasks. This can happen when the user switches to another app or when the app is suspended by the system.

Suspended

The app is in the background but is not executing tasks. This is the state when the app is in the background but is not performing any tasks. The system can terminate the app in this state to free up resources.

The OS can move the app to this state after it has been in the background for a while and is not performing any tasks.

Responding to App State Changes

You can respond to app state changes by adding the following modifiers to your SwiftUI views:

    .onReceive(NotificationCenter.default.publisher(
        for: UIApplication.willResignActiveNotification
    )) { _ in
        // app is going to the background, so do something
    }
    .onReceive(NotificationCenter.default.publisher(
        for: UIApplication.willEnterForegroundNotification
    )) { _ in
        // app is coming to the foreground, so do something else
    }

.onAppear - Called when the view appears on the screen.
.onDisappear - Called when the view disappears from the screen.
.onReceive - Called when the view receives a notification.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)) - Called when the app is about to enter the foreground.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.didEnterBackgroundNotification)) - Called when the app enters the background.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.willResignActiveNotification)) - Called when the app is about to become inactive.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.didBecomeActiveNotification)) - Called when the app becomes active.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.willTerminateNotification)) - Called when the app is about to be terminated.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.didFinishLaunchingNotification)) - Called when the app has finished launching.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)) - Called when the app is about to enter the foreground.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.didEnterBackgroundNotification)) - Called when the app enters the background.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.willResignActiveNotification)) - Called when the app is about to become inactive.
.onReceive(NotificationCenter.default.publisher(for: UIApplication.didBecomeActiveNotification)) - Called when the app becomes active.

Resources:

https://developer.apple.com/documentation/uikit/app_and_environment/managing_your_app_s_life_cycle

Controllig login and background items

Fri, 17 Oct 2025 22:37:14 +0200

In This post, we'll take a look at how to control login and background items on macOS.
When you start your Mac, you may have noticed that some apps or items automatically start up or appear in the background. This can be useful for apps that you use frequently, but it can also slow down your Mac or clutter your desktop.

Difference between Login Items and Background Items

Login Items: These are apps or items that automatically start up when you log in to your Mac. They can be useful for apps that you use frequently, such as messaging apps, email clients, or productivity tools.
Background Items: These are apps or items that run in the background when you start your Mac. They can be useful for apps that need to perform tasks in the background, such as cloud storage services, backup utilities, or system utilities.

* You can add or remove login items in the Users & Groups preferences pane in System Preferences. You can also use the sfltool command-line tool to list, add, remove, or reset login items, this is the tool we will use in this post.

How to List Login Items

This command will list all the login items that are set to start up when you log in to your Mac.

Open terminal
Type sudo sfltool dumpbtm

* Tip: Export the output to a text file, so you can read the values if you have resetted the login items.

Dump Login Items to a Text File

This can be useful if you want to save the list of login items to a text file for reference before making any changes.

Open terminal
Type sudo sfltool dumpbtm > ~/Desktop.login_items.txt
Open the file login_items.txt on your desktop to see the list of login items.

How to Add Login Items

Adding login items to start those apps when you log in to your Mac.

Open terminal
Type sudo sfltool add --label "App Name" -a "/Applications/AppName.app"

How to Remove Login Items

Removing login items to stop those apps from starting when you log in to your Mac.

Open terminal
Type sudo sfltool remove --label "App Name"

Reset Login Items

If you see a whole bunch of login items that you don't recognize or can't remove, you can reset the login items list to the default settings.

Open terminal
Type sudo sfltool reset

`launchctl` Command (Background Items)

You can use the launchctl command-line tool to manage background items on macOS. Here are some useful commands:

launchctl list - List all background items.
launchctl start <label> - Start a background item.
launchctl stop <label> - Stop a background item.
launchctl remove <label> - Remove a background item.
launchctl load <path> - Load a background item from a property list file.
launchctl unload <path> - Unload a background item from a property list file.
launchctl print <label> - Print the properties of a background item.

Items loaded by launchctl are usually controlled by Property Lists installed in the ~/Library/LaunchAgents folder.

Example Launch Agent.

Here is an example of a Launc Agent file that imports screenshots i've taken into my photo library using Apples Shortcuts Application with this shortcut.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
  <dict>
     <key>Label</key>
     <string>nl.wesleydegroot.ImportScreenshotsShortcut</string>
     <key>ProgramArguments</key>
     <array>
        <string>/usr/bin/shortcuts</string>
        <string>run</string>
        <string>Import Screenshots</string>
     </array>
     <key>RunAtLoad</key>
     <true />
     <key>StandardErrorPath</key>
     <string>/dev/null</string>
     <key>StandardOutPath</key>
     <string>/dev/null</string>
     <key>StartInterval</key>
     <integer>30</integer>
  </dict>
</plist>

This file is saved as ~/Library/LaunchAgents/nl.wesleydegroot.ImportScreenshotsShortcut.plist and is loaded using launchctl load ~/Library/LaunchAgents/nl.wesleydegroot.ImportScreenshotsShortcut.plist.

Explanation of the keys in the Property List:

Label: A unique identifier for the item.
ProgramArguments: The command to run when the item needs to be started.
RunAtLoad: Whether the item should be started when the system starts.
StandardErrorPath: The file to write standard error output to. (/dev/null means discard the output).
StandardOutPath: The file to write standard output to. (/dev/null means discard the output).
StartInterval: The interval at which the item should be started (in seconds).

Extra facts

Background items are mostly controlled using Property Lists traditionally installed in LaunchAgents and LaunchDaemons folders.
You can use the launchctl command-line tool to manage background items.
You can use the Activity Monitor app to see which apps are running in the background and how much system resources they are using.

Exploring ControlGroup in SwiftUI

Fri, 17 Oct 2025 22:37:15 +0200

In SwiftUI, a ControlGroup provides a way to visually group controls together, making your UI more intuitive and structured. It helps you present related controls in a unified manner, enhancing the user experience by logically grouping similar actions.

Syntax Overview

Here's a basic example of how to use a ControlGroup:

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            ControlGroup {
                Button("Action 1") {
                    // Action 1 code
                }
                Button("Action 2") {
                    // Action 2 code
                }
            }
            .controlGroupStyle(.automatic)
        }
    }
}

In this example, we create a ControlGroup inside a VStack, containing two buttons. The .controlGroupStyle(.automatic) modifier ensures that the group adopts the appropriate style based on the context it's used in.

Customizing `ControlGroup`

While the automatic style is convenient, you can customize ControlGroup to match your app's design. SwiftUI offers different styles, such as navigation and compact.

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            ControlGroup {
                Button("Action 1") {
                    // Action 1 code
                }
                Button("Action 2") {
                    // Action 2 code
                }
            }
            .controlGroupStyle(.navigation)
        }
    }
}

In the example above, we use .controlGroupStyle(.navigation) to give the control group a navigation-based appearance, suitable for toolbar items.

Practical Example

Consider an app where users frequently perform text formatting actions. You can use a ControlGroup to group formatting buttons together, providing a clean and organized interface:

import SwiftUI

struct FormattingView: View {
    var body: some View {
        VStack {
            Text("Formatted Text")
                .font(.title)

            ControlGroup {
                Button(action: boldText) {
                    Image(systemName: "bold")
                }
                Button(action: italicizeText) {
                    Image(systemName: "italic")
                }
                Button(action: underlineText) {
                    Image(systemName: "underline")
                }
            }
            .controlGroupStyle(.menu)
        }
    }

    func boldText() {
        // Bold text code
    }

    func italicizeText() {
        // Italicize text code
    }

    func underlineText() {
        // Underline text code
    }
}

.menu:

.compactMenu

In this FormattingView, we group three formatting actions—bold, italic, and underline—using ControlGroup with a .menu / .compactMenu style, making the actions easily accessible and visually appealing.

Interesing Use Cases

Control groups work great on (context) menu's, see the following example:

import SwiftUI

struct ContextMenuView: View {
    var body: some View {
        VStack {
            Text("Right-click (or long press) to show context menu")
                .contextMenu {
                    ControlGroup {
                        Button {
                             // Cut action
                        } label: {
                             Label("Cut", systemImage: "scissors")
                        }

                        Button {
                            // Copy action
                        } label: {
                            Label("Copy", systemImage: "doc.on.doc")
                        }

                        Button {
                            // Paste action
                        } label: {
                            Label("Paste", systemImage: "doc.on.clipboard")
                        }
                    }
                }
        }
    }
}

Conclusion

ControlGroup is a powerful feature in SwiftUI that enhances the organization of controls in your app. By logically grouping related actions, you can improve the user experience and create a more intuitive interface. Experiment with different control group styles to find the best fit for your app's design.

Expressible Literals

Fri, 17 Oct 2025 22:37:15 +0200

Expressible Literals in Swift are a powerful feature that allows you to create custom types that can be initialized using literals.
This post will show you how to create your own custom types that can be initialized using literals.

What is a literal?

A literal is a notation for representing a fixed value such as integers, strings, and booleans.
Literals in Swift are made possible by several available protocols.
Standard types conform to these protocols and allow us to initialize values as follows:

var integer = 0 // ExpressibleByIntegerLiteral
var string = "Hello!" // ExpressibleByStringLiteral
var array = [0, 1, 2] // ExpressibleByArrayLiteral
var dictionary = ["Key": "Value"] // ExpressibleByDictionaryLiteral
var boolean = true // ExpressibleByBooleanLiteral

How to create a custom type that can be initialized using literals

// ExpressibleBy..Literal protocol is used to create custom types that can be initialized using literals
extension CLASS: ExpressibleByStringLiteral {
    // Required initializer for ExpressibleBy...Literal
    public init(stringLiteral value: String) {
        // Initialize the class with the ... value
        self.init(value)
    }
}

Example 1: Image

Before:

import SwiftUI

let myImage = Image(named: "imageName")

Using ExpressibleByStringLiteral:

import SwiftUI
extension Image: ExpressibleByStringLiteral {
    public init(stringLiteral value: String) {
        self.init(value)
    }
}

let myImage: Image = "imageName"

Example 2: URL

Before:

let myURL = URL(string: "https://wesleydegroot.nl")

Using ExpressibleByStringLiteral:

extension URL: ExpressibleByStringLiteral {
    public init(stringLiteral value: String) {
        self.init(string: value)!
    }
}

let myURL: URL = "https://wesleydegroot.nl"

Example 3: Date

Before:

let formatter = DateFormatter()
formatter.dateFormat = "dd-MM-yyyy"
formatter.locale = Locale(identifier: "en_US_POSIX")
formatter.timeZone = TimeZone(secondsFromGMT: 0)

let date = formatter.date(from: "03-08-1990")
print(date) // Prints: 1990-08-03 00:00:00 +0000

Using ExpressibleByStringLiteral:

extension Date: ExpressibleByStringLiteral {
    public init(stringLiteral value: String) {
        let formatter = DateFormatter()
        formatter.dateFormat = "dd-MM-yyyy"
        formatter.locale = Locale(identifier: "en_US_POSIX")
        formatter.timeZone = TimeZone(secondsFromGMT: 0)
        self = formatter.date(from: value)!
    }
}

let date: Date = "03-08-1990"
print(date) // Prints: 1990-08-03 00:00:00 +0000

Conclusion

Expressible Literals in Swift are a powerful feature that allows you to create custom types that can be initialized using literals.

Resources:

JavaScriptCore

Fri, 17 Oct 2025 22:37:16 +0200

Whether you love it or hate it, JavaScript has become the most important language for developers in the world today. Yet despite any efforts we may take to change or replace it we’d be hard-pressed to deny its usefulness.

What is `JavaScriptCore`?

JavaScriptCore is a framework that provides a JavaScript engine for macOS and iOS. It allows developers to run JavaScript code within their applications. JavaScriptCore is a part of the WebKit framework and is used by Safari, Mail, and many other applications on macOS and iOS.

JavaScriptCore / Objective-C / Swift Types

JavaScriptCore uses a set of types to represent JavaScript values in Objective-C and Swift. These types are used to interact with JavaScript code and pass values between JavaScript and native code.
Here is a table that shows the mapping between JavaScript types and Objective-C/Swift types:

JavaScript Type	JSValue method	Objective-C Type	Swift Type
string	toString	NSString	String!
boolean	toBool	BOOL	Bool
number	toNumber	NSNumber	NSNumber!
number	toDouble	double	Double
number	toInt32	int32_t	Int32
number	toUInt32	uint32_t	UInt32
date	toDate	NSDate	Date?
array	toArray	NSArray	[Any]!
object	toDictionary	NSDictionary	[AnyHashable: Any]!
class	toObject	custom type	custom type

Simple Example

Here’s a simple example that evaluates a JavaScript expression and prints the result:

import JavaScriptCore

let context = JSContext()!
let result = context.evaluateScript("1 + 2 + 3")
result?.toInt32() // 6

Handling Exceptions

If a script throws an exception, JavaScriptCore calls the exception handler you provide. The handler receives the context and the exception object, which you can use to get the exception message.
below is an example how to create an exception handler:

import JavaScriptCore

let context = JSContext()!
context.exceptionHandler = { context, exception in
    print(exception!.toString())
}

context.evaluateScript("**INVALID**")
// Prints "SyntaxError: Unexpected token '**'"

Note: You can’t tell whether a script evaluated successfully based on its return value. For instance, both variable assignment and syntax errors produce undefined return values.

(Hacky) Way to dertimine if a script was evaluated successfully

If we want to determine if a script was evaluated successfully, we can set a variable in the script and then check if that variable exists in the context.
if the variable exists, the script was evaluated successfully.

import JavaScriptCore

let context = JSContext()!
let result = context.evaluateScript("1 + 2 + 3; var didRun = true;")
let didRun = context.objectForKeyedSubscript("didRun")?.toBool()

Virtual Machines and Contexts

JavaScriptCore uses a virtual machine to manage memory and resources. A virtual machine can have multiple contexts, each of which is a separate JavaScript environment. Contexts are isolated from each other, so they can’t share variables or functions.

let queue = DispatchQueue(label: "myVirtualMachineQueue")
let vm = queue.sync { JSVirtualMachine()! }
let context = JSContext(virtualMachine: vm)!

Creating a function in JavaScript

JavaScript evaluation isn’t limited to single statements. When you evaluate code that declares a function or variable, it’s saved into the context’s object space.

context.evaluateScript("""
function twoTimes(number) {
    return number * 2;
}
""")

context.evaluateScript("twoTimes(5)")?
       .toInt32() // 10

Getting JavaScript Context Values from Swift

You can access named values from a JSContext by calling the objectForKeyedSubscript(_:) method. This method returns a JSValue object that represents the value in the context.

context.evaluateScript("var twoTimesFive = twoTimes(5)")

context.objectForKeyedSubscript("twoTimesFive")?
       .toInt32() // 10

Setting Swift Values on a JavaScript Context

You can set a Swift value in a JSContext by calling the setObject(_:forKeyedSubscript:) method. This method creates a new variable in the context with the given name and value.

context.setObject(10, forKeyedSubscript: "swiftValue")

context.evaluateScript("swiftValue")?
       .toInt32() // 10

Passing Functions between Swift and JavaScript

You can pass Swift functions to JavaScript by creating a JSValue object from a block. This object can be called from JavaScript as if it were a regular JavaScript function.

let swiftFunction: @convention(block) (Int) -> Int = { 
    return $0 * 2
}
let jsFunction = JSValue(object: swiftFunction, in: context)
context.setObject(swiftFunction,
                  forKeyedSubscript: "swiftFunction" as NSString)

context.evaluateScript("swiftFunction(5)")?
       .toInt32() // 10

context.objectForKeyedSubscript("swiftFunction")?
       .call(withArguments: [6]) // 12

Passing Swift Objects between Swift and JavaScript

To improve interoperability between language contexts, JavaScriptCore provides the JSExport protocol, which allows native classes to be mapped and initialized directly.

import JavaScriptCore

@objc protocol MyExport: JSExport {
    var value: Int { get set }
    func doubleValue() -> Int
    func doubleTheValue(value: Int) -> Int
}

class MyObject: NSObject, MyExport {
    var value: Int = 0

    func doubleValue() -> Int {
        return value * 2
    }

    func doubleTheValue(value: Int) -> Int {
        return value * 2
    }
}

let context = JSContext()!
context.setObject(
    MyObject.self, 
    forKeyedSubscript: "myObject" as NSString
)

context.evaluateScript("""
var obj = new myObject();
obj.value = 5;
obj.doubleValue(); // 10
""")

context.evaluateScript("""
myObject.doubleTheValue(5) // 10
""")

Conclusion

JavaScriptCore is a powerful framework that allows you to run JavaScript code within your applications.
JavaScriptCore provides a simple API for evaluating JavaScript code, handling exceptions, creating functions, and passing values between Swift and JavaScript. By using JavaScriptCore, you can add dynamic scripting capabilities to your applications and create powerful, interactive user experiences.

Resources:

MacOS Terminal Commands

Fri, 17 Oct 2025 22:37:16 +0200

In this post i'll show you my favorite macOS terminal commands that i use often or find interesting.
This blog post is a different kind of post than i usually write, but i hope you like it.

Enable/Disable beta updates

Description	Command
Enroll developer seed	`sudo /System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil enroll DeveloperSeed`
Enroll public seed	`sudo /System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil enroll PublicSeed`
Unenroll seeds (stop receiving beta updates)	`sudo /System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil unenroll`

* This command stopped working as of MacOS 13.4.

Xcode

Description	Command
Debug/Internal Xcode	`defaults write com.apple.dt.Xcode ShowDVTDebugMenu -bool YES` `sudo mkdir -p /Applications/Xcode.app/Contents/Developer/AppleInternal/Library/Xcode/` `sudo touch /Applications/Xcode.app/Contents/Developer/AppleInternal/Library/Xcode/AppleInternal.plist`
Disable Xcode Cloud	`defaults write com.apple.dt.Xcode XcodeCloudUpsellPromptEnabled -bool false`
Use 4 spaces for indentation	`defaults write com.apple.dt.Xcode DVTTextIndentWidth -int 4`
Use spaces instead of tabs	`defaults write com.apple.dt.Xcode DVTTextIndentUsingTabs -bool NO`
Show the sidebar for indentation depth	`defaults write com.apple.dt.Xcode DVTTextShowFoldingSidebar -bool YES`
Show the full stack trace in the sidebar	`defaults write com.apple.dt.Xcode IDEAlwaysShowCompressedStackFrames -bool NO`
Show file extensions	`defaults write com.apple.dt.Xcode IDEFileExtensionDisplayMode -int 1`
Show up to 30 lines of detail in the issue navigator	`defaults write com.apple.dt.Xcode IDEIssueNavigatorDetailLevel -int 30`
Show up to 30 lines of detail when searching	`defaults write com.apple.dt.Xcode IDESearchNavigatorDetailLevel -int 30`
Show the build number in the app icon	`defaults write com.apple.dt.Xcode DVTEnableDockIconVersionNumber -bool YES`
Does the above, and show a debug menu, but useless because of the above an the latter has more checks	`defaults write com.apple.dt.Xcode ShowDVTDebugMenu -bool YES`
Show details on indexing progress	`defaults write com.apple.dt.Xcode IDEIndexerActivityShowNumericProgress -bool true`

Simulator

Description	Command
Show touches simulator	`defaults write com.apple.iphonesimulator ShowSingleTouches 1`

Finder

Description	Command
Enable display of filename extensions	`defaults write NSGlobalDomain AppleShowAllExtensions -bool true`
Disable the warning when changing a file extension	`defaults write com.apple.finder FXEnableExtensionChangeWarning -bool false`
Show hidden files by default	`defaults write com.apple.Finder AppleShowAllFiles -bool true`
Disable smart quotes and smart dashes they are annoying when typing code	`defaults write NSGlobalDomain NSAutomaticQuoteSubstitutionEnabled -bool false` `defaults write NSGlobalDomain NSAutomaticDashSubstitutionEnabled -bool false`
Open finder window in ~/Developer	`defaults write com.apple.finder NewWindowTargetPath -string "file://$HOME/Developer/"`
Finder in column view	`defaults write com.apple.finder FXPreferredViewStyle Clmv`
Allow text selection in Quick Look	`defaults write com.apple.finder QLEnableTextSelection -bool TRUE`
Check for software updates daily, not just once per week	`defaults write com.apple.SoftwareUpdate ScheduleFrequency -int 1`
Setting screenshots location to ~/Desktop/screenshots	`defaults write com.apple.screencapture location -string "$HOME/Desktop/screenshots"` I do this because i run a script that automatically imports screenshots to photos. LaunchAgent and [The shortcut][https://www.icloud.com/shortcuts/2c7c5cb4a4574437af66623b75521b16]
Setting screenshot format to PNG	`defaults write com.apple.screencapture type -string "png"`

Safari

Description	Command
Show the full URL in the address bar	`defaults write com.apple.Safari ShowFullURLInSmartSearchField -bool true`
Enable the Develop menu and the Web Inspector	`defaults write com.apple.Safari IncludeInternalDebugMenu -bool true` `defaults write com.apple.Safari IncludeDevelopMenu -bool true`
Enabling Safari's bookmarks bar by default	`defaults write com.apple.Safari ShowFavoritesBar -bool true`
Enable the Develop menu and the Web Inspector in Safari	`defaults write com.apple.Safari IncludeInternalDebugMenu -bool true` `defaults write com.apple.Safari IncludeDevelopMenu -bool true` `defaults write com.apple.Safari WebKitDeveloperExtrasEnabledPreferenceKey -bool true` `defaults write com.apple.Safari com.apple.Safari.ContentPageGroupIdentifier.WebKit2DeveloperExtrasEnabled -bool true`
Add a context menu item for showing the Web Inspector in web views	`defaults write NSGlobalDomain WebKitDeveloperExtras -bool true`
Warn about fraudulent websites	`defaults write com.apple.Safari WarnAboutFraudulentWebsites -bool true`
Enable “Do Not Track”	`defaults write com.apple.Safari SendDoNotTrackHTTPHeader -bool true`
Update extensions automatically	`defaults write com.apple.Safari InstallExtensionUpdatesAutomatically -bool true`
Do not automatically open "safe" files after downloading	`defaults write com.apple.Safari AutoOpenSafeDownloads -bool false`

Photos

Description	Command
Prevent Photos from opening automatically when devices are plugged in	`defaults -currentHost write com.apple.ImageCapture disableHotPlug -bool true`

Mission Control

Description	Command
Bottom left screen corner → Put to sleep	`defaults write com.apple.dock wvous-bl-corner -int 10`
Bottom right corner → do nothing	`defaults write com.apple.dock wvous-bl-modifier -int 0`

(0: no-operation, 2: Mission Control, 3: Show application windows, 4: Desktop, 5: Start screen saver, 6: Disable screen saver, 7: Dashboard, 10: Put display to sleep, 11: Launchpad, 12: Notification Center, 13: Lock Screen)

AppKit

Description	Command
Show an internal AppKit debug menu	`defaults write -g _NS_4445425547 -bool YES`

Terminal

Description	Command
Making macOS Terminal use case-insensitive autocomplete	add `zstyle ':completion:' matcher-list '' 'm:{a-zA-Z}={A-Za-z}' 'r:\|=' 'l:\|=* r:\|=*' autoload -Uz compinit && compinit` to your `~/.zshrc` file. [from: Daniel Saidi.

NavigationStack

Fri, 17 Oct 2025 22:37:17 +0200

NavigationStack is a SwiftUI view that provides a navigation stack for macOS and iOS.
Navigation was done using NavigationView, but it was deprecated in iOS 16 and was split into two new containers, NavigationStack and NavigationSplitView, and each one of them has new features.

What is `NavigationStack`?

NavigationStack is a way to manage navigation within a SwiftUI application.
It provides a stack-based navigation system that allows you to push and pop views onto and off of the navigation stack.
This makes it easy to create complex navigation flows in your application.

Requirements

iOS 16.0+, iPadOS 16.0+, Mac Catalyst 16.0+, macOS 13.0+, tvOS 16.0+, visionOS 1.0+, watchOS 9.0+

Key Features of NavigationStack

Declarative Syntax: Like all SwiftUI components, NavigationStack uses a declarative syntax, making it easy to define the navigation flow in your app.
State Management: It integrates seamlessly with SwiftUI's state management, allowing you to control the navigation stack based on your app's state.
Custom Transitions: You can customize the transitions between views, providing a more engaging user experience.
Deep Linking: NavigationStack supports deep linking, enabling users to navigate directly to specific views within your app.

Navigate to a view

With NavigationStack, you can navigate to a view by appending a view to the navigation path.
This can be done programmatically by calling append on the NavigationPath object, or by using a Button or NavigationLink.

Button("Go to profile") {
    navPath.append("profile") // This will trigger navigationDestination(for: String.self)
    // You can also route it to a specific view by using a specific identifier like "profile/1" (see example 3)
}

Example 1

import SwiftUI

struct ContentView: View {
    @State
    private var navigationPath = NavigationPath()

    var body: some View {
        // For sake of this demo the button is directly in the navigation stack
        NavigationStack(path: $navigationPath) {
            Button("Open view with identifier qwerty") {
               navigationPath.append("qwerty") // This will trigger navigationDestination(for: String.self)
               // if you use a Int, it needs to be Int.self, and so on.
            }
            .navigationDestination(for: String.self) { identifier in
                YourView(withIdentifier: identifier)
            }
        }
    }
}

struct YourView: View {
    var identifier: String

    var body: some View {
        Text("Hello, \(identifier)!")
    }
}

Example 2 with pop to root

import SwiftUI

struct ContentView: View {
    @State
    private var navigationPath = NavigationPath()

    var body: some View {
        // For sake of this demo the button is directly in the navigation stack
        NavigationStack(path: $navigationPath) {
            Button("Open view with identifier qwerty") {
               navigationPath.append("qwerty")
            }
            .navigationDestination(for: String.self) { identifier in
                VStack { 
                    Text("Hello, \(identifier)!")

                    var random = Int.random(in: 0...100)
                    Button("Add view \(random)") {
                        navigationPath.append("Random View \(random)")
                    }
                    Button("Back") {
                        navigationPath.removeLast()
                    }
                    Button("Root View") {
                        navigationPath = NavigationPath()
                    }
                }
            }
        }
    }
}

Example Navigate to a view with a specific identifier

You can also navigate to a view with a specific identifier by appending the identifier to the navigation path.
This can be done programmatically by calling append on the NavigationPath object, or by using a Button or NavigationLink.


import SwiftUI

struct ContentView: View {
    @State
    private var navigationPath = NavigationPath()

    var body: some View {
        // For sake of this demo the button is directly in the navigation stack
        NavigationStack(path: $navigationPath) {
            BButton("Go to profile") {
                navigationPath.append("profile/1") // This will trigger navigationDestination(for: String.self)
            }
            .navigationDestination(for: String.self) { identifier in
                // Note: this is a simple example, in a real app you would probably want to use a switch statement or something similar to handle different identifiers.
                if identifier.hasPrefix("profile/") {
                    let profileID = identifier.replacingOccurrences(of: "profile/", with: "")
                    ProfileView(profileID: profileID)
                }
            }
        }
    }
}

Wrap up

NavigationStack is a powerful tool for managing navigation in your SwiftUI app, especially when you need to use routing and other advanced navigation features.

Credits

I created this article for a friend to help him to navigate in his Alzheimer’s Detection App.

Resources:

Build a personal brand as developer

Fri, 17 Oct 2025 22:37:18 +0200

Here are some tips to build a personal brand as a developer.

Define your brand

Start by defining your brand.

Who do you target.
What are your strengths and skills.
What are your values.
Where do you stand for.
What are your goals.

This will help you to create a consistent message and image.

Create an Online Presence

Create a portfolio

Build a professional website to showcase your projects, skills, and experiences.
It's the first place where potential employers or collaborators will look to understand what you can do.
Make sure it's clean, easy to navigate, and clearly highlights your best work.

(Optional) Create a blog

If you start a blog, you can share your thoughts, experiences, and knowledge with others.
It is also a great way to improve your experience on a certain topic, to write the blog post you need to understand the topic well, this is a win-win situation because you are helping others and you are helping yourself.

Be active on social media

Use platforms like Twitter, Mastodon, Threads, LinkedIn, and GitHub to share your projects, engage with the (developer) community, and build your network. Regularly post updates, share interesting articles, and don't be afraid to showcase your personality. People connect with people, not just code.

Share Content

Write blog posts, create tutorial videos, and contribute to open-source projects.
It's a great way to showcase your skills, share your knowledge, and build your reputation.

Network and Collaborate

Attend meetups, conferences, and hackathons to meet other developers, learn new things, and build relationships.

Brand Yourself

Create a logo, choose a color scheme, and use consistent fonts and styles across your website, social media profiles, and other online platforms.

Be yourself

Be true to yourself and your values, and don't try to be someone you're not.
Authenticity is key to building a strong personal brand.

Dare to ask for help

Don't be afraid to ask for help, advice, or feedback.
No one knows everything, asking for help is a sign of strength, not weakness.

AppDevCon 2025

Fri, 17 Oct 2025 22:37:18 +0200

AppDevCon is a conference for application developers, focusing on the latest trends and technologies in app development.

Below is a brief overview of some of the talks at the conference, with a small description of their talks.

ANTONIO MARKOTIĆ

CUT COSTS, NOT CORNERS – MASTER MODULARIZATION WITH SPM

In this talk, we will go through 4 chapters (origins, maze, metamorphosis, legacy) I faced when I refactored our Monolith iOS project using SPM and afterward – alongside my team members – figured a way to revolutionize the way we integrate Kotlin Multiplatform code with iOS code. And the craziest part – no feature development was put on hold along this process. That’s kind of impressive, but I lied about it being the craziest part. The results we achieved are even crazier:

55% reduction in local clean build time
43% reduction in local incremental build time
73% reduction in CI/CD build time.

You will walk away with specific steps on how to modularize your Monolithic project with SPM, which traps to avoid, and how to maintain it moving forward. And if you are using KMM in your iOS project, you might just find out how to drastically improve the integration of it.

Whether you’re an engineer, a team lead, or a CTO, this talk promises not only to enlighten but also to inspire your next big move.

Video: https://vimeo.com/1097833727?fl=pl&fe=vl

BRUNO SCHEELE

GETTING YOUR APP READY FOR EU’S ACCESSIBILITY LAWS

Allowing everyone to be able to use your app without compromises is becoming increasingly important, for inclusivity, market and legal reasons. Especially with the new European laws about app accessibility taking effect in 2025, you may be scrambling to get your app in order.

In this talk, I explain what the European app accessibility laws mean in practical terms, how an organization can get started on making their apps comply and will illustrate some minor and major pitfalls they may encounter along the way. My goal is to help organizations get started on improving their apps’ accessibility, so that no one has to feel left behind while using them.

Video: https://vimeo.com/1097839086?fl=pl&fe=vl

TOM LOKHORST & MATHIJS KADIJK

FROM FRAMES TO FILES – BUILDING VIDEO WITH SWIFT

We use video everyday, but have you ever wondered how it actually works? How can we turn a bunch of pixels into moving pictures that we can see on screen, store in a file or transmit over the network? In this talk we’ll take a look at the history of video and build our own video from the ground up using only Swift. Then we’ll turn big uncompressed images, into small useable files using different Apple APIs.

Video: https://vimeo.com/1097833348?fl=pl&fe=vl

ROB WHITAKER

TOUCH-FREE TOUCH SCREENS

iOS devices are the pinnacle of touch screen technology. Capacitive multi-touch on the original iPhone was what really set the device apart from anything that had come before and helped make the iPhone the most successful consumer product ever made. But touch isn’t the only way to interact with iOS. Keyboards, Mice, your voice, even moving your eyes, offer your users options to make their device and your apps work for them. And for some people with limb differences or motor disabilities these options are essential. A third of people with a physical disability report they are unable to complete basic digital tasks, more than 3 times that of people without a disability.
So how do people who don’t have the dexterity required to use a touch screen interact with a device where touch is the primary input? And what simple changes can we make as app developers to remove barriers for them? This talk will give you the tools to build and test touch screen apps for non-touch users.

Video: https://vimeo.com/1097832577?fl=pl&fe=vl

Fun Fact.

GameControllerKit is mentioned in the talk of Rob Whitaker!

View the schedule of 2025 here

https://appdevcon.nl/schedule-2025/

Fixing slow scrolling in Calendo

Fri, 17 Oct 2025 22:37:19 +0200

In this post, I'll go through the steps which i took to fix a bug with slow scrolling in Calendo.
Interested in the development of Calendo? Read my previous post about Building Calendo or search on the Tag: Calendo.

What was the problem?

When you scrolled the calendar in Calendo, the scrolling was slow and laggy.
This was a problem because it made the app feel unresponsive and slow.

In this post, I explain how I fixed this problem and which steps I have taken to fix this.

Debugging... (pre-release)

first suspect: The ScrollView

The ScrollView contains a list with appointments (-1 month to +1 month) from the currently selected month.
The cells where build like this:

┌──────────────────────────────────┐
│ Date string              ┌─────┐ │
│ Appointment title        │ MAP │ │
│ Appointment Address      └─────┘ │
└──────────────────────────────────┘

I was thinking that the MapView was causing the issue, because it was loading the map every time the cell was shown.

second suspect: The CalendarView

Is the CalendarView causing the issue?
The CalendarView is pretty easy, it's just a grid with the days of the month, and a small circle that indicates the amount of appointments on that day.
This can't be the issue.

Partial solution (pre-release)

I ended up removing the MapView, to increase the speed on older devices, it did not had the magical effect that I was hoping for, but at that moment I was thinking, every little bit helps.

The New Appointment cell looked like this:

┌──────────────────────────────────┐
│ Date string                      │
│ Appointment title                │
│ Appointment Address              │
└──────────────────────────────────┘

Debugging...

Or actually thinking, because I had no points to investigate, or maybe a better explanation, I had no idea where to start.

Too much appointments?
Could the issue be that there are too many appointments in the calendar?
Is the day indicator causing the issue?
The day indicator is a small circle that shows the current day in the calendar. Could this be causing the issue?
If the day indicator is hidden, scrolling is snappy and fast, this is what made me think that the day indicator was causing the issue.

Problem avoiding

Rebuilt CalendarView
This improved the performance a little bit, but not enough to make it feel snappy.
Added a setting to disable certain calendars.
This made loading faster if you had a lot of calendars, but it did not solve the issue.
Added a setting to disable the day indicator.
This made the scrolling snappy and fast, but it was not a solution, because the day indicator is a key feature in the calendar.

Bonus find

Sometimes EKEventStore was complaining that i was running to much connections to the calendar.
After some investigation, I found out that I was constantly re-initializing the EKEventStore (when Mocking the calendar), I fixed this to make a global variable to store the EKEventStore in memory.

This was as simple as:

/// Global event store
public let globalEventStore = EKEventStore()

More Debugging...

first suspect: The ScrollView

I tried to fire notifications instead of updating the @State/@EnvironmentObject in the ScrollView cells, this did not solve the issue.

second suspect: The CalendarView

I was too focused on the day indicator (I did not see the real issue)

third suspect: The CalendarView day indicator

I was thinking that the day indicator was causing the issue, because when I disabled the day indicator, the scrolling was fast and snappy.
Below the day(number) in the month, there is a small circle that indicates the amount of appointments on that day.

For debugging purposes, i was thinking maybe the issue is that I look up the appointments on the main thread, so i added this little piece of code to the CalendarView's cell:

extension Date {
    var appointments: [Color] {
        let eventStore = globalEventStore
        var events: [Color] = []

// DEBUG CODE START
#if targetEnvironment(simulator) 
        for _ in 0...Int.random(in: 0...3) {
            events.append(
                Color.init(cgColor: Color.random.cgColor!)
            )
        }
        return events
#endif
// DEBUG CODE END

        /// Some code to get the appointments
        return events
    }
}

Something strange happend, every time I scrolled the calendar, the colors where changing, this was not what I was expecting, because the appointments should be the same every time I scroll the calendar.

Solution

var appointmentStore: [Date: [Color]] = [:]

extension Date {
    var appointments: [Color] {
        if let appointments = appointmentStore[self] {
            return appointments
        }

        let eventStore = globalEventStore
        var events: [Color] = []

        /// Some code to get the appointments
        appointmentStore[self] = events
        return events
    }
}

Conclusion

The solution was to cache the appointments for each day in the month, this made the scrolling fast and snappy.
I learned that you should not focus on one thing, but look at the bigger picture, and try to find the root cause of the issue.
I stared myself blind on the day indicator, but the real issue was the appointments that where loaded every time the cell was shown.

I hope this post helps you to find the root cause of your issue, and that you can fix it as well.

Download Calendo

You can download Calendo from the AppStore!.

Dutch.swift

Fri, 17 Oct 2025 22:37:19 +0200

For april fools day, I wanted to write a Swift library that allows you to write Swift code in Dutch. It's called Dutch.swift and it's available on GitHub. Unfortunately it didn't work out in the way I wanted it to, but I still wanted to share it with you.
There is a way to get the idea i had in mind to work, but it required me to write a transpiler which converted the dutch code to swift code. This was not what I had in mind, so I decided to not go that route.

I still want to share this with you:

import Dutch

let tekst: Tekst = "Hallo, Wereld!"

if true == waar {
    print(tekst)
}

zolang(true) { // while(true), Unfortunatly this needs parentheses
    print(tekst)
}

als(waar) { // if(waar), Unfortunatly this needs parentheses
    print(tekst)
}

I hope you like it! If you have any questions, feel free to ask me on the socials.

🦋 @0xWDG 🐘 mastodon.social/@0xWDG 🐦 @0xWDG 🧵 @0xWDG 🌐 wesleydegroot.nl 🤖 Discord

Building iWebTools

Fri, 17 Oct 2025 22:37:20 +0200

In this blog post I will show you how I build iWebTools.
iWebTools is a tool to check websites and use some tools like a JWT Decoder and a crontab converter.

Basic Design

I started with a basic design, I'm not really a designer so I tend to create simple designs.

Check Websites tab

For the check websites tab I wanted to have a list of websites with their status.
The status should be a colored dot, green for online and red for offline.
The user should be able to add a website to the list.

Design Result

Design	Result
Check Websites [+] ┌──────────────────────────────┐ \| https://mysite.com [add] \| ├──────────────────────────────┤ \| wesleydegroot.nl () ❯ \| \| 123.123.123.123 status^ \| ├──────────────────────────────┤ \| wdgwv.com () ❯ \| \| 123.123.123.123 status^ \| ├──────────────────────────────┤ \| apple.com () ❯ \| \| 123.123.123.123 status^ \| └──────────────────────────────┘


         Check Websites      [+]
┌──────────────────────────────┐
| https://mysite.com     [add] |
├──────────────────────────────┤
| wesleydegroot.nl        () ❯ |
| 123.123.123.123    status^   |
├──────────────────────────────┤
| wdgwv.com               () ❯ |
| 123.123.123.123    status^   |
├──────────────────────────────┤
| apple.com               () ❯ |
| 123.123.123.123    status^   |
└──────────────────────────────┘

Check Websites (in a website) tab

When the user clicks on a website, the user should see more information about the website.

Design Result

Design	Result
`https://wesleydegroot.nl ┌──────────────────────────────┐ \| Favicon - Site title \| \| Technology: Build with tech \| └──────────────────────────────┘` `┌──────────────────────────────┐ \| Validate HTML & CSS ❯ \| \| Debug Tools ❯ \| \| DOM Tree ❯ \| \| Check HTTP Headers ❯ \| \| DNS Entries ❯ \| \| Whois ❯ \| \| HTML Tag Usage ❯ \| \| Display HTML ❯ \| └──────────────────────────────┘`


    https://wesleydegroot.nl
┌──────────────────────────────┐
| Favicon - Site title         |
| Technology: Build with tech  |
└──────────────────────────────┘
┌──────────────────────────────┐

| Validate HTML & CSS        ❯ |

| Debug Tools                ❯ |

| DOM Tree                   ❯ |

| Check HTTP Headers         ❯ |

| DNS Entries                ❯ |

| Whois                      ❯ |

| HTML Tag Usage             ❯ |

| Display HTML               ❯ |

└──────────────────────────────┘

Check Websites: Whois

The Whois tab should show the whois information of the domain.
The user should be able to see the domain status, the DNSsec status, the creation date and the update date.

Design Result

Design	Result
`┌──────────────────────────────┐ \| Domain: wesleydegroot.nl \| \| Domain Status: Active \| \| DNSSec Status: yes \| \| Creation Date: 2015-10-16 \| \| Update Date: 2024-06-16 \| \| RAW Whois ❯ \| └──────────────────────────────┘`


┌──────────────────────────────┐
| Domain:     wesleydegroot.nl |
| Domain Status:        Active |
| DNSSec Status:           yes |
| Creation Date:    2015-10-16 |
| Update Date:      2024-06-16 |
| RAW Whois                  ❯ |
└──────────────────────────────┘

Tools tab

The tools tab should have a list of tools, the user should be able to select a tool.
The tools should be categorized in groups.

Design Result

Design	Result
Tools HTTP ┌──────────────────────────────┐ \| HTTP Status codes ❯ \| \| HTTP Request ❯ \| └──────────────────────────────┘ Converters ┌──────────────────────────────┐ \| Crontab converter ❯ \| \| Color converter ❯ \| └──────────────────────────────┘ Formatters ┌──────────────────────────────┐ \| JSON Formatter ❯ \| └──────────────────────────────┘ Encoders/Decoders ┌──────────────────────────────┐ \| Base64 ❯ \| \| JWT Decoder ❯ \| \| URL ❯ \| └──────────────────────────────┘


             Tools
HTTP
┌──────────────────────────────┐
| HTTP Status codes          ❯ |
| HTTP Request               ❯ |
└──────────────────────────────┘


Converters
┌──────────────────────────────┐
| Crontab converter          ❯ |
| Color converter            ❯ |
└──────────────────────────────┘


Formatters
┌──────────────────────────────┐
| JSON Formatter             ❯ |
└──────────────────────────────┘


Encoders/Decoders
┌──────────────────────────────┐
| Base64                     ❯ |
| JWT Decoder                ❯ |
| URL                        ❯ |
└──────────────────────────────┘

About tab

The about/settings tab is a modern design, which looks like a settings page.
The user should be able to rate the app, give feedback, read the privacy policy and see the changelog.

Design Result

Design	Result
About ┌──────────────────────────────┐ \| LOGO \| \| LOGO \| \| LOGO \| \| iWebTools \| \| Created by Wesley de Groot \| └──────────────────────────────┘ ⊡ Application ┌──────────────────────────────┐ \| Changelog ❯ \| \| Privacy policy \| \| Rate the app \| \| Feedback \| └──────────────────────────────┘ `⊡ About the developer ┌──────────────────────────────┐ \| X/Twitter \| \| Bluesky \| \| Mastodon \| \| More apps from the developer \| └──────────────────────────────┘`

Tool: JWT Decoder

The JWT Decoder is a tool to convert a crontab to a human readable format.
This was a harder tool to build, because i wanted to have (syntax) highlighting in the input and output.

To do this, I used a ZStack to overlay the TextField with the highlighted text.
The TextField is above the highlighted text, so the user can still edit the text.
In the code below I'll explain how I did it.

import SwiftUI

struct JWTView: View {
    // Save the JWT Token
    @State private var JWTToken = ""

    var body: some View {
        List {
            Section("Input") {
                // ZStack is used to overlay the textfield with the highlighted text
                ZStack {
                    // Hightlighted text
                    Highlight(text: $JWTToken)

                    // The textfield is above the highlighted text
                    // so the user can still edit the text
                    TextField(
                        "JWT Token",
                        text: $JWTToken,
                        axis: .vertical
                    )
                    // The line limit is set to 5, so the textfield
                    // will not grow, and the space will be reserved
                    .lineLimit(5, reservesSpace: true)
                    // Since we don't want this text field to be shown,
                    // we set the background and foreground color to clear
                    .background(Color.clear)
                    .foregroundStyle(.clear)
                }
            }
        }
    }


    @ViewBuilder
    func Highlight(text: Binding<String>) -> some View {
        // Split the JWT Token into 3 parts
        let tokenData = JWTToken.components(separatedBy: ".")

        // Check if the token is not empty and has 3 parts
        if !JWTToken.isEmpty, tokenData.count == 3 {
            // Create a group to combine the 3 parts
            Group {
                if #available(iOS 17.0, *) {
                    // Part 1 is red
                    Text(tokenData[0])
                        .foregroundStyle(.red)
                    + Text(".") +
                    // Part 2 is purple
                    Text(tokenData[1])
                        .foregroundStyle(.purple)
                    + Text(".") +
                    // Part 3 (Signature) is blue
                    Text(tokenData[2])
                        .foregroundStyle(.blue)
                } else {
                    // No iOS 17.0, so we use the fallback
                    FallbackView(text: text)
                }
            }
            // The line limit is set to 5, so the line
            // will not grow, and the space will be reserved
            .lineLimit(5, reservesSpace: true)
            // The text is aligned to the leading side (left) in most cases
            .multilineTextAlignment(.leading)
            // Make the text fill the width of the screen
            .frame(maxWidth: .infinity, alignment: .leading)
        } else {
            // The token is empty or has less/more than 3 parts
            FallbackView(text: text)
        }
    }

    @ViewBuilder
    func FallbackView(text: Binding<String>) -> some View {
        Text(text.wrappedValue)
            // The line limit is set to 5, so the line
            // will not grow, and the space will be reserved
            .lineLimit(5, reservesSpace: true)
            // The text is aligned to the leading side (left) in most cases
            .multilineTextAlignment(.leading)
            // Make the text fill the width of the screen
            .frame(maxWidth: .infinity, alignment: .leading)
    }

Click here to see the end result (screenshot)

Tool: crontab converter

The crontab converter is a tool to convert a crontab to a human readable format.
I made this tool also available as a open source project on GitHub, so other developers can use it in their projects.
The code below is a fully working example of the crontab converter and how to use the SwiftCronParser library, this is used in iWebtools.

import SwiftUI
import SwiftCronParser

struct CronConverterView: View {
    /// The input text
    @State
    private var cronText = ""

    /// The parsed cron time/converted data
    @State
    private var cronTime: SwiftCronParser.CronTime?

    var body: some View {
        List {
            VStack(alignment: .leading) {
                ZStack {
                    Highlight(text: $cronText)
                        .padding(2)
                        .monospaced()

                    TextField(
                        "Cron text",
                        text: $cronText
                    )
                    .padding(2)
                    .monospaced()
                    .lineLimit(1, reservesSpace: true)
                    .background(Color.clear)
                    .foregroundStyle(.clear)
                }
                .border(.black, width: 1)

                Text("Format: Minute Hour Day Month Weekday")
                    .monospaced()
                    .lineLimit(1)
                    .font(.footnote)
            }

            Section("Translated") {
                // Check if the cron time is not nil (we habe parsed the value)
                if let cronTime,
                    // Check if there is no error
                    cronTime.error == nil,
                    // Check if the cron time is valid
                    cronTime.isValid {
                    LabeledContent(
                        "Hour",
                        value: "\(cronTime.hour.map { String($0) }.joined(separator: ","))"
                    )
                    .foregroundStyle(.red)
                    LabeledContent(
                        "Minute",
                        value: "\(cronTime.minute.map { String($0) }.joined(separator: ","))"
                    )
                    .foregroundStyle(.purple)
                    LabeledContent(
                        "Day",
                        value: "\(cronTime.day.map { String($0) }.joined(separator: ","))"
                    )
                    .foregroundStyle(.blue)
                    LabeledContent(
                        "Month",
                        value: "\(cronTime.months.joined(separator: ", "))"
                    )
                    .foregroundStyle(.green)
                    LabeledContent(
                        "Day of week",
                        value: "\(cronTime.daysOfWeek.joined(separator: ", "))"
                    )
                    .foregroundStyle(.orange)
                } else {
                    if !cronText.isEmpty, let error = cronTime?.error {
                        Text(error)
                    }
                }
            }
        }
        .onChange(of: cronText) { val in
            // When the cron text changes, we parse the text
            cronTime = SwiftCronParser(input: cronText).parse()
        }
        .task {
#if DEBUG
            // If we are in debug mode, we set the cron text to a default value
            // so we can test the converter without typing
            cronText = "5 4 * * *"
            cronTime = SwiftCronParser(input: cronText).parse()
#endif
        }
        .navigationTitle("Crontab Converter")
        .navigationBarTitleDisplayMode(.inline)
    }

    // Here we do the same as in the JWT Decoder
    // We highlight if the input can be separated by a space into 5 parts
    @ViewBuilder
    func Highlight(text: Binding<String>) -> some View {
        let tokenData = text.wrappedValue.components(separatedBy: " ")
        if !text.wrappedValue.isEmpty,
           tokenData.count == 5 {
            Group {
                if #available(iOS 17.0, *) {
                    Text(tokenData[0])
                        .foregroundStyle(.red)
                    + Text(" ") +
                    Text(tokenData[1])
                        .foregroundStyle(.purple)
                    + Text(" ") +
                    Text(tokenData[2])
                        .foregroundStyle(.blue)
                    + Text(" ") +
                    Text(tokenData[3])
                        .foregroundStyle(.green)
                    + Text(" ") +
                    Text(tokenData[4])
                        .foregroundStyle(.orange)
                } else {
                    FallbackView(text: text)
                }
            }
            .lineLimit(1, reservesSpace: true)
            .multilineTextAlignment(.leading)
            .frame(maxWidth: .infinity, alignment: .leading)
        } else {
            FallbackView(text: text)
        }
    }

    @ViewBuilder
    func FallbackView(text: Binding<String>) -> some View {
        Text(text.wrappedValue)
            .lineLimit(1, reservesSpace: true)
            .multilineTextAlignment(.leading)
            .frame(maxWidth: .infinity, alignment: .leading)
    }
}

Click here to see the end result (screenshot)

Download iWebTools

You can download iWebTools from the AppStore

Ideas

If you have any ideas for iWebTools, please let me know in the comments below!

NumberFormatter

Fri, 17 Oct 2025 22:37:20 +0200

NumberFormatter is a class that provides a flexible and easy way to convert numbers into strings and vice versa.
It is a part of the Foundation framework and is available on all Apple platforms.
In this post, we will explore the various ways in which we can use NumberFormatter to format numbers in Swift.

What Styles does `NumberFormatter` have?

Style	en_US Locale	nl_NL Locale	zh_CN Locale
NumberFormatter.Style.none	1235	1235	1235
NumberFormatter.Style.decimal	1,234.568	1.234,568	1,234.568
NumberFormatter.Style.percent	12%	12 %	12%
NumberFormatter.Style.scientific	1.2345678E3	1,2345678E3	1.2345678E3
NumberFormatter.Style.spellOut	one hundred twenty-three	honderddrieëntwintig	一百二十三
NumberFormatter.Style.ordinal	3rd	3e	第3
NumberFormatter.Style.currency	$1,234.57	€ 1.234,57	￥1,234.57
NumberFormatter.Style.currencyAccounting	($1,234.57)	(€ 1.234,57)	(￥1,234.57)
NumberFormatter.Style.currencyISOCode	USD1,234.57	EUR 1.234,57	CNY1,234.57
NumberFormatter.Style.currencyPlural	1,234.57 US dollars	1.234,57 euro	1,234.57 人民币

Force a specific locale

By default, NumberFormatter uses the current locale of the device.
You can force a specific locale by setting the locale property of the NumberFormatter class.

let numberFormatter = NumberFormatter()
numberFormatter.locale = Locale(identifier: "nl_NL")
print(numberFormatter.string(from: 1000)!) // prints "1000" in the Dutch locale

Use Cases

Formatting Numbers

One of the most common use cases for NumberFormatter is to format numbers.
This can be done using the numberStyle property of the NumberFormatter class.

let numberFormatter = NumberFormatter()
numberFormatter.numberStyle = .decimal
print(numberFormatter.string(from: 1000)!) // prints "1,000" in the US locale, "1000" in the Dutch locale

Number to Words (Spell Out)

Another case for NumberFormatter is to convert a number into a string.
This can be done using the string(from: Number) function.

let numberFormatter = NumberFormatter()
numberFormatter.numberStyle = .spellOut
print(numberFormatter.string(from: 1990)!) // prints "one thousand nine hundred ninety"

Currency

Another use case for NumberFormatter is to format numbers as currency. .
This can be done using the currencySymbol and currencyCode properties of the NumberFormatter class.

let numberFormatter = NumberFormatter()
numberFormatter.numberStyle = .currency
numberFormatter.currencyCode = "EUR"
print(numberFormatter.string(from: 10)!) // prints "€10.00"

Conclusion

NumberFormatter is a powerful class that provides a flexible and easy way to convert numbers into strings and vice versa.
It supports a wide range of styles and locales, making it suitable for a variety of use cases.
Whether you need to format numbers, convert numbers to words, or display numbers as currency, NumberFormatter has you covered.

Resources:

https://developer.apple.com/documentation/foundation/numberformatter

Tips and ideas to start your own blog

Fri, 17 Oct 2025 22:37:21 +0200

When I started this website on 03 February 2024 I was unsure if I would be able to keep it up. I had tried to start a blog some times before but I always struggled to keep it up. This time I take another approach and I am happy to say that I have been able to keep it up for over a year now. In this blog post I want to share some tips and ideas on how to start your own blog about Swift.

Benefits of having a blog

For me the benefits of writing blogs are:

Learning: I learn a lot by writing blogs. I have to research the topic, understand it and then write about it. This helps me to understand the topic better.
Sharing: I can share my knowledge with others. This is a great way to give back to the community.
(Private) problem and solution database: I can use my blog to search for problems you have solved in the past.
Networking: I can connect with other developers who are interested in the same topics.

Cons of having a blog

The only con I can think of is that it takes time. Writing a blog post takes time and effort. But I think the benefits outweigh the cons.

The system I use for blogging.

This will be discussed in a future blog post What powers this website.

Finding topics

When I started this blog I subscribed to a lot of other blogs to get email updates from them. If there is a topic that I find interesting I open a issue on Github, I add the category and a indication of the difficulty of the topic. I also add a link to the blog post that inspired me to write about it.
Another way for finding topics is, problems I have solved in the past, or new things I have learned.

Managing topics & time

I often dont feel like I want to write a blog post, but I have a schedule to keep up with (every Tuesday).
What I do is, I write blogs in advance, this post is made on 05-FEB-2025. I usually have for a couple of weeks in advance a blog post ready to be published.
I also have placeholders for some future posts, e.g. Hacktoberfest 2025 and some posts for Hacktoberfest about some Swift Packages I've created (ImagePicker, FilePicker, iCloudStorage, SecureStorage, XCUITestHelper, PreventScreenshot, NetworkMonitor, SwiftCronParser, SwiftExtras).

Creating a blog post

My target audience does not like reading (i think) and I don’t like writing, so keep it short and focused

I do think I'm still a beginner in blogging. I have been able to keep it up for over a year now.
I have tried various formats and writing styles, I have a template that I use for every blog post.


<post‎ title="SUBJECT" tags="TAGS">

What powers this website

Fri, 17 Oct 2025 22:37:22 +0200

When I started this website on 03 February 2024, it was a small project, with one php file for rendering markdown files.

This website is made in Visual Studio Code, with plain HTML, CSS, and a little bit of JavaScript (for opening the external URL's in a new tab, and add some utm tags to it, and to support comments on the blogposts).

The "backend" is written in PHP.

Page: Home

The home page is the page where the visitor (you) lands on, it shows a small introduction, my latest blog post, my latest mastodon post, a random app, and my latest github action.

Page: Blog

The blog page is the part which takes care of the blogposts, it reads the blogposts from a folder and parses them, the post format is yyyymmdd_post-title.md if a post must remain hidden it contains a ~ in the filename.

Page: Apps

The apps page is a page where I show my apps, it reads the apps from a json file and display them, if there is a bundle identifier defined, fetch data from the AppStore (such as the name, price, description, last update, versionnumber and screenshots).

example of an app:

"Calendo": {
    "name": "Calendo",
    "bundle_id": "nl.wesleydegroot.Calendo",
    "description": "Calendo: Your Simple and Smart Calendar\n\nStay organized and on top of your schedule with Calendo,\nthe ultimate calendar app designed for simplicity and efficiency.\nWhether you're managing personal appointments, work meetings,\nor family events, Calendo makes it easy to keep track of everything in one place.\n\nKey Features:\n  - Easy Event Management: Quickly add, edit, and delete events with a few taps.\n  - Scrollable month views: No more hassle of switching screens.\n  - Offline Access: Access your calendar even without an internet connection, because it uses your system calendar!\n\nWhy Choose Calendo?\n  - User-Friendly Interface: Designed with simplicity in mind, Calendo is easy to navigate and use.\n  - Reliable and Secure: We don't gather your calendar data.\n",
    "tags": [
        "iOS"
    ],
    "category": "Productivity,Utility",
    "url": {
        "AppStore": "https:\/\/apps.apple.com\/us\/app\/calendo\/id6651862759",
        "Issue tracker": "https:\/\/github.com\/0xWDG\/calendo-issues"
    },
    "screenshots": [
        "\/assets/screenshots\/Calendo_welcome.png",
        "\/assets/screenshots\/Calendo_calendar.png",
        "\/assets/screenshots\/Calendo_details.png"
    ]
}

Page: Projects

The projects page is a page where I show my projects, it reads the projects from a json file and fetch information from the GitHub API (amount of stars, forks, last update, and description).

[
    "AuroraEditor/AuroraEditor",
    "0xWDG/Admob-SwiftUI",
    "0xWDG/Apple-Music-to-Discord",
    "0xWDG/build-documentation",
    "0xWDG/CachedAsyncImage",
    "0xWDG/Colors",
    "0xWDG/DynamicUI",
    "0xWDG/FilePicker",
    "0xWDG/GameControllerKit",
    "0xWDG/iCloudStorage",
    "0xWDG/ImagePicker",
    "0xWDG/Inspect",
    "0xWDG/NetworkMonitor",
    "0xWDG/OnboardingKit",
    "0xWDG/OSLogViewer",
    "0xWDG/PHPFramework",
    "0xWDG/PreventScreenshot",
    "0xWDG/SecureStorage",
    "0xWDG/SimpleNetworking",
    "0xWDG/SwiftCronParser",
    "0xWDG/SwiftExtras",
    "0xWDG/tvOS.js",
    "0xWDG/XCUITestHelper"
]

Item: Sitemap

This is a php file that generates a sitemap.xml file, containing all the pages, blogposts, apps, and projects.

Item: RSS

This is a php file that generates a rss.xml file, containing all blogposts.

Item: GitHub API.

This is used for my GitHub profile profile, it gives a random blogpost, latest blogpost, a random app, and a random project for the README.md file.

Item: Social media API.

This script post to Bluesky, Mastodon and Threads, it uses an AI to summarize the blogpost.

Extra: Mastodon instance

This website is also running a (not yet working) Mastodon instance, I want to use this to post my blogposts to it.

Fun pages

I've made some funny pages for some HTTP status codes, such as

Building xcstrings-translator

Fri, 17 Oct 2025 22:37:22 +0200

xcstrings-translator is a tool to (easily) translate .xcstrings files, It is a GUI tool, written in Swift and SwiftUI to translate .xcstrings files to different languages using Apple's Translation Framework.

Idea

The idea behind this tool is to provide a simple and easy way to translate .xcstrings files. The tool should be able to read the .xcstrings file, my original idea was to make this a commandline application, but the Translation framework needs a SwiftUI view to work, so I decided to make this a GUI tool, then it needs to show the strings in a table view, and allow the user to translate the strings. The tool should also be able to save the translated strings back to the .xcstrings file.

Implementation

The tool is implemented using Swift and SwiftUI. The tool uses the Translation framework to translate the strings. The tool reads the .xcstrings file, extracts the strings, and shows them in a table view. The user can then translate the strings and save the translated strings back to the .xcstrings file.

Layout

The tool has a simple layout. The main window has a table view to show the strings. The table view has two columns, one for the original string and one for the translated string.

The build process

Building the layout

The layout is built using SwiftUI.
The main window has a "table view" to show the strings, and some elements to interact.

The view has two columns, one for the original string and one for the translated string.
This is achived using the LabeledContent view.

List {
    ForEach(languageParser.stringsToTranslate, id: \.self) { string in
        HStack {
            LabeledContent(
                string,
                value: translatedStrings[string] ?? ""
            )
        }
    }
}

Opening and saving the `.xcstrings` file

To allow the user to open and save the .xcstrings file, the tool uses my FilePicker package.
The FilePicker package provides a simple way to open and save files in SwiftUI.

`.cxstrings` file format

{
  "sourceLanguage" : "en",
  "strings" : {
    "More apps from the developer" : {
      "extractionState" : "translated",
      "localizations" : {
        "de" : {
          "stringUnit" : {
            "state" : "translated",
            "value" : "Weitere Apps vom Entwickler"
          }
        },
        "fr" : {
          "stringUnit" : {
            "state" : "translated",
            "value" : "Plus d'applications du développeur"
          }
        },
        "nl" : {
          "stringUnit" : {
            "state" : "translated",
            "value" : "Meer apps van de ontwikkelaar"
          }
        }
      }
    }
  }
}

Reading the `.xcstrings` file

The .cxstrings file is a easy file to read, the only "tricky" part is that the keys in this JSON file are the strings to translate, so we can't use a Codable struct to decode the file.

To read the .xcstrings file, we do this:

class LanguageParser: ObservableObject {
    /// Create a language dictionary to store the strings
    @Published var languageDictionary: [String: Any] = [:]

    /// Create an array to store the strings to translate
    @Published var stringsToTranslate: [String] = []

    /// Create an array to store if the string should be translated 
    /// (there is a better way to do this)
    @Published var shouldTranslate: [Bool] = []

    func load(file url: URL) {
        do {
            /// Read the file
            if let data = try? Data(contentsOf: url),
               /// Try to decode the file to a [String: Any] dictionary.
               let dict = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] {
                /// Save the dictionary
                languageDictionary = dict

                /// Parse the dictionary
                parse()
            }
        } catch {
            // Error
        }
    }
}

Parsing the `.xcstrings` file

extension LanguageParser {
    func parse() {
        stringsToTranslate = []

        if let strings = languageDictionary["strings"] as? [String: Any] {
            for (key, value) in strings where !key.isEmpty {
                guard let value = value as? [String: Any] else { continue }
                stringsToTranslate.append(key)
                shouldTranslate.append(value["shouldTranslate"] as? Bool ?? true)
            }
        }
    }
}

Exposing the JSON data

To save the .xcstrings file, we need to convert the language dictionary to JSON data and write the data to the file.
The LanguageParser class has a data property that converts the language dictionary to JSON data, the .filePicker modifier will be used to save the file later.

extension LanguageParser {
    var data: Data {
        try! JSONSerialization.data(
            withJSONObject: languageDictionary,
            options: .prettyPrinted
        )
    }
}

Upating the translated strings

This is a bit complex to userstand, I made the mistake to not update the correct values to update the language dictionary.

extension LanguageParser {
    func add(translation: String, forLanguage: String, original: String) {
        // We want to get the "strings" key from the dictionary
        if var strings = languageDictionary["strings"] as? [String: Any],
           // We want to get the original string from the dictionary
           var item = strings[original] as? [String: Any] {
            // strings -> "original string" -> localizations -> "language"

            // We want to check if there are already localizations
            if var localizations = item["localizations"] as? [String: Any] {
                // There is already a localization key, now we can update the value for this language
                localizations[forLanguage] = [
                    "stringUnit": [
                        "state": "translated", 
                        "value": translation
                    ]
                ]

                // Update the localizations key
                item["localizations"] = localizations

                // Save the item back to the strings dictionary
                strings[original] = item

                // Save the strings back to the language dictionary
                languageDictionary["strings"] = strings

                // Finish execution
                return
            } else {
                // There are no localizations yet, so we need to create a new one
                item["localizations"] = [
                    forLanguage: [
                        "stringUnit": [
                            "state": "translated",
                            "value": translation
                        ]
                    ]
                ]

                // Save the item back to the strings dictionary
                strings[original] = item

                // Save the strings back to the language dictionary
                languageDictionary["strings"] = strings

                // Finish execution
                return
            }
        }

        // Something went wrong
        print("Failed to get strings")
    }
}

Final application

To translate the strings we need to setup a TranslationSession, and in this example we are always translating from English to Dutch.
Please note that this is a very simple example, for the best results you can look up the actual code for this view on GitHub.

struct ContentView: View {
    /// This is the language parser we've built before.
    @ObservedObject var languageParser = LanguageParser()

    /// This is array which holds the translated strings
    @State var translatedStrings: [String: String] = [:]

    /// This is the source language (English)
    @State var sourceLanguage: Locale.Language?

    /// This is the destination language (Dutch)
    @State var destinationLanguage: Locale.Language?

    /// This is the translation session
    @State var translationSession: TranslationSession?

    /// Is the file picker open
    @State var filePickerOpen = false

    /// Is the file exporter open
    @State var exportFile = false

    /// Which files are selected
    @State var filePickerFiles: [URL] = []

    var body: some View {
        VStack {
            List {
                ForEach(languageParser.stringsToTranslate, id: \.self) { string in
                    HStack {
                        LabeledContent(
                            string,
                            value: translatedStrings[string] ?? ""
                        )
                    }
                }

                Button("Open", systemImage: "square.and.arrow.down") {
                    filePickerOpen.toggle()
                }
                // Support ⌘O to open
                .keyboardShortcut("o", modifiers: .command)

                Button("Save", systemImage: "square.and.arrow.up") {
                    exportFile.toggle()
                }
                // Support ⌘S to save
                .keyboardShortcut("s", modifiers: .command)

                Button("Translate", systemImage: "translate") {
                    translate() // Translate the strings
                }
                // Support ⌘T to translate
                .keyboardShortcut("t", modifiers: .command)
            }
        }
        .task {
            /// Set the destination language to Dutch
            destinationLanguage = supportedLanguages.first(where: { $0.languageCode == "nl" })

            /// Set the source language to English
            sourceLanguage = supportedLanguages.first(where: { $0.languageCode == "en" })
        }
        /// Open a file
        .filePicker(
            isPresented: $filePickerOpen,
            files: $filePickerFiles,
            types: [.init(filenameExtension: "xcstrings")!]
        )
        /// Save a file
        .filePicker(
            isPresented: $exportFile,
            fileName: "Localizable.strings",
            data: languageParser.data, // Exposed JSON data
            types: [.init(filenameExtension: "xcstrings")!]
        )
        /// File is opened
        .onChange(of: $filePickerFiles.wrappedValue) {
            if let val = $filePickerFiles.wrappedValue.first {
                // Reset the translated strings
                translatedStrings = [:]

                // Load the file
                languageParser.load(file: val)
            }
        }
        // Setup the translation session
        .translationTask(
            source: sourceLanguage,
            target: destinationLanguage
        ) { session in
            // Save our translation session
            translationSession = session
        }
    }

    func translate() {
        Task {
            if let session = translationSession {
                do {
                    for string in languageParser.stringsToTranslate where !string.isEmpty {
                        // Perform translation
                        let response = try await session.translate(string)

                        // Save the translated string
                        translatedStrings[string] = response.targetText

                        // Add the translation to the language parser (to save it to the file)
                        languageParser.add(translation: response)
                    }
                } catch {
                    // code to handle error
                }
            }
        }
    }
}

Conclusion

This was a fun project to work on, I've created a new Swift package to open and save files in SwiftUI, and I've had fun to work on this project.

Special thanks

Special thanks goes to Zhenyi Tan to help me with fixing the issue I've made which prevented me from updating the language dictionary.

Dependencies used

Translation framework
This is a framework provided by Apple to translate strings.
FilePicker
FilePicker is a Swift package to open and save files in SwiftUI.
SwiftExtras
SwiftExtras is a collection of Swift extensions and utilities, It is mainly used to create the settings view.
xcstrings-translator app page
The app page for "xcstrings-translator" on my website.
xcstrings-translator GitHub repository
The GitHub repository for "xcstrings-translator".

Customizing macOS windows

Fri, 17 Oct 2025 22:37:23 +0200

MacOS windows are a fundamental part of the user interface, and customizing them can greatly enhance the user experience. In this post, we will explore how to customize macOS windows using SwiftUI.
We will cover how to create a custom window style, add a toolbar.

Window backgrounds

To customize the background of a window, we can use the .containerBackground(_:for:) modifier.

Default window background

The default window background is a solid color. You can set the background color of a window using the .background modifier.

import SwiftUI

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

thinMaterial window background

You can use the .containerBackground(_:for:) modifier to set a material background for the window. This will give the window a translucent effect, allowing the content behind it to show through.

import SwiftUI

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .containerBackground(
                    .thinMaterial, for: .window
                )
        }
    }
}

Without toolbar

You can also hide the toolbar of the window by using the .toolbarBackgroundVisibility(_:for:) modifier. This will remove the toolbar from the window, giving it a cleaner look.

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .containerBackground(
                    .thinMaterial, for: .window
                )
                .toolbarBackgroundVisibility(
                    .hidden, for: .windowToolbar
                )
        }
    }
}

Without title bar

You can also hide the title bar of the window by using the .windowStyle(_:) modifier. This will remove the title bar from the window, giving it a cleaner look.

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .containerBackground(
                    .thinMaterial, for: .window
                )
        }
        .windowStyle(.hiddenTitleBar)
    }
}

Different toolbar styles

You can customize the toolbar style of a window by using the .windowToolbarStyle(_:) modifier. This allows you to change the appearance of the toolbar to match your app's design.

Default toolbar style

The default toolbar style is combined with the window. This means that the toolbar will be displayed at the top of the window, and it will be combined with the window's title bar.

import SwiftUI

@main
struct WindowApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .toolbar {
                    ToolbarItemGroup(placement: .automatic, content: {
                        Image(systemName: "star")
                        Text("You're a superstar")
                    })
                    ToolbarItemGroup(placement: .automatic, content: {
                        Menu(content: {
                            Button(action: {}, label: { Text("Sub item 1") })
                            Button(action: {}, label: { Text("Sub item 2") })
                        }, label: {
                            Text("Menu")
                        })
                    })
                }
        }
    }
}

Expanded toolbar style

The expanded toolbar style expands the toolbar to its full width, allowing for more space for the toolbar items. This is useful for apps that have a lot of toolbar items or need more space for their content.

import SwiftUI

@main
struct WindowApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .toolbar {
                    ToolbarItemGroup(placement: .automatic, content: {
                        Image(systemName: "star")
                        Text("You're a superstar")
                    })
                    ToolbarItemGroup(placement: .automatic, content: {
                        Menu(content: {
                            Button(action: {}, label: { Text("Sub item 1") })
                            Button(action: {}, label: { Text("Sub item 2") })
                        }, label: {
                            Text("Menu")
                        })
                    })
                }
        }
        .windowToolbarStyle(.expanded)
    }
}

Unified toolbar style

The unified toolbar style combines the toolbar and the window title bar into a single element. This gives the window a more cohesive look and feel, making it easier for users to navigate.

import SwiftUI

@main
struct WindowApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .toolbar {
                    ToolbarItemGroup(placement: .automatic, content: {
                        Image(systemName: "star")
                        Text("You're a superstar")
                    })
                    ToolbarItemGroup(placement: .automatic, content: {
                        Menu(content: {
                            Button(action: {}, label: { Text("Sub item 1") })
                            Button(action: {}, label: { Text("Sub item 2") })
                        }, label: {
                            Text("Menu")
                        })
                    })
                }
        }
        .windowToolbarStyle(.unified)
    }
}

Unified compact toolbar style

The unified compact toolbar style is similar to the unified toolbar style, but it is more compact. This is useful for apps that have not a lot of toolbar items.

import SwiftUI

@main
struct WindowApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .toolbar {
                    ToolbarItemGroup(placement: .automatic, content: {
                        Image(systemName: "star")
                        Text("You're a superstar")
                    })
                    ToolbarItemGroup(placement: .automatic, content: {
                        Menu(content: {
                            Button(action: {}, label: { Text("Sub item 1") })
                            Button(action: {}, label: { Text("Sub item 2") })
                        }, label: {
                            Text("Menu")
                        })
                    })
                }
        }
        .windowToolbarStyle(.unifiedCompact)
    }
}

Conclusion

MacOS windows are very customizable, and SwiftUI provides a powerful set of tools to help you create beautiful and functional windows. By using the techniques outlined in this post, you can create a unique and engaging user experience for your macOS applications.

Creating macOS Menu Bar App in SwiftUI

Fri, 17 Oct 2025 22:37:23 +0200

Creating a menu bar app may seems like a complicated task, but with SwiftUI, it can be done in a few simple steps. In this post, we will create a basic macOS menu bar app using SwiftUI.
The app will display a menu bar icon and a simple menu with a few options. We will also add functionality to show a popover when the icon is clicked.

Setting up the Project

Create a new macOS project in Xcode and select "App" as the template. Make sure to select SwiftUI as the interface and Swift as the language.

Creating the Menu Bar App

Your MenuBarApp.swift file will look like this:

import SwiftUI

@main
struct MenuBarAppApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

To support the menu bar, we need to make a slight change in this file.

@main
struct MenuBarAppApp: App {
    var body: some Scene {
        MenuBarExtra {
            ContentView()
        } label: {
            Image(systemName: "star")
        }
        .menuBarExtraStyle(.window) // We use this to make the menu bar icon look like a window
    }
}

Creating the ContentView

Now, let's create a simple ContentView that will be displayed when the menu bar icon is clicked. Create a new SwiftUI view file named ContentView.swift and add the following code:

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(.tint)
            Text("Hello, world!")
        }
        .padding()
    }
}

This code creates a simple view with a text label and a button. When the button is clicked, it prints a message to the console.

Running the App

Now, you can run the app in Xcode.
You should see a menu bar icon appear in the top right corner of your screen.

When you click the icon, a popover with the text "Hello, World!" will appear.

Hiding the Dock Icon

By default, the app will also show an icon in the dock.

To hide the dock icon, you need to modify the Info.plist file.
Navigate to your Project, click on the Target, and select the Info tab, then add a new entry with the key Application is agent (UIElement) and set its value to YES.
This will hide the app from the dock and make it a menu bar app.

Conclusion

Creating a macOS menu bar app using SwiftUI is a easy process, it allows you to create a simple and functional app with minimal code.

I hope this post helps you get started with creating your own macOS menu bar app using SwiftUI.

Let me know in the comments which menu bar apps you've created or if you have any questions!

References

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

Popovers in SwiftUI

Fri, 17 Oct 2025 22:37:24 +0200

In SwiftUI, popovers are a great way to present additional information or options without navigating away from the current view. This post will explore how to create and customize popovers in SwiftUI.

Use Case for Popovers

Popovers are particularly useful when you want to display contextual information or options related to a specific element in your user interface. For example, you might use a popover to show additional details about an item in a list or to present settings options without cluttering the main view.

PresentationAdaptation struct

In SwiftUI, the PresentationAdaptation struct is used to define how a view should adapt when presented in different environments, such as compact or regular size classes. This is particularly useful for popovers, as it allows them to behave appropriately across various device orientations and screen sizes.

When you use the .presentationCompactAdaptation(_:) modifier, you can specify how the popover should adapt when the device is in a compact environment. For example, you might want the popover to appear as a full-screen modal in compact mode instead of a small popover.

The options are:

.automatic
Use the default presentation adaptation.
.none
Don’t adapt for the size class, if possible.
.fullScreenCover
Prefer a full-screen-cover appearance when adapting for size classes.
.popover
Prefer a popover appearance when adapting for size classes.
.sheet
Prefer a sheet appearance when adapting for size classes.

Popover Modifiers

In this tutorial, we'll use 2 key modifiers to create and customize a popover in SwiftUI:

.popover(isPresented:attachmentAnchor:arrowEdge:content:)
This modifier gives you some options to customize the popover's behavior. You can specify whether the popover is presented, where it should attach to the view, and which edge of the popover should point to the anchor.
.presentationCompactAdaptation(_:)
This modifier allows the popover to adapt to compact environments, such as when the device is in landscape mode or when the screen size is smaller. It ensures that the popover behaves appropriately across different device orientations and sizes.

Code

struct Popovers: View {
    @State
    private var popoverVisible: Bool = false

    var body: some View {
        Button("Toggle Popover") {
            popoverVisible.toggle()
        }
        .popover(
            isPresented: $popoverVisible, 
            arrowEdge: .top
        ) {
            popoverView
                .presentationCompactAdaptation(.popover)
                // This modifier allows the popover to adapt to compact environments
        }
    }

    var popoverView: some View {
        Text("You have pressed the button!")
            .padding()
    }
}

Screenshots

iOS

macOS

Conclusion

Popovers are easy to implement in SwiftUI and provide a clean way to present additional information or options without disrupting the user's flow. By using the popover modifier, you can easily toggle the visibility of a popover and customize its content.

Handle plurals in Swift with inflection

Fri, 17 Oct 2025 22:37:24 +0200

Inflection is a powerful tool in Swift that allows developers to handle plurals and other linguistic variations in a more elegant way. This post will explore how to use inflection in Swift, providing examples and best practices.

What is Inflection?

a change in the form of a word (typically the ending) to express a grammatical function or attribute such as tense, mood, person, number, case, and gender.
Inflection in Swift allows you to automatically adjust the form of words based on context, such as singular or plural forms. This is particularly useful in user interfaces where you want to display text that changes based on user input or data.

Code

import SwiftUI

struct BookCollection: View {
    @State private var bookCount: Int = 0

    var body: some View {
        VStack {
            Text("You've bought ^[\(bookCount) book](inflect: true) this year!")

            Button("Add a book") {
                bookCount += 1
            }
        }
    }
}

#Preview {
    BookCollection()
}

In this example, we create a simple SwiftUI view that displays the number of books purchased. The Text view uses an inflection feature to automatically handle the pluralization of the word "book" based on the value of bookCount. When bookCount is 1, it will display "1 book", and for any other number, it will display the correct plural form "books".
This approach makes it easy to manage plurals without having to write additional logic or conditional statements, leading to cleaner and more maintainable code.

Supported languages

Inflection supports (as of writing this article) the following languages:

English
French
German
Hindi
Italian
Korean
Portuguese
Spanish

Conclusion

Inflection in Swift is a powerful feature that simplifies the handling of plurals and other linguistic variations in your applications. By using inflection, you can create more dynamic and user-friendly interfaces without cluttering your code with complex logic. This not only enhances the user experience but also improves code readability and maintainability.

CocoaPods Trunk Read-only Plan

Fri, 17 Oct 2025 22:37:25 +0200

CocoaPods Trunk Read-only Plan

What is `CocoaPods`?

CocoaPods is a dependency manager for Swift and Objective-C Cocoa projects. It has thousands of libraries and can help you scale your projects elegantly.
It is used to manage library dependencies in iOS and macOS applications, allowing developers to easily integrate third-party libraries into their projects.
It is widely used in the iOS development community to simplify the process of managing external libraries and frameworks.

What will happen to `CocoaPods` pods?

CocoaPods will continue to function as a dependency manager, but the Trunk service will be read-only. This means that while you can still use CocoaPods to manage your dependencies, you will not be able to publish new pods or update existing ones through the Trunk service.

Migration to `Swift Package Manager`

The CocoaPods team is encouraging developers to migrate their projects to use the Swift Package Manager (SPM) for dependency management. SPM is Apple's official package manager for Swift and is integrated into Xcode, making it a more modern and streamlined solution for managing dependencies in Swift projects.

When will this happen?

This will happen on 02-DEC-2026, This is a Wednesday after American Thanksgiving.

More Information

For more information, you can refer to the official announcement on the CocoaPods blog: CocoaPods Trunk Read-only Plan

Thermal States on iOS

Fri, 17 Oct 2025 22:37:25 +0200

You can read the thermal states on iOS documentation to understand how to manage the thermal state of your iOS application. This is important for optimizing performance and battery life.

What is `Thermal State`?

Thermal states on iOS refer to the different levels of thermal conditions that an iOS device can experience. These states are used by the system to manage performance and power consumption based on the device's temperature. The thermal state can affect how your application behaves, especially in terms of CPU and GPU usage.

Reasons to know the `Thermal State`

For example if you want to compress a video, you might want to know the thermal state of the device to avoid overheating. If the device is in a high thermal state, you might want to reduce the quality of the video compression or pause it to prevent the device from overheating.

How to read the `Thermal State`

You can read the thermal state of an iOS device using the ProcessInfo class. The thermalState property of ProcessInfo provides the current thermal state of the device. You can use this information to adjust your application's behavior based on the thermal conditions.

import Foundation

let thermalState = ProcessInfo.processInfo.thermalState

switch thermalState {
case .nominal:
    print("Device is in a nominal thermal state.")
case .fair:
    print("Device is in a fair thermal state.")
case .serious:
    print("Device is in a serious thermal state.")
case .critical:
    print("Device is in a critical thermal state.")
case .unknown:
    print("Device thermal state is unknown.")
default:
    print("Device thermal state is not recognized.")
}

Example for video compression

import Foundation
var videoCompressionInProgress = true

func shouldContinueVideoCompression() -> Bool {
    let thermalState = ProcessInfo.processInfo.thermalState

    switch thermalState {
    case .nominal, .fair:
        // Continue compression at normal quality
        return true
    case .serious, .critical:
        // Reduce quality or pause compression to prevent overheating
        return false
    case .unknown:
        // Handle unknown state cautiously
        return false
}

func compressFrame() {
    // Your video compression logic here
    print("Compressing video frame...")
}

while (shouldContinueVideoCompression() && videoCompressionInProgress) {
    compressFrame() // Your video compression logic here
}

Conclusion

Knowing the thermal state of the device is curcial if you want to execute work which can cause the device to overheat. By using the ProcessInfo class, you can read the thermal state and adjust your application's behavior accordingly. This can help you optimize performance and battery life, ensuring a better user experience.

Move your app to the background

Fri, 17 Oct 2025 22:37:26 +0200

In this (small) post, we will explore how to move your iOS application to the background programmatically.
This is offcially not supported by Apple.

Send app to background

import SwiftUI

struct ContentView: View {
    var body: some View {
        Button("Send App to Background") {
            UIControl()
                .sendAction(
                    #selector(URLSessionTask.suspend), 
                    to: UIApplication.shared, 
                    for: nil
                )
        }
    }
}

What is `UIControl`?

UIControl is a class in UIKit that provides the base functionality for controls such as buttons, switches, and sliders. It is used to handle user interactions and events in iOS applications.

What is `sendAction`?

sendAction(_:to:for:) is a method of UIControl that sends an action message to the target object. It allows you to trigger a specific action when a control is interacted with, such as tapping a button.

What is `URLSessionTask.suspend`?

URLSessionTask.suspend is a method that suspends the task, effectively pausing any ongoing network operations.
However in this context, it is used to send the app to the background by invoking this method on the shared UIApplication instance.

What is `UIApplication.shared`?

UIApplication.shared is a singleton instance of the UIApplication class that represents the current application. It provides access to various application-level properties and methods, including managing the app's lifecycle and handling events.

How does it work?

The code snippet provided uses the sendAction(_:to:for:) method of UIControl to send an action to the UIApplication.shared instance, specifically calling the suspend method of URLSessionTask. This effectively moves the app to the background.

Conclusion

This method is not officially supported by Apple and should be used with caution. It is generally recommended to let the system manage the app's lifecycle and background behavior. However, if you need to programmatically move your app to the background, this approach can be used.

Using the share sheet to share content

Fri, 17 Oct 2025 22:37:26 +0200

In this post, we will explore how to use the share sheet in SwiftUI to share content from your app. The share sheet allows users to share text, images, URLs, and other types of content with other apps or services on their device.

What is `ShareLink`?

ShareLink is a view in SwiftUI that provides a way to share content using the system's share sheet. It allows you to specify the content you want to share, such as text, images, or URLs, and presents the share sheet when the user interacts with it.

Different ways to use `ShareLink`

ShareLink without title

You can create a ShareLink without a title, which will use the default system-provided title for the share action.

ShareLink(
    item: URL(string: "https://wesleydegroot.nl")!
)

ShareLink with customized link title

You can customize the title of the share link by providing a string as the first argument.

ShareLink(
    "Share Website",
    item: URL(string: "https://wesleydegroot.nl")!
)

ShareLink with a customized sharing subject and message

You can also customize the subject and message of the share action by providing Text views for the subject and message parameters.

ShareLink(
    item: URL(string: "https://wesleydegroot.nl")!,
    subject: Text("Share blog"),
    message: Text("Share blog post ShareLink")
)

ShareLink with a preview

You can provide a preview for the shared content using the preview parameter. This allows you to specify a title and an icon for the preview.

ShareLink(
    item: URL(string: "https://appsterdam.rs")!,
    preview: SharePreview(
        "Join Appsterdam!",
        icon: Image(systemName: "person.3.sequence.fill")
    )
)

ShareLink with a custom label

You can create a ShareLink with a custom label by providing a closure that returns a view, such as a Label.

ShareLink(item: URL(string: "https://wesleydegroot.nl")!) {
    Label(
        "Share my website",
        systemImage: "star"
    )
}

ShareLink with Transferable object

You can also share custom objects that conform to the Transferable protocol. This allows you to share complex data types, such as images or structured data.

Example of a Transferable object

struct BlogPost: Transferable {
    static var transferRepresentation: some TransferRepresentation {
        ProxyRepresentation(exporting: \.image)
    }

    public var image: Image
    public var title: String
    public var description: String
}

Using ShareLink with a Transferable object

ShareLink(
    item: post,
    preview: SharePreview(post.title, image: post.image)
)

Full code example

import SwiftUI

struct ShareLinkDemoView: View {
    let post: BlogPost = .init(
        image: Image(systemName: "star"),
        title: "Welcome to this blog post",
        description: "With a description that is longer than the title"
    )

    var body: some View {
        List {
            Section("ShareLink without title") {
                ShareLink(
                    item: URL(string: "https://wesleydegroot.nl")!
                )
            }

            Section("ShareLink with customized link title") {
                ShareLink(
                    "Share Website",
                    item: URL(string: "https://wesleydegroot.nl")!
                )
            }

            Section("ShareLink with a customized sharing subject and message") {
                ShareLink(
                    item: URL(string: "https://wesleydegroot.nl")!,
                    subject: Text("Share blog"),
                    message: Text("Share blog post ShareLink")
                )
            }

            Section("ShareLink with a preview") {
                ShareLink(
                    item: URL(string: "https://appsterdam.rs")!,
                    preview: SharePreview(
                        "Join Appsterdam!",
                        icon: Image(systemName: "person.3.sequence.fill")
                    )
                )
            }

            Section("ShareLink with a custom label") {
                ShareLink(item: URL(string: "https://wesleydegroot.nl")!) {
                    Label(
                        "Share my website",
                        systemImage: "star"
                    )
                }
            }

            Section("ShareLink with Transferable object") {
                ShareLink(
                    item: post,
                    preview: SharePreview(post.title, image: post.image)
                )
            }
        }
    }
}

struct BlogPost: Transferable {
    static var transferRepresentation: some TransferRepresentation {
        ProxyRepresentation(exporting: \.image)
    }

    public var image: Image
    public var title: String
    public var description: String
}

#Preview {
    ShareLinkDemoView()
}

Screenshots

Conclusion

ShareLink is a powerful and flexible way to share content in SwiftUI applications. It allows you to easily present the system's share sheet and customize the content being shared. By using ShareLink, you can enhance the user experience of your app by enabling users to share content with their favorite apps and services seamlessly.

Gradients in text using foregroundStyle

Fri, 17 Oct 2025 22:37:27 +0200

In this post, we will explore how to create gradients in text using the foregroundStyle modifier in SwiftUI. This technique allows for visually appealing text effects that can enhance the user interface of your applications.

What is `.foreGroundStyle`?

ForegroundStyle is a SwiftUI modifier that allows you to apply a style to the foreground of a view, such as text. It can be used to create gradients, patterns, or other visual effects that enhance the appearance of text elements.

Usage

To use foregroundStyle, you can apply it to a Text view in SwiftUI. Here’s a simple example:

import SwiftUI

struct ContentView: View {
    var body: some View {
        Text("Hello, SwiftUI!")
            .font(.largeTitle)
            .foregroundStyle(
                LinearGradient(
                    gradient: Gradient(colors: [.red, .blue]),
                    startPoint: .leading,
                    endPoint: .trailing
                )
            )
    }
}

Old way (without `foregroundStyle` and a mask)

This is the traditional way of applying a gradient to text before the introduction of foregroundStyle. It involves using a mask to apply the gradient to the text.
Note: This does not work well with Emoji.

import SwiftUI

struct OldContentView: View {
    var body: some View {
        Text("Hello, SwiftUI!")
            .font(.largeTitle)
            .overlay {
                LinearGradient(
                    colors: colors,
                    startPoint: startPoint,
                    endPoint: endPoint
                )
                .mask(
                    self
                )
            }
    }
}

Combining the two approaches (for supporting older iOS versions)

To support older iOS versions that do not have the foregroundStyle modifier, you can combine both approaches. This way, you can use foregroundStyle on newer versions and fall back to the masking technique on older versions.

import SwiftUI

extension Text {
    /// Make the foreground gradient
    ///
    /// Create a gradient for the foreground of the text.
    ///
    /// - Parameters:
    ///   - colors: Colors
    ///   - startPoint: Startpoint
    ///   - endPoint: End point
    /// - Returns: self
    @ViewBuilder
    public func foregroundLinearGradient(
        colors: [Color] = [.red, .blue, .green, .yellow],
        startPoint: UnitPoint = .leading,
        endPoint: UnitPoint = .trailing
    ) -> some View {
        if #available(iOS 17, *) {
            self.foregroundStyle(
                LinearGradient(
                    colors: colors,
                    startPoint: startPoint,
                    endPoint: endPoint
                )
            )
        } else {
            self.overlay {
                LinearGradient(
                    colors: colors,
                    startPoint: startPoint,
                    endPoint: endPoint
                )
                .mask(
                    self
                )
            }
        }
    }
}

Conclusion

The foregroundStyle modifier in SwiftUI provides a powerful way to apply gradients and other styles to text. This enhances the visual appeal of your applications and allows for creative text effects. By using LinearGradient, RadialGradient, or AngularGradient, you can easily create stunning text designs that stand out in your user interface.

Difference between animations in SwiftUI

Fri, 17 Oct 2025 22:37:28 +0200

In this post, we will explore the difference between .animation() and withAnimation() and phaseAnimator() in SwiftUI. Both are used to create animations, but they serve different purposes and have different use cases.

What is `.animation()` and `withAnimation()` and `phaseAnimation()`?

.animation() is a view modifier in SwiftUI that applies an animation to changes in a view's state. It can be used to animate specific properties of a view, such as its position, scale, or opacity, when those properties change.

withAnimation() is a function that allows you to perform state changes with an animation. It can be used to wrap any state-changing code, and the changes will be animated automatically.

phaseAnimator() is a more advanced animation API that allows you to create complex animations by defining different phases of an animation and transitioning between them. It provides greater control over the animation process and can be used for more intricate animations.

In summary, use .animation() when you want to apply an animation to a specific view, and use withAnimation() when you want to animate state changes more generally.

`.animation()`

Example

struct ContentView: View {
    @State private var isScaled = false

    var body: some View {
        Circle()
            .scaleEffect(isScaled ? 1.5 : 1.0)
            .animation(.easeInOut(duration: 0.5))
            .onTapGesture {
                isScaled.toggle()
            }
    }
}

When isScaled changes, SwiftUI checks if the value passed to .animation() has changed.
If it has, the animation is applied to the changes in that view’s state.
You’re essentially telling the view how it should animate as its state updates.

Pros of `.animation()`

Simple and concise.
Declarative style fits right into SwiftUI’s architecture.
Great for chaining effects (e.g. scale, opacity, rotation).

Cons of `.animation()`

Limited control over timing and grouping.
Only works on the specific view it's attached to.

Use Case: Animating a Button Press

In this example, we have a button that scales up when pressed and scales back down when released. We use .animation() to apply the scaling animation to the button's scale effect.

struct ContentView: View {
    @State private var isActivated = false

    var body: some View {
        Button(action: {
            isActivated.toggle()
        }) {
            Text("Press Me")
                .padding()
                .background(Color.blue)
                .foregroundColor(.white)
                .cornerRadius(10)
                .scaleEffect(isActivated ? 1.2 : 1.0)
                .animation(.easeInOut(duration: 0.2))
        }
    }
}

`withAnimation()`

withAnimation() is a function that allows you to perform state changes with an animation. It can be used to wrap any state-changing code, and the changes will be animated automatically.

Example

struct ContentView: View {
    @State private var isVisible = false

    var body: some View {
        VStack {
            Button("Toggle Visibility") {
                withAnimation(.easeInOut(duration: 0.5)) {
                    isVisible.toggle()
                }
            }

            if isVisible {
                Text("Hello, World!")
                    .transition(.slide)
            }
        }
    }
}

In this example, we use withAnimation() to wrap the state change of isVisible. When the button is pressed, the text will appear or disappear with a sliding transition. The animation is applied to the entire state change, including the transition of the text.

Pros of `withAnimation()`

Provides a simple way to animate state changes.
Can be used with any state-changing code, not just view properties.
Allows for more complex animations by combining multiple state changes.

Cons of `withAnimation()`

Less control over individual view animations.
Can lead to unexpected animations if not used carefully.

Use Case: Animating a View Transition

struct ContentView: View {
    @State private var isVisible = false

    var body: some View {
        VStack {
            Button("Toggle Visibility") {
                withAnimation(.easeInOut(duration: 0.5)) {
                    isVisible.toggle()
                }
            }

            if isVisible {
                Text("Hello, World!")
                    .transition(.slide)
            }
        }
    }
}

`phaseAnimator()`

Example

import SwiftUI

struct ContentView: View {
    @State private var currentPhase: Int = 0

    var body: some View {
        PhaseAnimator([0, 1, 2]) { phase in
            Circle()
                .frame(width: phase == 0 ? 50 : (phase == 1 ? 100 : 150))
                .foregroundStyle(phase == 0 ? .blue : (phase == 1 ? .green : .red))
        } animation: { phase in
            switch phase {
            case 0: .easeIn(duration: 0.5)
            case 1: .spring(response: 0.6, dampingFraction: 0.8)
            default: .linear(duration: 0.3)
            }
        }
    }
}

This example uses phaseAnimator() to create a circle that changes its size and color based on the current phase. The animation is defined for each phase, allowing for more complex transitions.

Pros of `phaseAnimator()`

Provides fine-grained control over the animation process.
Allows for complex animations with multiple phases.
Can be used to create intricate animations that are difficult to achieve with .animation() or withAnimation().
Supports custom timing and easing functions for each phase.

Cons of `phaseAnimator()`

More complex to set up compared to .animation() and withAnimation().
Requires a deeper understanding of SwiftUI's animation system.

Use Case: Creating a Complex Animation

In this example, we use phaseAnimator() to create a circle that changes its size and color based on the current phase. The animation is defined for each phase, allowing for more complex transitions.

import SwiftUI

struct ContentView: View {
    @State private var phase: Int = 0

    var body: some View {
        PhaseAnimator([0, 1, 2]) { phase in
            Rectangle()
                .frame(width: phase == 0 ? 100 : 200, height: 50)
                .foregroundStyle(phase == 1 ? .blue : .red)
        } animation: { _ in
            .spring(response: 0.5, dampingFraction: 0.7)
        }
    }
}

Side-by-Side Comparison

Feature	`.animation()`	`withAnimation()`	`phaseAnimator()`
Purpose	Animates specific view properties	Animates state changes	Provides fine-grained control over the animation process.
Usage	View modifier for specific views	Function to wrap state changes	Used to create intricate animations with multiple phases.
Control	Limited to the view it's attached to	More control over state changes	Supports custom timing and easing functions for each phase.
Timing	Fixed timing for the view	Customizable timing for state changes	Allows for complex animations with multiple phases.
Grouping	Limited to the view's properties	Can group multiple state changes	Enables intricate animations that are difficult to achieve with `.animation()` or `withAnimation()`.

When to Use Each

Use .animation() when you want to animate specific properties of a view, such as its position, scale, or opacity.
Use withAnimation() when you want to animate state changes more generally, such as showing or hiding views, or changing multiple properties at once.
Use phaseAnimator() when you need fine-grained control over the animation process, or when you want to create complex animations with multiple phases.

Conclusion

In summary, .animation() and withAnimation() are both powerful tools for creating animations in SwiftUI, but they serve different purposes. Use .animation() when you want to apply an animation to a specific view, and use withAnimation() when you want to animate state changes more generally. For more complex animations, consider using phaseAnimator(), which provides greater control over the animation process and allows for intricate animations with multiple phases.

Adjust the intensity of colors in SwiftUI views

Fri, 17 Oct 2025 22:37:28 +0200

SwiftUI provides a powerful way to create dynamic and visually appealing user interfaces. One of the features that can enhance the visual experience is the ability to adjust the intensity of colors in views. This can be achieved using the .brightness modifier, which allows developers to manipulate the brightness of colors in SwiftUI views.

What is `.brightness`?

The .brightness modifier in SwiftUI is used to adjust the brightness of a view. It takes a value between -1.0 and 1.0, where -1.0 represents the darkest possible state and 1.0 represents the brightest. This modifier can be particularly useful for creating dynamic interfaces that respond to user preferences or environmental conditions.

Installation

To use the .brightness modifier, you do not need to install any additional libraries as it is part of the SwiftUI framework. Simply import SwiftUI in your project and you can start using it.

Use Case: Adjusting Color Intensity

In this example, we will demonstrate how to use the .brightness modifier to adjust the intensity of colors in a SwiftUI view. This can be particularly useful for creating themes or adjusting the appearance of views based on user preferences.

import SwiftUI

// Example of using the .brightness modifier in SwiftUI
// This example creates a series of colored views with varying brightness levels.
// it is everytime brighter than the previous one.
struct ContentView: View {
    var body: some View {
        ForEach(0..<10) { num in
            Color
                .purple
                .brightness(Double(num) * 0.1)
        }
    }
}

Example of using the .brightness modifier in SwiftUI

import SwiftUI

// Example of using the .brightness modifier in SwiftUI
// This example creates a series of colored views with varying brightness levels.
// it is everytime darker than the previous one.
struct ContentView: View {
    var body: some View {
        ForEach(0..<10) { num in
            Color
                .purple
                .brightness(Double(num) * -0.1)
        }
    }
}

Example of using the .brightness modifier in SwiftUI

Caveats

While the .brightness modifier is powerful, there are a few caveats to keep in mind:

Accessibility: Ensure that the adjusted colors remain accessible to all users, including those with visual impairments. Test your views with different brightness levels to ensure readability and usability.
Device Variability: The appearance of colors can vary across different devices and screen types. Always test your views on multiple devices to ensure consistent appearance.

Wrap up

In this article, we explored the .brightness modifier in SwiftUI and how it can be used to adjust the intensity of colors in views. We discussed its use cases, implementation details, and potential caveats to keep in mind.

Conclusion

The .brightness modifier is a powerful tool for creating dynamic and visually appealing SwiftUI views. By understanding how to use it effectively, you can enhance the user experience in your applications.

https://developer.apple.com/documentation/swiftui/view/brightness(_:)

SwiftUI Buttons

Fri, 17 Oct 2025 22:37:29 +0200

In this post we will explore the different styles of buttons available in SwiftUI, how to create custom buttons, and some best practices for using buttons in your SwiftUI applications.

What are Buttons in SwiftUI?

Buttons in SwiftUI are interactive elements that trigger actions when tapped. They can be styled and customized to fit the design of your application. SwiftUI provides a variety of built-in button styles, and you can also create your own custom styles.

Basic Button Usage

To create a basic button in SwiftUI, you can use the Button view. Here’s a simple example:

Button("My Button") {
    print("Button tapped!")
}

Built-in Button Styles

SwiftUI provides several built-in button styles that you can use to change the appearance of your buttons.

Here are some common styles:

Default Button Style

The default button style is simple and adapts to the platform's design guidelines.

Button("Default Button") {
    print("Default button tapped!")
}
.buttonStyle(DefaultButtonStyle())

Borderless Button Style

The borderless button style removes the border and background, making it suitable for text-only buttons.

Button("Borderless Button") {
    print("Borderless button tapped!")
}
.buttonStyle(BorderlessButtonStyle())

Plain Button Style

The plain button style is used for buttons that do not have any background or border, making them look like regular text.

Button("Plain Button") {
    print("Plain button tapped!")
}
.buttonStyle(PlainButtonStyle())

Bordered Button Style

The bordered button style adds a border around the button, making it stand out more.

Button("Bordered Button") {
    print("Bordered button tapped!")
}
.buttonStyle(BorderedButtonStyle())

Bordered Prominent Button Style

The bordered prominent button style is similar to the bordered style but with a more pronounced appearance, often used for primary actions.

Button("Bordered Prominent Button") {
    print("Bordered prominent button tapped!")
}
.buttonStyle(BorderedProminentButtonStyle())

Button with (SF) Symbols

You can also add icons to your buttons using (SF) Symbols.
This enhances the visual appeal and provides context to the button's action.

Button {
    print("Button with icon tapped!")
} label: {
    Label("Button with Icon", systemImage: "star.fill")
}

Use Case: Custom Button Styles

In this example, we will create a custom button style that changes the appearance of the button when tapped.

struct CustomButtonStyle: ButtonStyle {
    @Environment(\.isEnabled) var isEnabled

    func makeBody(configuration: Configuration) -> some View {
        configuration.label
            .padding()
            // Change the background color to green when pressed, blue otherwise
            // and gray when disabled.
            .background(isEnabled ? (configuration.isPressed ? Color.green : Color.blue) : Color.gray)
            .foregroundColor(.white)
            .clipShape(Capsule())
    }
}

Button("Custom Button") {
    print("Custom button tapped!")
}
.buttonStyle(CustomButtonStyle())

Best Practices for Using Buttons

Accessibility: Always ensure that buttons are accessible. Use descriptive labels and consider the size of the button for touch targets.
Feedback: Provide visual feedback when a button is tapped. This can be done using animations or changing the button style.
Consistency: Use consistent styles for buttons throughout your application to create a cohesive user experience.
Avoid Overloading: Don’t overload buttons with too many actions. Each button should have a clear and singular purpose.

Conclusion

Buttons are a fundamental part of user interaction in SwiftUI applications. By understanding how to use and customize buttons, you can enhance the usability and aesthetics of your app. Remember to follow best practices to ensure that your buttons are accessible, provide feedback, and maintain consistency across your application.

Surprise Route

Fri, 17 Oct 2025 22:37:29 +0200

In this post, I'll take you tough the process of creating my Surprise Route app in Swift(UI).
This app is designed to generate random routes for walking or biking, making your daily exercise routine more exciting and adventurous.

Introduction

What is Surprise Route?

Surprise Route is an app that generates a random route for you to explore, making your daily walks or runs more exciting. It takes your current location and creates a unique path that you can follow, ensuring you discover new areas and enjoy the journey.

Why Surprise Route?

Since a couple of weeks I'll try to walk or bike every day. I noticed that I often take the same routes, which can become monotonous. I wanted to create an app that would help me break out of this routine and explore new places in my neighborhood. That's how the idea for Surprise Route was born.

How does it work?

The app uses the current location and generates a random route by selecting random points within a certain radius. Then it asks to MapKit to create a path that connects these points, ensuring that the route is walkable or bikeable. The app also allows you to customize the distance and difficulty level of the route, making it suitable for different users.

Design

┌────────────────────────────────────────┐
| ╭────────────────────────────────────╮ |
| |          (Surprise Route)      (i) | |
| |                                    | |
| |              MAP VIEW              | |
| |              MAP VIEW              | |
| |              MAP VIEW              | |
| |              MAP VIEW              | |
| |              MAP VIEW              | |
| |              MAP VIEW              | |
| |              MAP VIEW              | |
| |              MAP VIEW              | |
| |              MAP VIEW              | |
| |              MAP VIEW              | |
| |              MAP VIEW              | |
| |              MAP VIEW              | |
| |              MAP VIEW              | |
| ╰────────────────────────────────────╯ |
├────────────────────────────────────────┤
| Generate a [walk]↕ route for [1 hour]↕ |
| ┌────────────────────────────────────┐ |
| | Distance    Duration    Waypoints  | |
| | 5 km        1 hour      9          | |
| └────────────────────────────────────┘ |
| ╭────────────────────────────────────╮ |
| |         ↗ Generate Route           | |
| ╰────────────────────────────────────╯ |
└────────────────────────────────────────┘

Final design of the app

Encountered challenges

Sometimes routes generate a "spike" to one street to enter that street and then return to the original path. This can happen due to the way the random points are selected or how the path is generated. I'm currently working on improving the algorithm to minimize these spikes and create smoother routes.
(see the screenshot in the details section above "Final design of the app")

Fun facts

The map is displayed using the UIKit version of MapKit, which allows to add overlays and annotations to the map. This makes it easy to visualize the route and see the points of interest along the way.
You can see where the waypoints are located on the map, go to ⓘ scroll to the bottom of the screen and enable "Show Waypoints". This helps you understand how the route is constructed.

Wrap up

In this post, we explored the process of creating the Surprise Route app in Swift(UI). We discussed its purpose, functionality, and the challenges faced during development. By leveraging the power of Swift and MapKit, we were able to create an app that encourages exploration and makes daily walks or runs more exciting.

SwiftUI Lists

Fri, 17 Oct 2025 22:37:30 +0200

Discover List in SwiftUI, a powerful way to display collections of data in a scrollable format. In this post, we will explore how to create lists, customize their appearance, and handle user interactions.

What is `List`?

List is a container that presents rows of data in a single-column layout. It can display static or dynamic content and supports various customization options, making it a versatile choice for presenting data in your SwiftUI applications.

Built-in List Styles

SwiftUI provides several built-in styles for lists, allowing you to change their appearance and behavior.

List Style	Description
`.plain`	A minimal style with no separators or grouping. Great for clean designs.
`.grouped`	Groups items into visually distinct sections, often used in settings views.
`.insetGrouped`	Like grouped, but with inset padding on larger screens (iPad, macOS).
`.sidebar`	Ideal for navigation sidebars. Collapsible groups are supported.
`.inset`	Provides subtle padding and separator lines.
`.automatic`	Lets the system choose the best style for the context.

I like to use the .grouped style for most of my lists, as it provides a good balance between aesthetics and usability.

Creating a Basic List

To create a basic list, you can use the List view with an array of data. Here's a simple example:

import SwiftUI

struct ContentView: View {
    let items = ["Apple", "Banana", "Cherry", "Date", "Elderberry"]

    var body: some View {
        List(items, id: \.self) { item in
            Text(item)
        }
        .navigationTitle("Fruits")
    }
}

This code creates a list of fruits, where each item is displayed as a Text view. The id: \.self parameter indicates that each item in the array is unique and can be used as an identifier.

Customizing List Appearance

You can customize the appearance of a list by applying modifiers. For example, you can change the font, add images, or apply background colors to each row:

import SwiftUI

struct ContentView: View {
    let items = ["Apple", "Banana", "Cherry", "Date", "Elderberry"]

    var body: some View {
        List(items, id: \.self) { item in
            Text(item)
                .font(.headline)
                .padding()
                .background(Color.yellow)
                .cornerRadius(8)
        }
        .navigationTitle("Fruits")
    }
}

This example applies a headline font, padding, a yellow background, and rounded corners to each item in the list.

Handling User Interactions

You can handle user interactions with list items by adding gestures or navigation links. For example, you
can navigate to a detail view when an item is tapped:

import SwiftUI
struct ContentView: View {
    let items = ["Apple", "Banana", "Cherry", "Date", "Elderberry"]

    var body: some View {
        NavigationView {
            List(items, id: \.self) { item in
                NavigationLink(destination: Text("Details for \(item)")) {
                    Text(item)
                }
            }
            .navigationTitle("Fruits")
        }
    }
}

In this example, tapping on an item navigates to a detail view that displays the selected fruit's name.

Customizing List Rows

You can create custom row views by defining a separate view for each row. This allows you to create complex layouts within each list item. Here's an example of a custom row view:

import SwiftUI

struct FruitRow: View {
    let fruit: String

    var body: some View {
        HStack {
            Text(fruit)
                .font(.headline)
            Spacer()
            Image(systemName: "chevron.right")
        }
        .padding()
    }
}
struct ContentView: View {
    let items = ["Apple", "Banana", "Cherry", "Date", "Elderberry"]

    var body: some View {
        NavigationView {
            List(items, id: \.self) { item in
                FruitRow(fruit: item)
            }
            .navigationTitle("Fruits")
        }
    }
}

In this example, the FruitRow view is used to create a custom row layout with a horizontal stack (HStack) that displays the fruit name and a chevron icon on the right side.

List Modifiers

SwiftUI provides several modifiers that you can apply to lists to customize their behavior and appearance. Here are some commonly used modifiers:

.listStyle(_:): Changes the style of the list (e.g., .plain, .grouped, .insetGrouped).
.navigationTitle(_:): Sets the title of the navigation bar when the list is embedded in a NavigationView.
.scrollIndicators(_:): Controls the visibility of scroll indicators in the list.
.onDelete(perform:): Enables swipe-to-delete functionality for list items.
.onMove(perform:): Enables drag-and-drop reordering of list items.

Here's an example of using some of these modifiers:

import SwiftUI

struct ContentView: View {
    @State private var items = ["Apple", "Banana", "Cherry", "Date", "Elderberry"]

    var body: some View {
        NavigationView {
            List {
                ForEach(items, id: \.self) { item in
                    Text(item)
                }
                .onDelete(perform: deleteItems)
                .onMove(perform: moveItems)
            }
            .navigationTitle("Fruits")
            .navigationBarItems(
                leading: EditButton(),
                trailing: Button(action: addItem) {
                    Image(systemName: "plus")
                }
            )
        }
    }

    private func deleteItems(at offsets: IndexSet) {
        items.remove(atOffsets: offsets)
    }

    private func moveItems(from source: IndexSet, to destination: Int) {
        items.move(fromOffsets: source, toOffset: destination)
    }

    private func addItem() {
        items.append("New Fruit \(items.count + 1)")
    }
}

This example demonstrates how to enable swipe-to-delete and drag-and-drop reordering of list items, as well as adding a button to add new items to the list.

Bonus: Indexed lists (SwiftUI)

In the code below, we will create an IndexedList view that displays a list of items grouped by their initial letter. This allows for quick navigation to sections of the list by tapping on the initial letters displayed on the right side of the view.

I've added a custom implementation of IndexedList that allows you to create a list with indexed letters on the right side, similar to the Contacts app on iOS. This implementation uses SwiftUI's List and ScrollViewReader to create a scrollable list with sections.

There are other ways to implement this, for example using a hosted UICollectionView or UITableView, but this implementation is purely in SwiftUI and leverages the power of SwiftUI's declarative syntax.

//
//  IndexedList.swift
//  SwiftExtras
//
//  Created by Wesley de Groot on 2025-07-22.
//  https://wesleydegroot.nl
//
//  https://github.com/0xWDG/SwiftExtras
//  MIT License
//

// This works in SwiftUI for both macOS and iOS, allowing you to create a list with indexed letters on the right side.
#if canImport(SwiftUI) && (os(macOS) || os(iOS))
import SwiftUI

/// IndexedList is a view that displays a list of items grouped by their initial letter.
/// It allows for quick navigation to sections of the list \
/// by tapping on the initial letters displayed on the right side of the view.
/// The list is scrollable and each item can be customized using a cell builder closure.
public struct IndexedList<Cell: View>: View {
    /// The data to be displayed in the list, grouped by initial letter.
    private let listData: [String: [String]]

    /// A closure that builds the view for each cell in the list.
    /// It takes a string (the item name) and returns a view of type `Cell
    private let cellBuilder: (String) -> Cell

    /// Initializes an IndexedList with a list of strings.
    /// The strings are grouped by their initial letter, \
    /// and each item is displayed using the provided cell builder closure.
    /// - Parameters:
    ///   - data: An array of strings to be displayed in the list.
    ///   - rowContent: A closure that takes a string and returns a \
    ///     view of type `Cell` to be used as the content for each row in the list.
    /// - Example:
    /// ```swift
    /// IndexedList(data: ["Apple", "Banana", "Cherry"]) { name in
    ///     Text(name)
    /// }
    /// ```
    public init(
        data: [String],
        @ViewBuilder rowContent: @escaping (String) -> Cell
    ) {
        // Grouping the data by the first letter of each string, converting it to uppercase
        // This creates a dictionary where the keys are the first letters and the values are arrays of strings
        // This allows for quick access to items based on their initial letter
        // The keys are sorted alphabetically to maintain a consistent order in the list
        listData = Dictionary(grouping: data) { name in
            String(name.prefix(1)).uppercased()
        }

        // Assigning the provided rowContent closure to the cellBuilder property
        // This closure will be used to build the view for each cell in the list
        self.cellBuilder = rowContent
    }

    /// The current index that is being hovered over or tapped.
    @State private var currentIndex: String?

    /// A list of index key frames used for determining the position of each indexed letter.
    /// This is used to handle hover and drag gestures for scrolling.
    @State private var indexKeyFrames: [IndexKeyInfo] = []

    /// The body of the IndexedList view.
    public var body: some View {
        // Sorting the keys of the listData dictionary to maintain a consistent order in the list
        // This ensures that the sections are displayed in alphabetical order based on the initial letter
        let sortedKeys = Array(listData.keys).sorted()

        // Using ScrollViewReader to allow programmatic scrolling to sections
        ScrollViewReader { proxy in
            // The main ZStack contains the background color, the List, and the indexed letter column
            ZStack(alignment: .topTrailing) {
                // MARK: - Background Color
                // Dynamic background color based on the platform
                bgColor

                // MARK: - List
                // List displaying the items grouped by their initial letter
                List {
                    // Using ForEach to iterate over the sorted keys of the listData dictionary
                    ForEach(sortedKeys, id: \.self) { key in
                        // Unwrapping the items for the current key
                        if let items = listData[key] {
                            // For each key, we create a section with the header as the key    
                            Section(header: Text(key).id(key)) {
                                // Using ForEach to iterate over the items in each section
                                ForEach(items, id: \.self) { name in
                                    // Building the cell using the provided cell builder closure
                                    cellBuilder(name)
                                }
                            }
                        }
                    }
                }
                // Add extra padding to the list to avoid clipping the indexed letter column
                .padding(.trailing, 10)
                // Hide the scroll indicators for a cleaner look
                .scrollIndicators(.hidden)

                // MARK: - Indexed Letter Column
                // Using a GeometryReader to create a vertical column of indexed letters
                // This column allows users to quickly navigate to sections of the list
                GeometryReader { geo in
                    // A vertical stack containing the indexed letters
                    VStack(spacing: 8) {
                        // Using ForEach to iterate over the sorted keys
                        // Each key is displayed as a tappable text view
                        ForEach(sortedKeys, id: \.self) { key in
                            // Displaying the key as a tappable text view
                            Text(key)
                                // Add a small font
                                .font(.caption2)
                                // Add accent color
                                .foregroundStyle(Color.accentColor)
                                // Add some padding
                                .padding(2)
                                // On tap gesture to scroll to the section corresponding to the key
                                .onTapGesture {
                                    proxy.scrollTo(key, anchor: .top)
                                }
                                // Zoom when hovering over the indexed letter
                                .scaleEffect(currentIndex == key ? 2.0 : 1.0)
                                // Adding a background to add the GeometryReader
                                .background(
                                    // Using GeometryReader to capture the frame of each index key
                                    // For enabling scrubbing on iOS
                                    GeometryReader { proxy in
                                        Color.clear.preference(
                                            key: IndexKeyPreferenceKey.self,
                                            value: [
                                                IndexKeyInfo(
                                                    key: key,
                                                    frame: proxy.frame(in: .global)
                                                )
                                            ]
                                        )
                                    }
                                )
                                // Accessibility traits to make it clear that this is a link
                                .accessibilityAddTraits(.isLink)
                                // Adding hover effect for macOS
                                .onHover { hovering in
                                    if hovering {
                                        currentIndex = key
                                        proxy.scrollTo(key, anchor: .top)
                                    }
                                }
                        }
                    }
                    // Add some trailing padding to the indexed letter column, \
                    // to avoid the text being too close to the edge
                    .padding(.trailing, 8)
                    // Make the height 100% of the available space, \
                    // so it will be centered vertically
                    .frame(maxHeight: .infinity)
                    // Add a drag gesture to allow scrolling through the index
                    // This is particularly useful for iOS where scrubbing is common
                    // The drag gesture updates the current index based on the location of the drag
                    // and scrolls the list to the corresponding section
                    .gesture(
                        // Drag gesture to allow scrolling through the index
                        // For enabling scrubbing on iOS
                        DragGesture(minimumDistance: 1)
                            .onChanged { value in
                                // Check if the current index is nil or if it has changed
                                if let match = indexForLocation(
                                    value.location,
                                    in: geo.frame(in: .global),
                                    keyFrames: indexKeyFrames
                                ) {
                                    // If the current index is nil or has changed, update it and scroll to the section
                                    if currentIndex != match {
                                        currentIndex = match
                                        proxy.scrollTo(match, anchor: .top)
                                    }
                                }
                            }
                            .onEnded { _ in
                                // Reset the current index when the gesture ends
                                currentIndex = nil
                            }
                    )
                }
                // Add a preference key to capture the frames of the indexed letters
                .onPreferenceChange(IndexKeyPreferenceKey.self) { values in
                    self.indexKeyFrames = values
                }
                // Set the frame width of the indexed letter column
                // This ensures that the column has a fixed width for consistency
                // and to avoid layout issues
                .frame(width: 24)
            }
        }
    }

    /// A background color for the IndexedList view.
    /// This color adapts to the platform.
    /// - Returns: A `Color` that represents the background color of the IndexedList view.
    private var bgColor: some View {
#if os(macOS)
        Color(NSColor.windowBackgroundColor)
#else
        Color(UIColor.systemGroupedBackground)
#endif
    }

    /// Determines the index key for a given location in the indexed letter column.
    /// This function checks if the location falls within the frame of any indexed letter.
    /// - Parameters:
    ///   - location: The CGPoint representing the location of the gesture.
    ///   - container: The CGRect representing the frame of the indexed letter column.
    ///   - keyFrames: An array of `IndexKeyInfo` containing the keys and their corresponding frames.
    /// - Returns: The key of the indexed letter that corresponds to the location, or `nil` if no match is found.
    private func indexForLocation(
        _ location: CGPoint,
        in container: CGRect,
        keyFrames: [IndexKeyInfo]
    ) -> String? {
        // Check if the location is within the bounds of the indexed letter column
        for info in keyFrames where info.frame.contains(CGPoint(x: container.midX, y: location.y)) {
            return info.key
        }

        return nil
    }
}

// MARK: - IndexKeyInfo and PreferenceKey
/// A struct that holds information about an indexed letter key and its frame.
/// This is used to capture the frames of the indexed letters for scrubbing functionality.
/// It conforms to `Equatable` to allow comparison between instances.
struct IndexKeyInfo: Equatable {
    let key: String
    let frame: CGRect
}

/// A preference key that collects `IndexKeyInfo` instances.
/// This is used to store the frames of the indexed letters in the IndexedList view.
/// It conforms to `PreferenceKey` to allow the IndexedList view to update its state based \
/// on the frames of the indexed letters.
struct IndexKeyPreferenceKey: PreferenceKey {
    static var defaultValue: [IndexKeyInfo] = []
    static func reduce(value: inout [IndexKeyInfo], nextValue: () -> [IndexKeyInfo]) {
        value.append(contentsOf: nextValue())
    }
}

// MARK: - Preview
// To Preview the IndexedList in SwiftUI previews, you can use the following code snippet:
#Preview {
    IndexedList(data: [
        "Wesley", "Carlo", "Uneata", "Anne", "Bram", "Sanne", "Daan", "Lieke", "Milan",
        "Femke", "Joris", "Tess", "Thijs", "Noa", "Sem", "Lars", "Lotte", "Max", "Eva",
        "Luuk", "Nina", "Finn", "Roos", "Janneke", "Gijs", "Isa", "Koen", "Sofie", "Tijn",
        "Maud", "Ruben", "Evi", "Siem", "Luca", "Bo", "Jelle", "Fleur", "Mees", "Yara",
        "Pim", "Elin", "Stijn", "Mare", "Noud", "Saar", "Tim", "Bente", "Jochem", "Ilse",
        "Pepijn", "Marit", "Teun", "Milou", "Jip", "Jet", "Bas", "Anouk", "Timo", "Veerle",
        "Floris", "Lana", "Jens", "Mila", "Job", "Loes", "Cas", "Tirza", "Nick", "Fenna",
        "Hidde", "Lynn", "Dirk", "Jade", "Mark", "Iris", "Bart", "Elise", "Wout", "Norah",
        "Maarten", "Nora", "Kees", "Tessa", "Rik", "Amber", "Nathan", "Vera", "Roel", "Zara",
        "Jan", "Esmee", "Tom", "Britt", "Stef", "Demi", "Arjen", "Floor", "Johan", "Liv",
        "Harm", "Romy", "Martijn", "Suze", "Kees"
    ]) { name in
        Text(name)
    }
}
#endif

Conclusion

You can easily create lists in SwiftUI using the List view. With its built-in styles and customization options, you can present data in a visually appealing and interactive way. Whether you're displaying simple text or complex custom views, List provides a powerful tool for building user interfaces in SwiftUI.

Interpolation and formatting in Text

Fri, 17 Oct 2025 22:37:30 +0200

In this post, we will explore how to use interpolation and formatting in SwiftUI's Text view. This is a powerful feature that allows you to create dynamic and formatted text easily.

What is `Interpolation and Formatting`?

Interpolation and formatting in SwiftUI's Text view refer to the ability to insert dynamic values into text strings and apply various formatting options. This allows developers to create rich, user-friendly text displays that can change based on user input or other data.

Interpolation in SwiftUI

Interpolation in SwiftUI allows you to embed variables and expressions directly within a string. You can use string interpolation by wrapping your variables in parentheses and prefixing them with a backslash. Here's an example:

import SwiftUI

struct ContentView: View {
    let name = "Wesley"
    let age = 35

    var body: some View {
        Text("Hello, my name is \(name) and I am \(age) years old.")
    }
}

In this example, the Text view displays a greeting message that includes the name and age variables.

Formatting in SwiftUI

Formatting in SwiftUI allows you to control how values are displayed, such as arrays.

import SwiftUI

struct ContentView: View {
    var body: some View {
        let pokemon = ["Dragonite", "Lugia", "Pikachu"]

        Text("Favorite Pokemon: \(pokemon, format: .list(type: .and))")
        // Favorite Pokemon: Dragonite, Lugia and Pikachu
    }
}

In this example, the Text view formats the pokemon array into a list format, automatically handling the conjunction for the last item.

import SwiftUI

struct ContentView: View {
    var body: some View {
        let pokemon = ["Dragonite", "Lugia", "Pikachu"]

        Text("Favorite Pokemon: \(pokemon, format: .list(type: .and))")
            .environment(\.locale, Locale(identifier: "nl"))
        // Favorite Pokemon: Dragonite, Lugia en Pikachu
    }
}

Formatting Measurements

You can also format measurements in SwiftUI. For example, if you have a measurement in meters and want to display it in kilometers, you can do the following:

import SwiftUI

struct ContentView: View {
    var body: some View {
        let distance = Measurement(value: 1000, unit: UnitLength.meters)

        // You walked 3,281 mi.
        Text("You walked \(distance, format: .measurement(width: .abbreviated)).")
            .environment(\.locale, Locale(identifier: "en_US"))

        // You walked 1 km.
        Text("You walked \(distance, format: .measurement(width: .abbreviated)).")
            .environment(\.locale, Locale(identifier: "nl"))
    }
}

Caveats

While interpolation and formatting in SwiftUI's Text view are powerful, there are some caveats to keep in mind:

Performance: Excessive use of interpolation and formatting can lead to performance issues, especially in complex views. Use them judiciously.
Localization: When using interpolation and formatting, ensure that your strings are localized properly to support different languages and regions. SwiftUI provides tools for localization, but you need to manage your strings carefully.

Wrap up

In this post, we explored how to use interpolation and formatting in SwiftUI's Text view. By leveraging these features, you can create dynamic and user-friendly text displays that adapt to your app's needs.

Resources:

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

Placing components within the Safe Area Inset

Fri, 17 Oct 2025 22:37:31 +0200

In this post, we will explore how to effectively place components within the Safe Area Inset in SwiftUI applications.

What is `Safe Area Inset` and `.safeAreaInset` modifier?

The Safe Area Inset is a layout guide in iOS that defines the portion of the screen where content can be safely displayed without being obscured by system UI elements like the status bar, navigation bar, and home indicator. In SwiftUI, the Safe Area Inset is automatically taken into account when laying out views, but there are times when you may want to customize the placement of your components within this area.
The safeAreaInset(edge:alignment:spacing:content:) modifier allows you to specify additional padding for your views, ensuring they remain within the safe area.

Use Case: Display an important view at all times

import SwiftUI

struct SafeAreaInset: View {
    var body: some View {
        ZStack {
            LinearGradient(colors: [.black, .blue], startPoint: .top, endPoint: .bottom)
                .ignoresSafeArea()

            VStack(spacing: 20) {
                Text("Safe Area Insets Example")
                    .font(.title)
                    .fontWeight(.bold)
                    .foregroundColor(.white)
            }
        }
        .safeAreaInset(edge: .bottom) {
            Text("I am inset from the bottom safe area")
                .foregroundStyle(.white)
        }
    }
}

#Preview {
    SafeAreaInset()
}

Caveats

When using Safe Area Insets, it's important to be aware of the following caveats:

Dynamic Content: If your content changes dynamically (e.g., due to user input or network responses), you may need to adjust your layout accordingly to ensure it remains within the safe area.
Device Variability: Different devices have different safe area insets (e.g., iPhones with and without a notch). Always test your layout on multiple devices to ensure a consistent experience.
Overlapping Views: Be cautious when layering views. If you have overlapping views, make sure they respect the safe area insets to avoid being obscured by system UI elements.

Wrap up

Safe area insets are a crucial aspect of designing user interfaces in iOS applications. By understanding and utilizing safe area insets, you can ensure that your content is displayed correctly and is not obscured by system UI elements.

Resources:

https://developer.apple.com/documentation/swiftui/view/safeareainset(edge:alignment:spacing:content:)-6gwby

Building Editable Lists in SwiftUI

Fri, 17 Oct 2025 22:37:32 +0200

In this post, we will explore how to create editable lists in SwiftUI using a couple of different approaches using EditButton(), @Environment(\.editMode) and custom EditMode state.

What is `List`, `EditButton()`, `EditMode` and `@Environment(\.editMode)`?

List is a SwiftUI view that presents a scrollable list of rows. It is commonly used to display collections of data in a structured way.

The EditButton() is a built-in SwiftUI button that toggles the edit mode of a view. When tapped, it switches the view between editing and non-editing states, please note this will only update the List's edit mode, it cannot be read from somewhere else in the view.

The EditMode is an enumeration that represents the different states of a view's edit mode. It has two cases we want to use .inactive and .active.

The @Environment(\.editMode) property wrapper allows you to access the current edit mode of the view, enabling you to create editable lists.

Example `List` with `EditButton()`

To create an editable list, you can use the List view in combination with EditButton().

struct Pokemon: Identifiable {
    let id: UUID
    let name: String

    init(name: String) {
        self.id = UUID()
        self.name = name
    }
}

struct EditModeView: View {
    @State private var pokemon: [Pokemon] = [
        .init(name: "Dragonite"),
        .init(name: "Lugia"),
        .init(name: "Pikachu"),
        .init(name: "Mewtwo")
    ]

    @State private var selectedIems: Set<UUID> = []

    var body: some View {
        NavigationStack {
            List(selection: $selectedIems) {
                ForEach(pokemon) { pokemon in
                    Text(pokemon.name)
                }
                .onDelete { pokemon.remove(atOffsets: $0) }
                .onMove { pokemon.move(fromOffsets: $0, toOffset: $1) }
            }
            .toolbar {
                ToolbarItem(placement: .primaryAction) {
                    EditButton()
                }
            }
        }
    }
}

#Preview {
    EditModeView()
}

Example `List` and `@Environment(\.editMode)`

To create an editable List using @Environment(\.editMode), you can follow this example:

struct EditModeView: View {
    @Environment(\.editMode) private var editMode
    @State private var name = "Firstname Lastname"

    var body: some View {
        NavigationStack {
            Form {
                if editMode?.wrappedValue.isEditing == true {
                    TextField("Name", text: $name)
                } else {
                    Text(name)
                }
            }
            .animation(nil, value: editMode?.wrappedValue)
            .toolbar {
                EditButton()
            }
        }
    }
}

#Preview {
    EditModeView()
}

Example `List` with custom `EditMode`

To create an editable List using a custom EditMode state, you can follow this example:

import SwiftUI

struct Pokemon: Identifiable {
    let id: UUID
    let name: String

    init(name: String) {
        self.id = UUID()
        self.name = name
    }
}

struct EditModeView: View {
    // Custom edit mode.
    @State var editMode: EditMode = .inactive

    @State private var pokemon: [Pokemon] = [
        .init(name: "Dragonite"),
        .init(name: "Lugia"),
        .init(name: "Pikachu"),
        .init(name: "Mewtwo")
    ]

    @State private var selectedIems: Set<UUID> = []

    var body: some View {
        NavigationStack {
            List(selection: $selectedIems) {
                ForEach(pokemon) { pokemon in
                    Text(pokemon.name)
                }
                .onDelete { pokemon.remove(atOffsets: $0) }
                .onMove { pokemon.move(fromOffsets: $0, toOffset: $1) }
            }
            // Tell the List that we are if editting
            .environment(\.editMode, $editMode)
            .toolbar {
                ToolbarItem(placement: .primaryAction) {
                    // Toggle editmode
                    Button(editMode.isEditing ? "Done" : "Edit") {
                        withAnimation {
                            editMode = editMode.isEditing ? .inactive : .active
                        }
                    }
                }

                ToolbarItem(placement: .bottomBar) {
                    VStack {
                        Text("Selected: \(selectedIems.count), edit mode: \(editMode.isEditing)")

                        HStack {
                            if selectedIems.isEmpty {
                                Button("Select All") {
                                    selectedIems.formUnion(pokemon.map(\.id))
                                    editMode = .active
                                }
                            } else {
                                Button("Deselect All") {
                                    selectedIems.removeAll()
                                    editMode = .inactive
                                }
                            }

                            Spacer()

                            Button("Delete") {
                                pokemon.removeAll(where: {
                                    selectedIems.contains($0.id)
                                })
                                selectedIems = []
                                editMode = .inactive
                            }
                            .disabled(selectedIems.isEmpty)
                            .disabled(!editMode.isEditing)
                            .frame(maxWidth: .infinity)
                        }
                    }
                    .frame(maxWidth: .infinity)
                }
            }
        }
    }
}

#Preview {
    EditModeView()
}

Caveats

@Environment(\.editMode) only passes the EditMode to the List/Form and will not be updated anywhere else, that's why you need to manage the edit mode state manually if you want to support "Select All", "Deselect All", and "Delete" as a button.

Wrap up

In this article, we explored how to create editable lists in SwiftUI using a custom edit mode. We covered the basics of managing selection and deletion of items, as well as how to toggle edit mode. With these techniques, you can create more interactive and user-friendly list interfaces in your SwiftUI applications.

Resources:

Building SwiftUI Debugging Utilities

Fri, 17 Oct 2025 22:37:32 +0200

In this post, we will explore how to create debugging utilities in SwiftUI to help diagnose and fix issues in your app.

Printing values

As you may know already you cannot use print() directly in your SwiftUI code.

struct ContentView: View {
    var body: some View {
        Text("Hello, World!")
        let _ = print("This is a debug message") // Print in the supported way
    }
}

A way to achieve this functionality is creating a extension on View.

extension View {
    func print(_ value: Any) -> Self {
        Swift.print(value) // Swift.print to tell Swift that we want to use the native print function
        return self
    }
}

now we can use:

struct ContentView: View {
    var body: some View {
        Text("Hello, World!")
            .print("This is a debug message")
    }
}

Perform custom debugging actions

Sometimes you want to execute code only on the debug build.
One way is:

struct ContentView: View {
    var body: some View {
        Text("Hello, World!")
#if DEBUG
            .print("This is a debug message")
#endif
    }
}

A better way to achieve this functionality is creating a extension on View.

extension View {
    func debugAction(_ closure: () -> Void) -> Self {
        #if DEBUG
        closure()
        #endif

        return self
    }
}

now we can use:

struct ContentView: View {
    var body: some View {
        Text("Hello, World!")
            .debugAction {
                print("This is a debug message")
            }
    }
}

Debugging view borders

Sometimes you want to see where the views are located on the screen. You can achieve this by adding borders to your views.

extension View {
    func debugBorder(_ color: Color = .red) -> some View {
#if DEBUG
        self.border(color, width: 2)
#else
        self
#endif
    }
}

Now we can use:

struct ContentView: View {
    var body: some View {
        Text("Hello, World!")
            .debugBorder()
    }
}

Conclusion

Writing a pair of functions to print debug messages and add borders to views can greatly enhance the debugging experience in SwiftUI. By using conditional compilation and view extensions, we can create a clean and efficient debugging workflow.

Remove the background from images using Swift

Fri, 17 Oct 2025 22:37:33 +0200

Removing backgrounds from images is a common task in modern apps, whether for photo editing, social media, or automation. In this article, you'll learn how to build a cross-platform background remover in Swift using Apple's Vision and Core Image frameworks. We'll walk through the concepts, code, and practical tips to help you integrate this feature into your iOS or macOS projects.

Technologies Used

Swift
Core Image
Vision Framework
UIKit / AppKit

Why Background Removal?

Background removal lets you isolate subjects, create transparent images, and enhance user experiences. Apple's Vision framework makes this possible with powerful machine learning tools, while Core Image handles image processing. We'll use both to create a reusable Swift class.

Note: This implementation is cross-platform (iOS & macOS) For a ready-to-use version use SwiftExtras.

Step 1: Cross-Platform Setup

We'll create a BackgroundRemover class that works on both iOS and macOS. To handle platform differences, we use a typealias for the image type: NSImage for macOS and UIImage for iOS.

@available(iOS 17.0, macOS 14.0, *)
class BackgroundRemover {
#if os(macOS)
    // Support macOS
    typealias PlatformNativeImage = NSImage
#else
    // Support iOS
    typealias PlatformNativeImage = UIImage
#endif
}

Step 2: Error Handling

To make our code robust, we define custom errors for common failure cases. This helps with debugging and makes the API safer to use.

enum Errors: Error {
    case failedToUnwrapImage
    case failedToCreateCIImage
    case failedToRenderCGImage
    case failedToApplyMask
    case failedToCreateMask
    case invalidImageData
}

Step 3: Generate the Foreground Mask

The Vision framework can detect the subject in an image and create a mask. This mask is used to separate the foreground from the background.

Key APIs:

⚠️ Note: This code does not run on the iOS simulator due to Vision framework limitations. Use a real device or macOS.

private func createMask(from inputImage: CIImage) -> CIImage? {
    // Create a request to generate the foreground instance mask
    let request = VNGenerateForegroundInstanceMaskRequest()
    // Create a handler to perform the request
    let handler = VNImageRequestHandler(ciImage: inputImage)
    do {
        // Perform the request
        try handler.perform([request])
        // Get the first result
        if let result = request.results?.first {
            // Generate the mask from the result
            let mask = try result.generateScaledMaskForImage(
                forInstances: result.allInstances,
                from: handler
            )

            // Return the mask as a CIImage
            return CIImage(cvPixelBuffer: mask)
        }
    } catch {
        // Something went wrong
        print(error)
    }

    // Something went wrong
    return nil
}

Step 4: Apply the Mask to Remove the Background

With the mask generated, we use Core Image to blend the mask with the original image, effectively removing the background.

Key APIs:

CIFilter.blendWithMask() (requires import CoreImage.CIFilterBuiltins)

private func applyMask(mask: CIImage, to image: CIImage) -> CIImage? {
    // Create a blend filter
    let filter = CIFilter.blendWithMask()
    // Set the input image
    filter.inputImage = image
    // Set the mask image
    filter.maskImage = mask
    // Set the background image to be empty
    filter.backgroundImage = CIImage.empty()
    // Return the output image
    return filter.outputImage
}

Step 5: Render the Final Image

After applying the mask, we render the result to a platform-native image type (UIImage or NSImage).

Key APIs:

private func removeBackground(from inputImage: CIImage) throws -> PlatformNativeImage {
    // Create a CIContext to render the output image
    let context = CIContext(options: nil)

    // Create a mask image, see createMask(from:)
    guard let maskImage = createMask(from: inputImage) else {
        throw Errors.failedToCreateMask
    }
    // Apply the mask to the input image, see applyMask(mask:to:)
    guard let outputImage = applyMask(mask: maskImage, to: inputImage) else {
        throw Errors.failedToApplyMask
    }

    // Render the output image
    guard let cgImage = context.createCGImage(outputImage, from: outputImage.extent) else {
        throw Errors.failedToRenderCGImage
    }

    #if os(iOS)
    return PlatformNativeImage(cgImage: cgImage)
    #else
    return PlatformNativeImage(cgImage: cgImage, size: CGSize(width: cgImage.width, height: cgImage.height))
    #endif
}

Step 6: Parse and Remove the Background

The parse(image:) method ties everything together. It converts the input image to a CIImage, processes it, and returns the result with the background removed.

/// Parses the image and removes the background.
///
/// - Parameter image: The image to parse.
/// - Returns: The image with the background removed.
public func parse(image: PlatformNativeImage) throws -> PlatformNativeImage {
#if os(iOS)
    guard let ciImage = CIImage(image: image) else {
        throw Errors.failedToCreateCIImage
    }
#else
    guard let cgImage = image.cgImage(forProposedRect: nil, context: nil, hints: nil) else {
        throw Errors.failedToCreateCIImage
    }
    let ciImage = CIImage(cgImage: cgImage)
#endif

    return try removeBackground(from: ciImage)
}

Complete Implementation

#if canImport(Vision) && canImport(CoreImage.CIFilterBuiltins)
import Vision
import CoreImage.CIFilterBuiltins
#if canImport(UIKit)
import UIKit
#endif
#if canImport(AppKit)
import AppKit
#endif

@available(iOS 17.0, macOS 14.0, *)
class BackgroundRemover {
    enum Errors: Error {
        /// Failed to unwrap the image.
        case failedToUnwrapImage

        /// Failed to create a CIImage from the input image.
        case failedToCreateCIImage

        /// Failed to render the CGImage.
        case failedToRenderCGImage

        /// Failed to apply the mask to the image.
        case failedToApplyMask

        /// Failed to create the mask.
        case failedToCreateMask

        /// Invalid image data.
        case invalidImageData
    }

#if os(macOS)
    /// Platform-specific image type. (macOS)
    typealias PlatformNativeImage = NSImage
#else
    /// Platform-specific image type. (iOS)
    typealias PlatformNativeImage = UIImage
#endif

    /// Removes the background from the image.
    ///
    /// - Parameter inputImage: The image from which to remove the background.
    /// - Returns: The image with the background removed.
    private func removeBackground(from inputImage: CIImage) throws -> PlatformNativeImage {
        // Create a CIContext to render the output image
        let context = CIContext(options: nil)

        // Create a mask image, see createMask(from:)
        guard let maskImage = createMask(from: inputImage) else {
            throw Errors.failedToCreateMask
        }
        // Apply the mask to the input image, see applyMask(mask:to:)
        guard let outputImage = applyMask(mask: maskImage, to: inputImage) else {
            throw Errors.failedToApplyMask
        }

        // Render the output image
        guard let cgImage = context.createCGImage(outputImage, from: outputImage.extent) else {
            // Failed to render CGImage
            throw Errors.failedToRenderCGImage
        }

        // Create the final output image
#if os(iOS)
        return PlatformNativeImage(cgImage: cgImage)
#else
        return PlatformNativeImage(cgImage: cgImage, size: CGSize(width: cgImage.width, height: cgImage.height))
#endif
    }

    /// Creates a mask from the input image.
    ///
    /// - Parameter inputImage: The image from which to create the mask.
    /// - Returns: The mask image, or nil if creation failed.
    private func createMask(from inputImage: CIImage) -> CIImage? {
        // Create a request to generate the foreground instance mask
        let request = VNGenerateForegroundInstanceMaskRequest()
        // Create a handler for the image request
        let handler = VNImageRequestHandler(ciImage: inputImage)

        do {
            // Perform the request
            try handler.perform([request])
            // Get the first result
            if let result = request.results?.first {
                // Generate the mask for the image
                let mask = try result.generateScaledMaskForImage(
                    forInstances: result.allInstances,
                    from: handler
                )

                // Create the final mask image
                return CIImage(cvPixelBuffer: mask)
            }
        } catch {
            // Failed to generate mask
            print(error)
        }

        // Failed to generate mask
        return nil
    }

    /// Applies the mask to the image.
    ///
    /// - Parameters:
    ///   - mask: The mask image to apply.
    ///   - image: The image to which the mask will be applied.
    /// - Returns: The image with the mask applied, or nil if the operation failed.
    private func applyMask(mask: CIImage, to image: CIImage) -> CIImage? {
        // Create a blend filter
        let filter = CIFilter.blendWithMask()
        // Set the input image
        filter.inputImage = image
        // Set the mask image
        filter.maskImage = mask
        // Set the background image to be empty
        filter.backgroundImage = CIImage.empty()
        // Return the output image
        return filter.outputImage
    }

    /// Removes the background from the image.
    ///
    /// - Parameter image: The image from which to remove the background.
    /// - Returns: The image with the background removed.
    public func parse(image: PlatformNativeImage) throws -> PlatformNativeImage {
#if os(iOS)
        // iOS: Create a CIImage from the UIImage
        guard let ciImage = CIImage(image: image) else {
            throw Errors.failedToCreateCIImage
        }
#else
        // macOS: Create a CIImage from the NSImage
        guard let cgImage = image.cgImage(forProposedRect: nil, context: nil, hints: nil) else {
            throw Errors.failedToCreateCIImage
        }
        let ciImage = CIImage(cgImage: cgImage)
#endif

        // Remove the background from the image
        return try removeBackground(from: ciImage)
    }
}

For a production-ready version and more utilities, see SwiftExtras on GitHub.

Wrap Up

With just a few lines of Swift, you can leverage Apple's frameworks to perform advanced image background removal on both iOS and macOS. This approach is efficient, easy to integrate, and can be extended for more complex use cases.

Conclusion

You now have a solid foundation for implementing background removal in Swift. Experiment with the code, adapt it to your needs, and explore the resources below for further reading and inspiration.

Further Resources:

Custom Tabbar with SwiftUI

Fri, 17 Oct 2025 22:37:33 +0200

In this post, we will explore how to create a custom tab bar using SwiftUI.

What is a `TabView`?

A TabView is a user interface component that allows users to switch between different views or sections of an app. Unlike the default tab bar provided by SwiftUI, a custom tab bar can be tailored to fit the specific design and functionality needs of your application.

How to Build a Custom TabBar in SwiftUI

SwiftUI’s built-in TabView is great for quick setups, but sometimes you want more control over the look and feel of your app’s navigation. Whether you're aiming for a sleek, animated tab bar or something that matches your brand’s aesthetic, building a custom tab bar in SwiftUI is surprisingly approachable.

Step 1: Define Your Tab Items

We'll start by creating a model to represent each tab:

enum TabItem: String, CaseIterable {
    case home = "house"
    case search = "magnifyingglass"
    case profile = "person"

    var title: String {
        switch self {
        case .home: return "Home"
        case .search: return "Search"
        case .profile: return "Profile"
        }
    }
}

Step 2: Create the Custom Tab Bar View

Now let’s build the tab bar UI:

struct CustomTabBar: View {
    // This will update our selected tab
    @Binding var selectedTab: TabItem

    var body: some View {
        HStack {
            // Walk through each tab item
            ForEach(TabItem.allCases, id: \.self) { tab in
                // Add a spacer (before the item)
                Spacer()
                VStack {
                    // Tab icon
                    Image(systemName: tab.rawValue)
                        .font(.system(size: 20, weight: .bold))

                    // Tab title
                    Text(tab.title)
                        .font(.caption)
                }
                // By placing the foregroundColor modifier here, the color gets changed in all components in our VStack.
                .foregroundColor(selectedTab == tab ? .blue : .gray)
                // On tap, we update the selected tab with animation.
                .onTapGesture {
                    withAnimation {
                        selectedTab = tab
                    }
                }
                // This makes the entire tab area accessible
                .accessibilityAddTraits(.isButton)
                // Add a spacer (after the item)
                Spacer()
            }
        }
        .padding()
        // Set the background color and shadow
        .background(
            Color(.systemBackground)
                .shadow(radius: 2)
        )
    }
}

This view uses @Binding so it can update the selected tab from the parent view.

Step 3: Create the Main View

Now let’s create the main view that uses the custom tab bar:

struct ContentView: View {
    // This will save our selected tab
    @State private var selectedTab: TabItem = .home

    var body: some View {
        VStack {
            switch selectedTab {
            case .home:
                Text("Home") // Replace with your Home view
            case .search:
                Text("Search") // Replace with your Search view
            case .profile:
                Text("Profile") // Replace with your Profile view
            }
        }
        // We'll set the max width and height to fill the available space
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        // We'll place our custom tab bar in the safe area.
        .safeAreaInset(edge: .bottom) {
            CustomTabBar(selectedTab: $selectedTab)
        }
    }
}

Each tab displays a different view, and the tab bar sits at the bottom.

Screenshot

Conclusion

Building a custom tab bar in SwiftUI is a straightforward process that allows for a high degree of customization, it is a great way to enhance the user experience in your app.

Resources:

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

Hidden macOS features

Fri, 17 Oct 2025 22:37:34 +0200

In this post we're going to explore some hidden features of macOS that can enhance your productivity and improve your workflow.

Move a file.

To move a file in finder you can use ⌘C (Command + C) to copy the file,
then navigate to the destination folder and use command ⌘⌥V (Command + Option + V) to move the file instead of copying it.

Hidden menu options.

A lot of menu options are hidden, you can reveal them by holding down the Option key while clicking on the menu. This will often show additional options that are not visible by default.

Resizing windows.

You can quickly resize windows by holding down the Option key while dragging the edges or corners. This will allow you to resize the window from the center, rather than from the edge.

Apple Logo

You can type Option + Shift + K to quickly insert the Apple logo () in your documents.

Screenshot a window

Press Command + Shift + 4 to enter screenshot mode, then press the Space bar to switch to window mode. Click on the window you want to capture.

Screenshot to clipboard

Holding control while taking a screenshot immediately saves it to the clipboard.

Screen Recording

Press Command + Shift + 5 to enter screen recording mode. You can choose to record the entire screen or a selected portion.

Open Settings

Press Command + , (Command + Comma) to quickly open the settings of the currently open application.

Move cursor quickly in the terminal.

Option click in terminal jumps your cursor to that position in the terminal.

Quick Look

Press the Space bar while a file is selected in Finder to quickly preview the file without opening it.

No state restoration

Shift + Click on an app in the Dock will reset its state before opening it.

Cycle between windows of the current application.

Press Command + ` (Command + Backtick) to quickly cycle between windows of the current application.
(On some keyboards, try the ~ (tilde) key instead)

Hide current application

Press Command + H (Command + H) to quickly hide the currently active application.

(Un)hide the dock

Press Command + Option + D (Command + Option + D) to quickly hide or show the dock.

Sensory feedback in SwiftUI

Fri, 17 Oct 2025 22:37:34 +0200

This post explores the concept of sensory feedback in SwiftUI, a modifier to provide feedback to users based on their interactions.

What is `Sensory Feedback in SwiftUI`?

Sensory Feedback in SwiftUI is a powerful feature that allows developers to create responsive and interactive user interfaces. It enables the triggering of actions and updates in the UI based on user interactions or changes in data.

Sensory feedback can include haptic feedback, sound effects, and visual cues that enhance the user experience by providing immediate and relevant responses to user actions.

What are the options

.sensoryfeedback(_:trigger:) allows you to specify the type of feedback and the trigger for that feedback.

.success: Indicates that a task or action has completed.
.warning: Indicates that a task or action has produced a warning of some kind.
.error: Indicates that an error has occurred.

Use Case: Button Press Feedback

In this example, we provide haptic feedback when a button is pressed:

import SwiftUI

struct ContentView: View {
    @State private var action = true
    var body: some View {
        Button("Tap me") {
            action.toggle()
        }
        .sensoryFeedback(.success, trigger: action)
    }
}

Use Case: Button Press Feedback (Custom intensity)

In this example, we provide haptic feedback with custom intensity when a button is pressed:

struct ContentView: View {
    @State private var trigger = false

    var body: some View {
        NavigationStack {
            Button("Action") {
                // do something
                trigger.toggle()
            }
            .sensoryFeedback(
                .impact(weight: .heavy, intensity: 0.9),
                trigger: trigger
            )
        }
    }
}

Use Case Button Press Feedback (based on value)

In this example, we provide haptic feedback based on the value of a state variable when a button is pressed:

import SwiftUI

struct ContentView: View {
    @State private var action = true
    var body: some View {
        Button("Tap me") {
            action.toggle()
        }
        .sensoryFeedback(trigger: action) { oldValue, newValue in
            return newValue.isEmpty ? .error : .success
        }
    }
}

Caveats

While Sensory Feedback in SwiftUI can greatly enhance user interactions, it's important to use it judiciously. Overusing haptic feedback or other sensory cues can lead to a cluttered user experience. Always consider the context and the user's needs when implementing these features.

Wrap up

In summary, Sensory Feedback in SwiftUI is a valuable tool for creating responsive and interactive user interfaces. By providing immediate feedback based on user interactions, it can significantly enhance the overall user experience.

Conclusion

In conclusion, Sensory Feedback in SwiftUI is an essential aspect of modern app development. By incorporating haptic feedback, sound effects, and visual cues, developers can create more engaging and intuitive user experiences. As you explore SwiftUI, consider how you can leverage these features to improve your app's interactivity and responsiveness.

Resources:

Hacktoberfest 2025

Fri, 17 Oct 2025 22:37:35 +0200

What is Hacktoberfest?

Why Should Swift Developers Participate?

Skill Enhancement: Contributing to open-source projects allows you to work on real-world problems, enhancing your coding skills and learning new techniques.
Community Engagement: Hacktoberfest is a great way to connect with other developers, share knowledge, and collaborate on exciting projects.
Portfolio Building: Contributions to open-source projects are a valuable addition to your portfolio, showcasing your skills to potential employers.
Giving Back: Open source thrives on community contributions. By participating, you help improve the tools and libraries that you and others use daily.

Getting Started with Hacktoberfest

Sign Up: Register for Hacktoberfest on the official website.
Find Projects: Look for Swift projects that need contributions. You can filter repositories by language on GitHub to find Swift-specific projects.
Read the Guidelines: Each project has its own contribution guidelines. Make sure to read and follow them to ensure your PRs are accepted.
Start Contributing: Begin by tackling issues labeled "Hacktoberfest" or "good first issue." These are typically beginner-friendly and a great way to get started.

Tips for Successful Contributions

Communicate: Engage with project maintainers and other contributors. Ask questions if you're unsure about something.
Write Clear PRs: Ensure your pull requests are well-documented and clearly explain the changes you've made.
Test Thoroughly: Make sure your code works as expected and doesn't introduce new bugs.
Be Respectful: Open-source communities thrive on respect and collaboration. Be courteous and constructive in your interactions.

Recommended Swift Projects for Hacktoberfest

Here are a few Swift projects that welcome contributions:

AuroraEditor: Aurora Editor is a IDE built by the community, for the community, and written in Swift for the best native performance and feel for macOS.
SwiftLint: A tool to enforce Swift style and conventions.
Vapor: A web framework for Swift.
All of my SPM projects
Search on Hacktoberfest on GitHub, GitLab.

Conclusion

For more information and to register, visit the Hacktoberfest website.

Happy Hacktoberfest!

ViewThatFits

Fri, 17 Oct 2025 22:37:36 +0200

SwiftUI is all about declarative UI and adaptive design. But sometimes, you need your view to intelligently choose between multiple layout options depending on the available space. That's where ViewThatFits comes in a sleek, space-aware container introduced in iOS 16 that makes responsive design a breeze.

Let's explore how it works and why it's a game-changer for building flexible interfaces.

What Is `ViewThatFits`?

ViewThatFits is a layout container that evaluates its child views in order and displays the first one that fits within the available space. Think of it as a smart switchboard—it tries each view until it finds one that works.

Syntax Overview:

ViewThatFits {
    Text("This is a long version of the text that might not fit.")
    Text("Shorter version.")
    Text("Tiny.")
}

In this example, SwiftUI will try to render the first Text. If it doesn't fit, it moves to the second, and so on.

Real-World Use Case: Responsive Buttons

Let's say you want a button that shows a full label on larger screens and a compact icon on smaller ones.

ViewThatFits {
    Label("Download", systemImage: "arrow.down.circle")
        .padding()
        .background(Color.blue)
        .foregroundColor(.white)
        .clipShape(Capsule())

    Image(systemName: "arrow.down.circle")
        .padding()
        .background(Color.blue)
        .foregroundColor(.white)
        .clipShape(Circle())
}

This layout automatically adapts to the space available—no need for manual size checks or geometry readers.

Adaptive Toolbars

Toolbars are another great use case. You might want to show a full set of controls on iPad, but simplify them on iPhone.

ViewThatFits(in: .horizontal) {
    HStack {
        Button("Edit") { }
        Button("Share") { }
        Button("Delete") { }
    }

    HStack {
        Image(systemName: "pencil")
        Image(systemName: "square.and.arrow.up")
        Image(systemName: "trash")
    }
}

The .horizontal parameter tells SwiftUI to evaluate fitting based on horizontal space only.

Tips and Gotchas

Order matters: SwiftUI picks the first view that fits, so arrange from most desirable to most compact.
Performance: Keep child views lightweight—SwiftUI evaluates each one until it finds a match.
Combine with LayoutPriority: For even finer control, you can use layout priorities inside each child view.

Why It Matters

Before ViewThatFits, developers had to rely on GeometryReader, conditional logic, or custom layout algorithms to achieve responsive behavior. Now, it's declarative, elegant, and built right into SwiftUI.

Whether you're building for iPhone SE or a 12.9" iPad Pro, ViewThatFits helps your UI gracefully adapt without breaking a sweat.

Final Thoughts

SwiftUI continues to evolve, and ViewThatFits is a perfect example of its philosophy: write less code, get more adaptability. It's a small but mighty tool that can make your layouts smarter and your code cleaner.

Ready to give it a try? Drop it into your next layout and watch your UI respond like magic.

Resources:

Swift Package: ImagePicker

Fri, 17 Oct 2025 22:37:37 +0200

In this post, we will explore the ImagePicker Swift Package, a powerful tool for selecting images in your applications.

What is `ImagePicker`?

ImagePicker is a Swift Package that simplifies the process of selecting images from the user's photo library or taking new photos with the camera. It provides a customizable and easy-to-use interface for integrating image picking functionality into your SwiftUI applications.

Installation

To install the ImagePicker package, you can use the Swift Package Manager. Add the following line to your Package.swift file:

.package(url: "https://github.com/0xWDG/ImagePicker", branch: "main")

Then, add ImagePicker to the dependencies of your target:

.target(
    name: "YourApp",
    dependencies: ["ImagePicker"]
)

How to use `ImagePicker`

import SwiftUI
import ImagePicker

struct ContentView: View {
    @State
    private var image: Image?

    var body: some View {
        VStack {
            ImagePicker(image: $image)
                .frame(width: 150, height: 150)
        }
        .padding()
    }
}

Caveats

Make sure to handle permissions for accessing the photo library.

Wrap up

The ImagePicker Swift Package is a powerful tool for integrating image selection into your SwiftUI applications. Its customizable interface and ease of use make it a great choice for developers looking to enhance their apps with image picking functionality.

Resources:

Contextmenu

Fri, 17 Oct 2025 22:37:38 +0200

SwiftUI continues to surprise us with its elegant solutions to common UI patterns. One such gem is the ContextMenu—a powerful modifier that lets you attach contextual actions to any view. Think of it as the right-click menu for touch interfaces.

What is `Contextmenu`?

The Contextmenu in SwiftUI is a view modifier that allows you to present a context menu when the user performs a secondary click (right-click) on a view. This is particularly useful for providing additional options or actions related to the content the user is interacting with.

import SwiftUI

struct ContentView: View {
    var body: some View {
        Text("Long press me")
            .padding()
            .contextMenu {
                Button(action: {
                    print("Edit tapped")
                }) {
                    Label("Edit", systemImage: "pencil")
                }

                Button(action: {
                    print("Delete tapped")
                }) {
                    Label("Delete", systemImage: "trash")
                }
            }
    }
}

Use Cases

Context menus are useful in scenarios like:

File management (rename, delete, duplicate)
List items with secondary actions
Image previews with quick edits
Admin dashboards with hidden controls

They’re especially useful when you want to keep your UI clean but still offer power-user features.

Platform Behavior

ContextMenus behave differently depending on the platform:

Platform	Trigger	Appearance
iOS	Long press	Floating menu
macOS	Right-click	Native context menu
watchOS	Not supported	—

On iOS, they feel like a native part of the system. On macOS, they integrate seamlessly with right-click behavior. Just be mindful of platform limitations.

Customizing the Experience

Conditionally show menu items:

.contextMenu {
    Button("Share", action: {
        print("Share tapped")
    }) {
        Label("Share", systemImage: "square.and.arrow.up")
    }
    if isAdmin {
        Button("Ban User", action: {
            print("Ban User tapped")
        }) {
            Label("Ban User", systemImage: "person.crop.square")
        }
    }
    Button("Report", action: {
        print("Report tapped")
    }) {
        Label("Report", systemImage: "exclamationmark.bubble")
    }
}

This keeps your menus dynamic and relevant.

Best Practices

Keep context menus short and focused.
Use system icons for familiarity.
Avoid placing critical actions (like "Delete") without confirmation.
Test on all platforms.

Conclusion

SwiftUI’s ContextMenu is a subtle but powerful tool. It helps you declutter your UI while still offering rich interactions. Whether you're building a productivity app or a social platform, context menus can elevate your user experience.

Want to see more SwiftUI tricks? Check out my post on Popovers in SwiftUI for another clean way to present options without navigating away.

Swift Package: FilePicker

Fri, 17 Oct 2025 22:37:38 +0200

FilePicker is a Swift Package to open and save files in SwiftUI. It provides a simple way to open and save files in SwiftUI views.

Installation

To install FilePicker, add it to your Package.swift file:

dependencies: [
    .package(url: "https://github.com/0xWDG/FilePicker", branch: "main")
]

Use Case: Open a file

Opening a file:

import SwiftUI
import FilePicker

struct ContentView: View {
    // MARK: Filepicker
    @State var filePickerOpen = false
    @State var filePickerFiles: [URL] = []

    var body: some View {
        VStack {
            Text("Open a file :)")
                .padding()

            Button("Open", systemImage: "square.and.arrow.down") {
                filePickerOpen.toggle()
            }

            ForEach(filePickerFiles, id: \.self) { file in
                Text(file.lastPathComponent)
            }
        }
        .padding()
        .filePicker(
            isPresented: $filePickerOpen,
            files: $filePickerFiles,
            types: [.json, .text], // Optional (default: .json)
            allowsMultipleSelection: false // Optional (default: false)
        )
        .onChange(of: $filePickerFiles.wrappedValue) { newValue in
            print(newValue)
        }
    }
}

Use Case: Save a file

import SwiftUI
import FilePicker

struct ContentView: View {
    // MARK: Filepicker
    @State var filePickerOpen = false
    var filePickerFileName = "test.txt"
    var filePickerData = Data("Hello, World!".utf8)

    var body: some View {
        VStack {
            Text("Save a file :)")
                .padding()

            Button("Save", systemImage: "square.and.arrow.up") {
                filePickerOpen.toggle()
            }
        }
        .padding()
        .filePicker(
            isPresented: $filePickerOpen,
            fileName: filePickerFileName,
            data: filePickerData,
            types: [.text]
        )
    }
}

Conclusion

FilePicker is a Swift Package to open and save files in SwiftUI. It provides a simple way to open and save files in SwiftUI views.

Resources:

Swift Package: iCloudStorage

Fri, 17 Oct 2025 22:37:39 +0200

In this post, we will explore the iCloudStorage Swift Package, a powerful tool for managing iCloud key-value storage in your applications.

What is `iCloudStorage`?

iCloudStorage is a Swift Package that simplifies the process of storing and retrieving key-value pairs in iCloud. It provides a straightforward API for interacting with iCloud's key-value storage, making it easy to persist user preferences and app state across devices.

Installation

To install the iCloudStorage package, you can use the Swift Package Manager. Add the following line to your Package.swift file:

.package(url: "https://github.com/0xWDG/iCloudStorage", branch: "main")

Then, add iCloudStorage to the dependencies of your target:

.target(
    name: "YourApp",
    dependencies: ["iCloudStorage"]
)

Use Case: Storing User Preferences

Imagine you want to store user preferences, such as a theme selection or a user ID, across app launches. With iCloudStorage, you can easily save and retrieve these values.

import SwiftUI
import iCloudStorage

struct ContentView: View {
    @iCloudStorage("key")
    var value: String = "default"

    var body: some View {
        VStack {
            Text(value)

            Button("Change value") {
                value = "Hello there at \(Date())"
            }
        }
        .task {
            value = "Hello there"
        }
        .padding()
    }
}

Caveats

Make sure to handle errors when accessing iCloud storage.
Be aware of iCloud's limitations on data size and types.

Wrap up

The iCloudStorage Swift Package is a powerful tool for managing iCloud key-value storage in your applications. Its simple API and seamless integration with SwiftUI make it an excellent choice for developers looking to enhance their apps with persistent storage.

Resources:

Swift Package: SecureStorage

Fri, 17 Oct 2025 22:37:39 +0200

In this post, we will explore the SecureStorage Swift Package, a powerful tool for managing sensitive data in your applications.

What is `SecureStorage`?

SecureStorage is a Swift Package that simplifies the process of storing and retrieving sensitive data, such as passwords and tokens, securely. It provides a straightforward API for interacting with the Keychain, making it easy to persist sensitive information across app launches.

Installation

To install the SecureStorage package, you can use the Swift Package Manager. Add the following line to your Package.swift file:

.package(url: "https://github.com/0xWDG/SecureStorage", branch: "main")

Then, add SecureStorage to the dependencies of your target:

.target(
    name: "YourApp",
    dependencies: ["SecureStorage"]
)

## Use Case: Storing User Credentials

Imagine you want to securely store user credentials, such as a username and password, in your application. With `SecureStorage`, you can easily save and retrieve these values.

```swift
import SwiftUI
import SecureStorage

struct ContentView: View {
    @SecureStorage("username")
    var username: String = ""

    @SecureStorage("password")
    var password: String = ""

    var body: some View {
        VStack {
            TextField("Username", text: $username)
            SecureField("Password", text: $password)

            Button("Save Credentials") {
                // Save the credentials securely
            }
        }
        .padding()
    }
}

Caveats

Make sure to handle errors when accessing the Keychain.
Be aware of Keychain's limitations on data size and types.

Wrap up

The SecureStorage Swift Package is a powerful tool for managing sensitive data in your applications. Its simple API and seamless integration with SwiftUI make it an excellent choice for developers looking to enhance their apps with secure storage.

Resources:

Supporting Reduced Motion accessibility setting in SwiftUI

Fri, 17 Oct 2025 22:37:40 +0200

In this post, we will explore how to support the Reduced Motion accessibility setting in SwiftUI applications.

What is `Reduced Motion` accessibility setting in SwiftUI?

The Reduced Motion accessibility setting in iOS allows users to minimize the amount of motion and animation in the user interface. This is particularly helpful for individuals who may experience discomfort or distraction from excessive motion.

Supporting Reduced Motion accessibility setting in SwiftUI

In a SwiftUI application, you can respect the user's preference for reduced motion by using the @Environment property wrapper to access the colorScheme and accessibilityReduceMotion environment values. This allows you to conditionally adjust your animations and transitions based on the user's settings.

Get the reduced motion setting

To get the current reduced motion setting, you can use the following code snippet:

@Environment(\.accessibilityReduceMotion) var reduceMotion

Implementation

struct ContentView: View {
    @Environment(\.accessibilityReduceMotion) private var reduceMotion

    var body: some View {
        Image(systemName: "star")
            .rotationEffect(reduceMotion ? .zero : .degrees(360))
            .animation(
                reduceMotion ? nil : .linear(duration: 1).repeatForever(autoreverses: false),
                value: reduceMotion
            )
    }
}

Note: If we also wanted to check whether Prefer Cross-Fade Transitions is enabled, we can use UIAccessibility.prefersCrossFadeTransitions. There's currently no environment value available for that setting in SwiftUI.

Wrap up

In summary, supporting the Reduced Motion accessibility setting in SwiftUI is essential for creating a more inclusive user experience. By leveraging the @Environment property wrapper and being mindful of animation duration and user preferences, you can ensure that your app respects the needs of all users.

Resources:

Swift Package: XCUITestHelper

Fri, 17 Oct 2025 22:37:40 +0200

In this post, we will explore the XCUITestHelper Swift Package, a powerful tool for simplifying UI testing in your applications.

What is `XCUITestHelper`?

XCUITestHelper is a Swift Package that provides a set of utilities and extensions to make writing UI tests easier and more efficient.

Installation

To install XCUITestHelper, you can add it to your Swift Package dependencies. Here’s how you can do it:

.package(url: "https://github.com/0xWDG/XCUITestHelper", branch: "main")

Then, add XCUITestHelper to the dependencies of your target:

.target(
    name: "YourApp",
    dependencies: ["XCUITestHelper"]
)

Use Case: Simplified UI Testing

Imagine you want to write UI tests for your application. With XCUITestHelper, you can easily streamline your test code and make it more readable.

import XCTest
import XCUITestHelper

final class MyAppUITests: XCTestCase {
    override func setUpWithError() throws {
        continueAfterFailure = false
    }

    func testExample() throws {
        // UI tests must launch the application that they test.
        let app = XCUIApplication()

        // * Set the app language to English.
        app.setLanguage(to: .english)
        // Do this before launching the app.
        app.launch()

        // * `Wait` for 1 second to continue
        app.wait(for: 1)

        // * Tap a `random` cell in a collection view.
        // Random works with any kind of element, not just buttons.
        app.collectionViews.buttons.random.tap()

        // * Go back to previous screen (NavigationView)
        app.navigateBack()

        // * Tap on the last button
        app.buttons.lastMatch.tap()

        // * Tap on the second button
        app.buttons[1].tap()

        // * Type something, and then clear it.
        let textfield = app.searchFields.firstMatch
        app.type(in: textfield, text: "a", action: .clear)
    }
}

Caveats

Make sure to handle errors when accessing UI elements.
Be aware of potential race conditions when waiting for elements to appear.

Wrap up

The XCUITestHelper Swift Package is a powerful tool for simplifying UI testing in your applications. Its utilities and extensions can help you write more readable and maintainable test code.

Resources:

Swift Package: PreventScreenshot

Fri, 17 Oct 2025 22:37:41 +0200

In this post, we will explore a Swift package designed to prevent screenshots in iOS applications.

What is `PreventScreenshot`?

PreventScreenshot is a Swift package that provides a simple way to prevent users from taking screenshots of sensitive information displayed in your iOS app. This can be particularly useful for applications that handle sensitive data, such as banking or healthcare apps.

Installation

To install PreventScreenshot, you can use the Swift Package Manager. Add the following line to your Package.swift file:

.package(url: "https://github.com/0xWDG/PreventScreenshot", branch: "main")

Then, add PreventScreenshot to the dependencies of your target:

.target(
    name: "YourApp",
    dependencies: ["PreventScreenshot"]),

Use Case: Preventing Screenshots of Sensitive Information

In a banking app, for example, you may want to prevent users from taking screenshots of their account balance or transaction history. By using PreventScreenshot, you can easily implement this functionality.

import SwiftUI
import PreventScreenshot

struct ContentView: View {
    var body: some View {
        VStack {
            Text("Don't take a screenshot of this")
                .preventScreenshot()
        }
        .padding()
    }
}

Caveats

While PreventScreenshot can be an effective way to protect sensitive information, it's important to note that it may not be foolproof. Users may still find ways to capture sensitive information through other means, such as using a camera or a secondary device. Therefore, it's essential to combine this approach with other security measures to ensure the protection of sensitive data.
Using PreventScreenshot may decrease the overall user experience, as it can be seen as intrusive. It's crucial to find a balance between security and usability when implementing such measures.

Wrap up

In conclusion, PreventScreenshot is a valuable tool for developers looking to enhance the security of their iOS applications. By preventing screenshots of sensitive information, you can help protect your users' data and maintain their trust in your app.

Resources:

https://github.com/0xWDG/PreventScreenshot

Swift Package: NetworkMonitor

Fri, 17 Oct 2025 22:37:41 +0200

In this post, we will explore a Swift package designed to monitor network connectivity in iOS applications.

What is `NetworkMonitor`?

NetworkMonitor is a Swift package that provides a simple way to monitor the network connectivity status of your iOS app. This can be particularly useful for applications that rely on network access to function properly.

Installation

To install NetworkMonitor, you can use the Swift Package Manager. Add the following line to your Package.swift file:

.package(url: "https://github.com/0xWDG/NetworkMonitor", branch: "main")

Then, add NetworkMonitor to the dependencies of your target:

.target(
    name: "YourApp",
    dependencies: ["NetworkMonitor"]),

Use Case

Sometimes, you may want to perform certain actions based on the network connectivity status. For example, you might want to show a "No Internet Connection" screen when the user is offline or retry a network request when the connection is restored.

import SwiftUI
import NetworkMonitor

struct ContentView: View {
    @ObservedObject
    private var network = NetworkMonitor()

    var body: some View {
        VStack {
            Text("Hello!")
            Text("The network status is \(network.isConnected ? "Connected" : "Disconnected")")
            Text("You are using a \"\(network.isExpensive ? "Expensive" : "Normal")\" internet connection")

            HStack(spacing: 0) {
                Text("You are using \"")
                switch (network.networkType) {
                case .cellular:
                    Text("Celluar")
                case .wifi:
                    Text("Wifi")
                case .loopback:
                    Text("Loopback")
                case .other:
                    Text("Other")
                case .wiredEthernet:
                    Text("Wired")
                default:
                    Text("Unknown")
                }
                Text("\" to connect to the internet")
            }
        }.task {
            print(network.nwPath)
        }
    }
}

Caveats

While NetworkMonitor can be a useful tool for monitoring network connectivity, it's important to keep in mind that it may not cover all edge cases. For example, changes in network status may not be immediately reflected in the UI, and there may be a delay between when the network status changes and when the app is notified of the change. Additionally, the package may not account for all possible network configurations and scenarios.

Wrap up

In summary, NetworkMonitor is a valuable tool for developers looking to enhance the network connectivity monitoring capabilities of their iOS applications. By providing a simple and effective way to track network status changes, it can help improve the overall user experience and ensure that your app behaves as expected in different network conditions.

Resources:

https://github.com/0xWDG/NetworkMonitor

The Identifiable Protocol in Swift

Thu, 22 Jan 2026 17:55:15 +0100

The Identifiable protocol is a fundamental building block in Swift and SwiftUI that enables unique identification of instances. Understanding how to effectively use Identifiable improves code clarity, enables powerful SwiftUI features, and provides type-safe identity management across your applications.

Understanding Identifiable

The Identifiable protocol requires a single property, id, that uniquely identifies each instance:

protocol Identifiable {
    associatedtype ID: Hashable
    var id: ID { get }
}

This simple requirement enables powerful features in SwiftUI and Swift collections:

struct User: Identifiable {
    let id: UUID
    let name: String
    let email: String

    init(name: String, email: String) {
        self.id = UUID()
        self.name = name
        self.email = email
    }
}

// Usage in SwiftUI
struct UsersListView: View {
    let users: [User]

    var body: some View {
        List(users) { user in // No need to specify \.id
            Text(user.name)
        }
    }
}

Why Use Identifiable?

Identifiable provides several key benefits for Swift and SwiftUI development:

// Without Identifiable - verbose and error-prone
struct Product {
    let sku: String
    let name: String
}

List(products, id: \.sku) { product in // Must specify id manually
    Text(product.name)
}

// With Identifiable - clean and type-safe
struct Product: Identifiable {
    let id: String // Using SKU as identifier
    let name: String
}

List(products) { product in // Automatic identification
    Text(product.name)
}

// Identifiable enables powerful diffing
class ProductStore: ObservableObject {
    @Published var products: [Product] = []

    func updateProduct(_ updated: Product) {
        // Swift can efficiently find and update the correct product
        if let index = products.firstIndex(where: { $0.id == updated.id }) {
            products[index] = updated
        }
    }
}

Identifiable with Different ID Types

The ID type can be any Hashable type:

// UUID identifier - best for unique entities
struct Article: Identifiable {
    let id: UUID
    let title: String
    let content: String

    init(title: String, content: String) {
        self.id = UUID()
        self.title = title
        self.content = content
    }
}

// String identifier - useful for API models
struct Category: Identifiable {
    let id: String // API-provided identifier
    let name: String
    let icon: String
}

// Int identifier - database primary keys
struct DatabaseRecord: Identifiable {
    let id: Int
    let data: String
}

// Composite identifier - multiple properties
struct CourseEnrollment: Identifiable {
    struct ID: Hashable {
        let courseID: String
        let studentID: String
    }

    let id: ID
    let enrollmentDate: Date

    init(courseID: String, studentID: String, date: Date) {
        self.id = ID(courseID: courseID, studentID: studentID)
        self.enrollmentDate = date
    }
}

Identifiable with Enums

Enums can conform to Identifiable using self as the identifier:

enum AppTab: String, Identifiable, CaseIterable {
    case home
    case search
    case profile
    case settings

    var id: String { rawValue }

    var title: String {
        rawValue.capitalized
    }

    var icon: String {
        switch self {
        case .home: return "house.fill"
        case .search: return "magnifyingglass"
        case .profile: return "person.fill"
        case .settings: return "gear"
        }
    }
}

// Usage in TabView
struct MainTabView: View {
    @State private var selectedTab: AppTab = .home

    var body: some View {
        TabView(selection: $selectedTab) {
            ForEach(AppTab.allCases) { tab in
                tabView(for: tab)
                    .tabItem {
                        Label(tab.title, systemImage: tab.icon)
                    }
                    .tag(tab)
            }
        }
    }

    @ViewBuilder
    func tabView(for tab: AppTab) -> some View {
        switch tab {
        case .home: HomeView()
        case .search: SearchView()
        case .profile: ProfileView()
        case .settings: SettingsView()
        }
    }
}

// Enum with associated values
enum LoadingState<T: Identifiable>: Identifiable {
    case idle
    case loading
    case success(T)
    case error(Error)

    var id: String {
        switch self {
        case .idle: return "idle"
        case .loading: return "loading"
        case .success(let data): return "success-\(data.id)"
        case .error: return "error"
        }
    }
}

Extending Built-in Types

Extend existing types to conform to Identifiable:

// Extend String to be Identifiable
extension String: @retroactive Identifiable {
    public var id: String { self }
}

// Now strings can be used directly in ForEach
struct TagsView: View {
    let tags: [String] = ["Swift", "iOS", "SwiftUI"]

    var body: some View {
        HStack {
            ForEach(tags) { tag in
                TagView(text: tag)
            }
        }
    }
}

// Extend Date for time-series data
extension Date: @retroactive Identifiable {
    public var id: TimeInterval {
        timeIntervalSince1970
    }
}

struct TimelineView: View {
    let events: [Date] = [
        Date(),
        Date().addingTimeInterval(3600),
        Date().addingTimeInterval(7200)
    ]

    var body: some View {
        List(events) { date in
            Text(date.formatted())
        }
    }
}

// Custom Color wrapper
struct IdentifiableColor: Identifiable {
    let id = UUID()
    let color: Color
    let name: String

    init(_ color: Color, name: String) {
        self.color = color
        self.name = name
    }
}

struct ColorPalette: View {
    let colors: [IdentifiableColor] = [
        IdentifiableColor(.red, name: "Red"),
        IdentifiableColor(.blue, name: "Blue"),
        IdentifiableColor(.green, name: "Green")
    ]

    var body: some View {
        HStack {
            ForEach(colors) { item in
                VStack {
                    Circle()
                        .fill(item.color)
                        .frame(width: 50, height: 50)
                    Text(item.name)
                }
            }
        }
    }
}

Identifiable in Collections

Use Identifiable for efficient collection operations:

struct Task: Identifiable {
    let id: UUID
    var title: String
    var isCompleted: Bool

    init(title: String) {
        self.id = UUID()
        self.title = title
        self.isCompleted = false
    }
}

class TaskManager: ObservableObject {
    @Published var tasks: [Task] = []

    // Add task
    func add(_ task: Task) {
        tasks.append(task)
    }

    // Remove by ID
    func remove(id: UUID) {
        tasks.removeAll { $0.id == id }
    }

    // Update task
    func update(_ task: Task) {
        if let index = tasks.firstIndex(where: { $0.id == task.id }) {
            tasks[index] = task
        }
    }

    // Toggle completion
    func toggleCompletion(id: UUID) {
        if let index = tasks.firstIndex(where: { $0.id == id }) {
            tasks[index].isCompleted.toggle()
        }
    }

    // Reorder tasks
    func move(from source: IndexSet, to destination: Int) {
        tasks.move(fromOffsets: source, toOffset: destination)
    }
}

struct TaskListView: View {
    @StateObject private var taskManager = TaskManager()

    var body: some View {
        List {
            ForEach(taskManager.tasks) { task in
                TaskRow(task: task) {
                    taskManager.toggleCompletion(id: task.id)
                }
            }
            .onDelete { indexSet in
                indexSet.forEach { index in
                    taskManager.remove(id: taskManager.tasks[index].id)
                }
            }
            .onMove { source, destination in
                taskManager.move(from: source, to: destination)
            }
        }
    }
}

Identifiable with Navigation

Use Identifiable for type-safe navigation:

struct Destination: Identifiable, Hashable {
    let id: String
    let title: String
    let content: String
}

struct NavigationExample: View {
    @State private var path: [Destination] = []

    let destinations: [Destination] = [
        Destination(id: "1", title: "Home", content: "Welcome"),
        Destination(id: "2", title: "Settings", content: "Configure"),
        Destination(id: "3", title: "About", content: "Info")
    ]

    var body: some View {
        NavigationStack(path: $path) {
            List(destinations) { destination in
                NavigationLink(value: destination) {
                    Text(destination.title)
                }
            }
            .navigationTitle("Destinations")
            .navigationDestination(for: Destination.self) { destination in
                DestinationView(destination: destination)
            }
        }
    }
}

struct DestinationView: View {
    let destination: Destination

    var body: some View {
        VStack {
            Text(destination.title)
                .font(.largeTitle)
            Text(destination.content)
        }
        .navigationTitle(destination.title)
    }
}

Identifiable in SwiftData

Identifiable integrates seamlessly with SwiftData:

import SwiftData

@Model
final class Note: Identifiable {
    @Attribute(.unique) var id: UUID
    var title: String
    var content: String
    var createdAt: Date

    init(title: String, content: String) {
        self.id = UUID()
        self.title = title
        self.content = content
        self.createdAt = Date()
    }
}

struct NotesView: View {
    @Query private var notes: [Note]
    @Environment(\.modelContext) private var context

    var body: some View {
        List(notes) { note in
            NavigationLink(value: note) {
                VStack(alignment: .leading) {
                    Text(note.title)
                        .font(.headline)
                    Text(note.createdAt.formatted())
                        .font(.caption)
                }
            }
        }
    }
}

Advanced Patterns

Implement advanced patterns with Identifiable:

// Identifiable with protocols
protocol Entity: Identifiable {
    var id: UUID { get }
    var createdAt: Date { get }
    var updatedAt: Date { get }
}

struct Document: Entity {
    let id: UUID
    var title: String
    var createdAt: Date
    var updatedAt: Date

    init(title: String) {
        self.id = UUID()
        self.title = title
        self.createdAt = Date()
        self.updatedAt = Date()
    }
}

// Generic container with Identifiable
struct DataContainer<T: Identifiable> {
    private var items: [T.ID: T] = [:]

    mutating func insert(_ item: T) {
        items[item.id] = item
    }

    mutating func remove(id: T.ID) {
        items.removeValue(forKey: id)
    }

    func get(id: T.ID) -> T? {
        items[id]
    }

    var all: [T] {
        Array(items.values)
    }
}

// Usage with any Identifiable type
var userContainer = DataContainer<User>()
userContainer.insert(User(name: "John", email: "john@example.com"))

var articleContainer = DataContainer<Article>()
articleContainer.insert(Article(title: "Swift", content: "Content"))

Best Practices

Use UUID for unique entities - Guarantees uniqueness across systems
Use natural keys when available - API IDs, database keys, or domain identifiers
Make IDs immutable - Use let to prevent accidental modification
Avoid hash-based IDs for persistence - Hash values aren't stable across sessions
Use enums with rawValue - Provides type-safe, stable identifiers
Extend types carefully - Consider uniqueness guarantees before extending
Document ID meaning - Make it clear what the ID represents
Test identity logic - Ensure IDs remain unique and stable

Conclusion

The Identifiable protocol is a powerful tool for managing object identity in Swift and SwiftUI. By providing unique identification, it enables efficient collection operations, seamless SwiftUI integration, and type-safe navigation. Understanding and effectively using Identifiable is essential for building robust, maintainable iOS applications.

Resources:

Swift Package: SwiftCronParser

Fri, 17 Oct 2025 22:37:43 +0200

In this post, we will explore the SwiftCronParser Swift Package, a package to parse cron expressions in Swift.

What is `SwiftCronParser`?

SwiftCronParser is a Swift package that provides a simple and efficient way to parse cron expressions. Cron expressions are widely used in scheduling tasks and jobs in Unix-like operating systems. With SwiftCronParser, you can easily work with cron expressions in your Swift applications.

Installation

To install SwiftCronParser, you can use the Swift Package Manager. Add the following line to your Package.swift file:

.package(url: "https://github.com/0xWDG/SwiftCronParser", branch: "main")

Then, add SwiftCronParser to the dependencies of your target:

.target(
    name: "YourTarget",
    dependencies: ["SwiftCronParser"]
)

Usage:

import SwiftUI
import SwiftCronParser

let cronParser = SwiftCronParser(input: "0 0 * * *")
let cronTime = cronParser.parse()

if let error = cronTime.error {
    print("Error: \(error)")
} else {
    print("Cron string: \(cronTime)") // 0 0 0,1,2,3,4,5,6 1,2,3,4,5,6,7,8,9,10,11,12 0,1,2,3,4,5,6
    // Or using cronTime.minute, cronTime.hour, cronTime.dayOfMonth, cronTime.month, cronTime.dayOfWeek
}

Conclusion

In this post, we explored the SwiftCronParser Swift Package, a powerful tool for parsing cron expressions in Swift. We covered the installation process, usage examples, and potential use cases for this package. With SwiftCronParser, you can easily work with cron expressions and integrate them into your Swift applications.

Resources:

Swift Package: SwiftExtras

Fri, 17 Oct 2025 22:37:43 +0200

In this post, we will explore the SwiftExtras Swift Package, a package that provides additional functionality and utilities for Swift developers.

What is `SwiftExtras`?

SwiftExtras is a Swift package that offers a collection of useful extensions, utilities, and helper functions to enhance the Swift programming experience. It aims to fill in the gaps and provide commonly needed functionality that may not be available in the standard library.

Installation

To install SwiftExtras, you can use the Swift Package Manager. Add the following line to your Package.swift file:

.package(url: "https://github.com/0xWDG/SwiftExtras", branch: "main")

Then, add SwiftExtras to the dependencies of your target:

.target(
    name: "YourTarget",
    dependencies: ["SwiftExtras"]
)

Features

Versatile Extensions & Helpers
SwiftExtras offers enhancements across a wide range of Swift types as String, Date, Color, View, Error.

Cross-Platform SwiftUI Utilities
The package includes ready-to-use SwiftUI components like IndexedList, MonthYearPickerView, and other layout structures—built for seamless integration across iOS, macOS, tvOS, and watchOS.

e.g. but not limited to:

IndexedList(data:rowContent:)
Error.errorCode
AppInfo.openAppStorePage() and AppInfo.isLatestVersion()
String.clean() (for removing diacritics)
.longPress(action:) for views
MonthYearPickerView()
String.containsHTML & String.htmlToAttributedString()

Read the documentation for more information on how to use these features.

Conclusion

In this post, we explored the SwiftExtras Swift Package, a powerful tool for enhancing the Swift programming experience. We covered the installation process, usage examples, and potential use cases for this package. With SwiftExtras, you can easily work with common tasks and integrate them into your Swift applications.

Resources:

Quick actions in SwiftUI

Fri, 17 Oct 2025 22:37:44 +0200

Quick actions are a powerful feature in SwiftUI that allows developers to add contextually relevant actions to their views. These actions can be triggered by user interactions, such as tapping and holding on a view, and can provide a more streamlined and efficient user experience.

Static Quick Actions

Static quick actions are predefined actions that can be added to a view without requiring any additional configuration. These actions are typically used for common tasks, such as sharing content or navigating to a specific screen.

Defining Quick Actions

We are going to add some information to the Info.plist file:

UIApplicationShortcutItemType – A unique identifier for the action, used later when handling the action.
UIApplicationShortcutItemIconSymbolName – Specifies an SF Symbol for the action’s icon.
UIApplicationShortcutItemTitle – Displays the action’s title.

<key>UIApplicationShortcutItems</key>
<array>
    <dict>
        <key>UIApplicationShortcutItemType</key>
        <string>favoritesAction</string>
        <key>UIApplicationShortcutItemIconSymbolName</key>
        <string>heart</string>
        <key>UIApplicationShortcutItemTitle</key>
        <string>Favorites</string>
    </dict>
</array>

Tip: To localize the title, you can add the value from UIApplicationShortcutItemTitle to your localization file.

Dynamic Quick Actions

This is an example of how to update quick actions dynamically based on the app's state.
We use UIApplicationShortcutItem to create a quick action item, and then we update the quick actions based on the app's state, such as when the user adds or removes items from their favorites.

func updateQuickActionItems() {
    // Check if there are any favorite items, otherwise don't return quick actions
    guard !favorites.isEmpty else {
        // Tell the system about the new quick actions (no actions)
        UIApplication.shared.shortcutItems = []
        return
    }

    // Create a quick action for the favorites
    let favoritesAction = UIApplicationShortcutItem(
        type: "favoritesAction",
        localizedTitle: "Favorites",
        localizedSubtitle: nil,
        icon: UIApplicationShortcutIcon(systemImageName: "heart"),
        userInfo: [:]
    )

    // Tell the system about the new quick actions
    UIApplication.shared.shortcutItems = [favoritesAction]
}

Note: You need to call updateQuickActionItems() on a convenient place, i'll suggest to call it when the favorites list is updated.

Handling Quick Actions

SwiftUI unfortunately does not provide a built-in way to handle quick actions directly. However, we can use the AppDelegate and SceneDelegate to manage quick actions.

We need to use a lot of UIKit integration to make this work. Here's how you can set it up:

@UIApplicationDelegateAdaptor to tell SwiftUI that we want to use AppDelegate
AppDelegate to manage the application lifecycle
UISceneConfiguration to configure the app's scenes
UIWindowSceneDelegate to manage the app's windows

@main
struct MyApp: App {
    // Set up delegate adaptor
    @UIApplicationDelegateAdaptor(AppDelegate.self) private var appDelegate

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

// Set up AppDelegate
class AppDelegate: NSObject, UIApplicationDelegate {
    // Register SceneDelegate
    func application(
        _ application: UIApplication,
        configurationForConnecting connectingSceneSession: UISceneSession,
        options: UIScene.ConnectionOptions
    ) -> UISceneConfiguration {
        let configuration = UISceneConfiguration(
            name: nil,
            sessionRole: connectingSceneSession.role
        )
        if connectingSceneSession.role == .windowApplication {
            configuration.delegateClass = SceneDelegate.self
        }
        return configuration
    }
}

// Set up SceneDelegate
class SceneDelegate: NSObject, UIWindowSceneDelegate {
    // Handle quick action (fresh start)
    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        if let shortcutItem = connectionOptions.shortcutItem {
            handleShortcut(shortcutItem)
        }
    }

    // Handle quick action (resuming app)
    func windowScene(
        _ windowScene: UIWindowScene,
        performActionFor shortcutItem: UIApplicationShortcutItem,
        completionHandler: @escaping (Bool) -> Void
    ) {
        handleShortcut(shortcutItem)
        completionHandler(true)
    }

    // Handle quick action
    func handleShortcut(_ item: UIApplicationShortcutItem) {
        if item.type == "favoritesAction" {
            print("Show favorites")
        }
    }
}

Caveats

Quick actions do not work great with SwiftUI it requires a lot on UIKit integration.
You need to manage the application lifecycle and window scenes manually.

Wrap up

In this article, we explored how to implement quick actions in a SwiftUI application. We covered static quick actions defined in the app's Info.plist file, as well as dynamic quick actions that can be updated at runtime. We also discussed how to handle quick actions using the AppDelegate and SceneDelegate.

Resources:

Picker in SwiftUI

Fri, 17 Oct 2025 22:37:44 +0200

The Picker is a SwiftUI view that presents a set of options for the user to choose from. It can be displayed as a dropdown menu, a segmented control, or a wheel, depending on the context and the number of options available.

Use Case: Picker

A common use case for Picker is to allow users to select a value from a predefined list. For example, you might use a Picker to let users choose their favorite fruit from a list of options.

Set up Picker cases

We need to define the options for our picker. In this case, we'll create an enum for the different themes.

We conform it to String and add conformance to CaseIterable (to support .allCases) and Identifiable (so that we can use it in a ForEach loop)

enum Theme: String, CaseIterable, Identifiable {
    case light = "Light"
    case dark = "Dark"
    case system = "System Default"

    var id: String { self.rawValue }
}

Picker View

struct PickerView: View {
    @State private var selectedTheme: Theme = .light
    var body: some View {
        Form {
            Section("Default/Automatic") {
                Picker("Select Theme", selection: $selectedTheme) {
                    ForEach(Theme.allCases) { theme in
                        Text(theme.rawValue)
                            .tag(theme)
                    }
                }
                .pickerStyle(.automatic)
            }
        }
    }
}

Different Picker styles

The Picker can be styled in various ways to suit different use cases. Here are some of the available styles:

Style	Description
.automatic	The system chooses the best style based on the context.
.menu	A menu-style picker that presents options in a list.
.segmented	A segmented control style picker for a compact selection.
.navigationLink	A picker that navigates to a new view for selection.
.palette	A color palette style picker for selecting colors.
.inline	An inline style picker that displays options within the form.
.wheel	A wheel-style picker for selecting values in a scrollable wheel.

In this code example, we create a PickerView that demonstrates the different picker styles:

struct PickerView: View {
    @State private var selectedTheme: Theme = .light
    var body: some View {
        NavigationStack {
            Form {
                Section("Default/Automatic") {
                    Picker("Select Theme", selection: $selectedTheme) {
                        ForEach(Theme.allCases) { theme in
                            Text(theme.rawValue)
                                .tag(theme)
                        }
                    }
                    .pickerStyle(.automatic)
                }

                Section(".menu") {
                    Picker("Select Theme", selection: $selectedTheme) {
                        ForEach(Theme.allCases) { theme in
                            Text(theme.rawValue).tag(theme)
                        }
                    }
                    .pickerStyle(.menu)
                }

                Section(".segmented") {
                    Picker("Select Theme", selection: $selectedTheme) {
                        ForEach(Theme.allCases) { theme in
                            Text(theme.rawValue).tag(theme)
                        }
                    }
                    .pickerStyle(.segmented)
                }

                Section(".navigationLink") {
                    Picker("Select Theme", selection: $selectedTheme) {
                        ForEach(Theme.allCases) { theme in
                            Text(theme.rawValue).tag(theme)
                        }
                    }
                    .pickerStyle(.navigationLink)
                }

                Section(".palette") {
                    Picker("Select Theme", selection: $selectedTheme) {
                        ForEach(Theme.allCases) { theme in
                            Text(theme.rawValue).tag(theme)
                        }
                    }
                    .pickerStyle(.palette)
                }

                Section(".inline") {
                    Picker("Select Theme", selection: $selectedTheme) {
                        ForEach(Theme.allCases) { theme in
                            Text(theme.rawValue).tag(theme)
                        }
                    }
                    .pickerStyle(.inline)
                }

                Section(".inline & labelsHidden") {
                    Picker("Select Theme", selection: $selectedTheme) {
                        ForEach(Theme.allCases) { theme in
                            Text(theme.rawValue).tag(theme)
                        }
                    }
                    .pickerStyle(.inline)
                    // I'd suggest to hide the "labels" it looks cleaner when using .inline
                    .labelsHidden()
                }

                Section(".wheel") {
                    Picker("Select Theme", selection: $selectedTheme) {
                        ForEach(Theme.allCases) { theme in
                            Text(theme.rawValue).tag(theme)
                        }
                    }
                    .pickerStyle(.wheel)
                }
            }
        }
    }
}

This is a screenshot of the different picker styles in action.

Conclusion

Pickers are a powerful way to allow users to select from a range of options in a SwiftUI application. By utilizing the various picker styles available, you can create a more intuitive and user-friendly interface.

Resources:

Monospace digits

Fri, 17 Oct 2025 22:37:45 +0200

Monospace digits are a type of font where each character takes up the same amount of horizontal space. This is particularly useful in programming and data presentation, as it allows for better alignment and readability of numbers.

Use Case: Monospace Digits

If you have a countdown timer in your app, using only Text will cause the digits to be misaligned as they change. By using a monospace font, you can ensure that each digit takes up the same amount of space, making the timer easier to read.

Example

Here's a simple example of how to use monospace digits in a SwiftUI countdown timer:

struct AppTimer: View {
    @State private var timeRunning = 0

    var body: some View {
        Text("The app is running for \(timeRunning) seconds.")
            .font(.title2)
            .monospacedDigit()
            .task {
                repeat {
                    try? await Task.sleep(for: .seconds(1))
                    timeRunning += 1
                } while true
            }
    }
}

This code ensures that the timer updates every second without changing the text alignment.

The repeat block allows to repeat a certain action (in this case, updating the timer) while a certain condition is met (in this case, forever).

Caveats

While monospace digits can improve readability, they may not always be the best choice for every design. Consider the overall aesthetic of your app and whether a monospace font fits with the other design elements.

Wrap Up

Using monospace digits in your SwiftUI app can enhance the readability of numerical data, especially in dynamic contexts like timers or counters. By ensuring consistent spacing for each digit, you can create a more visually appealing and user-friendly interface.

Environment: OpenURL

Fri, 17 Oct 2025 22:37:45 +0200

@Environment(\.openURL) allows you to open URLs from your SwiftUI views.

What is `@Environment(\.openURL)`?

@Environment(\.openURL) is a property wrapper that provides a way to open URLs in your SwiftUI application. It gives you access to the OpenURL environment value, which you can use to present a URL in the appropriate way for the current platform.

struct ContentView: View {
    @Environment(\.openURL) var openURL

    var body: some View {
        Button("Open Website") {
            openURL(URL(string: "https://wesleydegroot.nl")!)
        }
    }
}

Custom `OpenURLAction`

You can also set a custom OpenURLAction for your views. This allows you to define how URLs should be handled when they are opened.

struct ContentView: View {
    var body: some View {
        Text(.init("Visit https://wesleydegroot.nl or [Play a sound](play://sound)"))
        .environment(\.openURL, OpenURLAction { url in
            if let scheme = url.scheme {
                if scheme == "play" {
                    // MusicPlayer.play(url)
                    return .handled
                }
            }
            return .systemAction
        })
    }
}

Wrap up

Opening URLs in SwiftUI is made easy with @Environment(\.openURL). This powerful property wrapper allows you to handle URL actions seamlessly across different platforms.

Resources:

Make your app visible with alternative app names

Tue, 02 Dec 2025 21:18:45 +0100

With INAlternativeAppNames, you can provide alternative names for your app so that the user can find your app more easily.

Example you have a agenda app called `Calendo`

You can provide alternative names like Calendar, Kalender or Agenda to help users discover your app through different keywords.

How to implement

Add the INAlternativeAppNames key to your app's Info.plist file and provide an array of alternative names.

<key>INAlternativeAppNames</key>
<array>
    <dict>
        <key>INAlternativeAppName</key>
        <string>Kalender</string>
        <key>INAlternativeAppNamePronunciationHint</key>
        <string>Kalender</string>
    </dict>
    <dict>
        <key>INAlternativeAppName</key>
        <string>Calendar</string>
        <key>INAlternativeAppNamePronunciationHint</key>
        <string>Calendar</string>
    </dict>
    <dict>
        <key>INAlternativeAppName</key>
        <string>Planning</string>
        <key>INAlternativeAppNamePronunciationHint</key>
        <string>Planning</string>
    </dict>
</array>

The end user should be able to find your app using the app name and any of the alternative names you provided.

Note: There is a limit of 3 alternative names that you can provide.

Wrap up

In this article, we explored how to use INAlternativeAppNames to make your app more discoverable through alternative names. By providing a variety of keywords, you can help users find your app more easily.

Resources:

https://developer.apple.com/documentation/sirikit/specifying-synonyms-for-your-app-name

Tracking Screen Views in SwiftUI with a Custom ViewModifier

Fri, 17 Oct 2025 22:37:46 +0200

In this post we'll create a small extension to track which screens are being viewed in a SwiftUI application.

Why Track Screen Views?

Tracking screen views is essential for understanding user behavior within your app. By knowing which screens are viewed most often, you can make informed decisions about where to focus your development efforts, improve user experience, and ultimately drive engagement.

TelemetryDeck Integration

For This example we'll use TelemetryDeck.
You can create a free account(referral) and get your API key from the dashboard.
p.s. if you use my referral code (0XL7FMWOV3LYPR61) we'll both get 100,000 extra signals every month 🙌

Why TelemetryDeck?

TelemetryDeck is a powerful tool for tracking user interactions in your app. It provides a privacy-first approach to analytics, ensuring that user data is anonymized.

Setting up TelemetryDeck

import SwiftUI
import TelemetryDeck

@main
struct YourAppNameApp: App {
    init() {
        let config = TelemetryDeck.Config(appID: "YOUR-APP-ID")
        TelemetryDeck.initialize(config: config)
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

Use Case: Tracking Screen Views

To track screen views, we can create a custom ViewModifier that will automatically log the screen name whenever a view appears. Here's a simple implementation:

import SwiftUI
import TelemetryDeck

struct ContentView: View {
    var body: some View {
        Text("Hello, World!")
            .screenViewEvent()
    }
}

extension View {
    func screenViewEvent(
        _ screen: String = #file,
        extraParameters: [String: String]? = nil
    ) -> some View {
        self.onAppear {
            TelemetryDeck.signal(
                "open.\(screen)",
                parameters: extraParameters ?? [:]
            )
        }
    }
}

Wrap up

In this post, we've created a simple yet effective way to track screen views in a SwiftUI application using a custom ViewModifier. By integrating with TelemetryDeck, we can gain valuable insights into user behavior and make data-driven decisions to improve our app.

Resources:

TelemetryDeck Documentation
free account (referral)

Task.sleep() vs. Task.yield(): The differences explained

Mon, 22 Dec 2025 11:52:34 +0100

Task.sleep() vs. Task.yield() The differences explained

What is `Task.sleep()`?

With Task.sleep(), you can suspend the execution of a task for a specified duration. This is useful when you want to introduce a delay in your asynchronous code, such as waiting for a certain condition to be met or simulating a long-running operation.

What is `Task.yield()`?

With Task.yield(), you can voluntarily yield control back to the system, allowing other tasks to run. This is useful in scenarios where you want to prevent blocking the current current actor and allow for more responsive and efficient multitasking.

When should you use `Task.sleep()` vs `Task.yield()`?

Both methods suspend execution, but they have a few key differences.

The Task.sleep() method suspends execution for a set of time while the Task.yield() method might only suspend if other tasks with similar or lower priority await execution. Therefore, the duration of suspension is only fixed for Task.sleep() and indeterminate for Task.yield().

The Task.sleep() method is interruptible via cancellation, while Task.yield() only yields control. Both are non-blocking for their respective threads.

Conclusion

In conclusion, Task.sleep() is best used when you need a precise delay, while Task.yield() is more appropriate for allowing other tasks to run without blocking. Understanding these differences can help you write more efficient and responsive asynchronous code.

Credits:

Thanks Matt Massicotte for pointing me out on a mistake in this post.

Resources:

Form in SwiftUI

Fri, 17 Oct 2025 22:37:48 +0200

User input powers almost every app. From reminders to events, contacts, or sign-ups thats where Form comes in.

A Basic Contact Form

The simplest way to start is by grouping TextField inside a Form. SwiftUI automatically handles grouping, scrolling, and native styling.

Form {
    Section {
        TextField("First name", text: $firstName)
        TextField("Last name", text: $lastName)
        TextField("Company", text: $company)
    }
    Section {
        TextField("Phone", text: $phone)
    }
    Section {
        TextField("Email", text: $email)
    }
}
.navigationTitle("New Contact")
.padding()

Adding Toggles & Pickers

Forms are not just text fields. You can combine toggles, pickers, and sliders seamlessly.

Form {
    Section("Preferences") {
        Toggle("Enable notifications", isOn: $notificationsEnabled)
        Picker("Theme", selection: $theme) {
            Text("Light").tag("light")
            Text("Dark").tag("dark")
            Text("System").tag("system")
        }
    }
}

On iOS, the picker shows as a sheet. On macOS, it renders as a dropdown.

Date & Stepper Inputs

Need scheduling or number input? SwiftUI has it built-in.

Form {
    Section("Event Details") {
        DatePicker("Date", selection: $eventDate, displayedComponents: .date)
        Stepper("Guests: \(guestCount)", value: $guestCount, in: 1...20)
    }
}

This is perfect for calendar apps, bookings, or reservations.

Styling with Section Footers

You can add footers for extra context — useful for tips or validation hints.

Form {
    Section(
        header: Text("Account"),
        footer: Text("Password must be at least 8 characters.")
    ) {
        SecureField("Password", text: $password)
        SecureField("Confirm Password", text: $confirmPassword)
    }
}

The footer automatically adapts to the platform’s design.

Why use SwiftUI Forms?

Native look & feel across iOS, iPadOS, macOS, and watchOS
Automatic layout adjustments
Built-in components for most common inputs
Lightweight and declarative

Resources:

How to Position Views in SwiftUI

Fri, 17 Oct 2025 22:37:48 +0200

Sometimes you want to position your views precisely within a SwiftUI layout.

How to place your view on a specific coordinate

You can use the position modifier to place a view at a specific point within its parent.

import Swift

struct ContentView: View {
    var body: some View {
        Circle()
            .fill(Color.blue)
            .frame(width: 100, height: 100)
            .position(x: 100, y: 100)
    }
}

Caveats

Using the position modifier can lead to unexpected layouts, especially with dynamic content. It's often better to use alignment guides or other layout tools provided by SwiftUI.

Wrap up

In this guide, we've covered how to position views in SwiftUI using the position modifier. While it's a powerful tool, be mindful of its caveats and consider alternative layout strategies when necessary.

Resources:

It's a wrap (2025)

Wed, 31 Dec 2025 10:44:04 +0100

In 2025 I have written 68 articles!

The most used tags are: SwiftUI, Swift, SwiftPM, macOS, iOS,

January

In January I've released 4 articles

Apple version numbers (1 min) [Tags: Apple, version numbers]
As you may know, Apple releases new versions of its operating systems every year. The version numbers are not always the same across all platforms, and they don't always follow the same pattern. Her...
Accessibility in SwiftUI (6 min) [Tags: Accessibility, SwiftUI]
Accessibility in app development is all about making sure everyone, regardless of their abilities, can use your app. Apple’s SwiftUI framework makes integrating accessibility features more streaml...
Contact Provider Extension (8 min) [Tags: ContactProvider, Swift]
The ContactProvider framework lets your app create (business) contacts on the user's device. It is the prefered way to add contacts to the user's address book without interferring with their (perso...
Using MetricKit (2 min) [Tags: MetricKit, Swift]
In this post, I will show you how to use MetricKit to collect and analyze performance data from your app. MetricKit is a framework introduced in iOS 13 that allows you to collect and analyze perfor...

February

In February I've released 4 articles

iOS App States (2 min) [Tags: iOS, App State]
When you're developing an iOS app, it's important to understand the different states that your app can be in, to handle them correctly and provide a smooth user experience. In this post, we'll take a...
Controllig login and background items (3 min) [Tags: macOS, background, login]
In This post, we'll take a look at how to control login and background items on macOS. When you start your Mac, you may have noticed that some apps or items automatically start up or appear in the ba...
Exploring ControlGroup in SwiftUI (3 min) [Tags: ControlGroup, SwiftUI]
In SwiftUI, a ControlGroup provides a way to visually group controls together, making your UI more intuitive and structured. It helps you present related controls in a unified manner, enhancing the ...
Expressible Literals (2 min) [Tags: Swift, expressible-literals]
Expressible Literals in Swift are a powerful feature that allows you to create custom types that can be initialized using literals. This post will show you how to create your own custom types that ...

March

In March I've released 6 articles

JavaScriptCore (5 min) [Tags: JavaScriptCore, Swift]
Whether you love it or hate it, JavaScript has become the most important language for developers in the world today. Yet despite any efforts we may take to change or replace it we’d be hard JavaSc...
MacOS Terminal Commands (5 min) [Tags: macOS, Terminal]
In this post i'll show you my favorite macOS terminal commands that i use often or find interesting. This blog post is a different kind of post than i usually write, but i hope you like it. | Descr...
NavigationStack (4 min) [Tags: NavigationStack, Swift]
NavigationStack is a SwiftUI view that provides a navigation stack for macOS and iOS. Navigation was done using NavigationView, but it was deprecated in iOS 16 and was split into two new containers...
Build a personal brand as developer (2 min) [Tags: Developer, Brand]
Here are some tips to build a personal brand as a developer. Start by defining your brand. This will help you to create a consistent message and image. Build a professional website to showcase...
AppDevCon 2025 (4 min) [Tags: AppDevCon, Conference]
AppDevCon is a conference for application developers, focusing on the latest trends and technologies in app development. Below is a brief overview of some of the talks at the conference, with a smal...
Fixing slow scrolling in Calendo (7 min) [Tags: Calendo, SwiftUI]
In this post, I'll go through the steps which i took to fix a bug with slow scrolling in Calendo. Interested in the development of Calendo? Read my previous post about Building Calendo or search on t...

April

In April I've released 5 articles

Dutch.swift (1 min) [Tags: Swift]
For april fools day, I wanted to write a Swift library that allows you to write Swift code in Dutch. It's called Dutch.swift and it's available on GitHub. Unfortunately it didn't work out in the way...
Building iWebTools (17 min) [Tags: iWebTools]
In this blog post I will show you how I build iWebTools. iWebTools is a tool to check websites and use some tools like a JWT Decoder and a crontab converter. I started with a basic design, I'm not r...
NumberFormatter (3 min) [Tags: NumberFormatter, Swift]
NumberFormatter is a class that provides a flexible and easy way to convert numbers into strings and vice versa. It is a part of the Foundation framework and is available on all Apple platforms. ...
Tips and ideas to start your own blog (5 min) [Tags: Swift, Blog]
When I started this website on 03 February 2024 I was unsure if I would be able to keep it up. I had tried to start a blog some times before but I always struggled to keep it up. This time I take an...
What powers this website (4 min) [Tags: Blog, PHP]
When I started this website on 03 February 2024, it was a small project, with one php file for rendering markdown files. This website is made in Visual Studio Code, with plain HTML, CSS, and a litt...

May

In May I've released 4 articles

Building xcstrings-translator (9 min) [Tags: Swift, xcstrings]
xcstrings The idea behind this tool is to provide a simple and easy way to translate .xcstrings files. The tool should be able to read the .xcstrings file, my original idea was to make this a comman...
Customizing macOS windows (5 min) [Tags: SwiftUI, macOS]
MacOS windows are a fundamental part of the user interface, and customizing them can greatly enhance the user experience. In this post, we will explore how to customize macOS windows using SwiftUI. ...
Creating macOS Menu Bar App in SwiftUI (3 min) [Tags: SwiftUI, macOS, MenuBar]
Creating a menu bar app may seems like a complicated task, but with SwiftUI, it can be done in a few simple steps. In this post, we will create a basic macOS menu bar app using SwiftUI. The app will...
Popovers in SwiftUI (3 min) [Tags: SwiftUI]
In SwiftUI, popovers are a great way to present additional information or options without navigating away from the current view. This post will explore how to create and customize popovers in SwiftUI...

June

In June I've released 4 articles

Handle plurals in Swift with inflection (2 min) [Tags: SwiftUI]
Inflection is a powerful tool in Swift that allows developers to handle plurals and other linguistic variations in a more elegant way. This post will explore how to use inflection in Swift, providing...
CocoaPods Trunk Read-only Plan (1 min) [Tags: CocoaPods]
CocoaPods Trunk Read CocoaPods is a dependency manager for Swift and ObjectiveIt is used to manage library dependencies in iOS and macOS applications, allowing developers to easily integrate thirdIt...
Thermal States on iOS (3 min) [Tags: iOS, Swift]
You can read the thermal states on iOS documentation to understand how to manage the thermal state of your iOS application. This is important for optimizing performance and battery life. Thermal st...
Move your app to the background (2 min) [Tags: iOS]
In this (small) post, we will explore how to move your iOS application to the background programmatically. This is offcially not supported by Apple. `swift import SwiftUI struct ContentView: View ...

July

In July I've released 5 articles

Using the share sheet to share content (4 min) [Tags: SwiftUI]
In this post, we will explore how to use the share sheet in SwiftUI to share content from your app. The share sheet allows users to share text, images, URLs, and other types of content with other app...
Gradients in text using foregroundStyle (2 min) [Tags: SwiftUI]
In this post, we will explore how to create gradients in text using the foregroundStyle modifier in SwiftUI. This technique allows for visually appealing text effects that can enhance the user interf...
Difference between animations in SwiftUI (6 min) [Tags: SwiftUI, Animations]
In this post, we will explore the difference between .animation()) and withAnimation()) and phaseAnimator()) in SwiftUI. Both are used to create animations, but they serve different purposes and have...
Adjust the intensity of colors in SwiftUI views (3 min) [Tags: SwiftUI, Colors, Brightness]
SwiftUI provides a powerful way to create dynamic and visually appealing user interfaces. One of the features that can enhance the visual experience is the ability to adjust the intensity of colors i...
SwiftUI Buttons (4 min) [Tags: SwiftUI, Button]
In this post we will explore the different styles of buttons available in SwiftUI, how to create custom buttons, and some best practices for using buttons in your SwiftUI applications. Buttons in S...

August

In August I've released 5 articles

Surprise Route (6 min) [Tags: Swift]
In this post, I'll take you tough the process of creating my Surprise Route app in Swift(UI). This app is designed to generate random routes for walking or biking, making your daily exercise routine ...
SwiftUI Lists (16 min) [Tags: SwiftUI, List]
Discover List in SwiftUI, a powerful way to display collections of data in a scrollable format. In this post, we will explore how to create lists, customize their appearance, and handle user interact...
Interpolation and formatting in Text (3 min) [Tags: SwiftUI, Interpolation, Formatting]
In this post, we will explore how to use interpolation and formatting in SwiftUI's Text view. This is a powerful feature that allows you to create dynamic and formatted text easily. Interpolation a...
Placing components within the Safe Area Inset (2 min) [Tags: SwiftUI, SafeArea]
In this post, we will explore how to effectively place components within the Safe Area Inset in SwiftUI applications. The Safe Area Inset is a layout guide in iOS that defines the portion of the sc...
Building Editable Lists in SwiftUI (4 min) [Tags: SwiftUI, List]
In this post, we will explore how to create editable lists in SwiftUI using a couple of different approaches using EditButton(), @Environment(.editMode) and custom EditMode state. List is a SwiftU...

September

In September I've released 5 articles

Building SwiftUI Debugging Utilities (2 min) [Tags: SwiftUI, Debug]
In this post, we will explore how to create debugging utilities in SwiftUI to help diagnose and fix issues in your app. As you may know already you cannot use print()) directly in your SwiftUI code...
Remove the background from images using Swift (8 min) [Tags: Swift]
Removing backgrounds from images is a common task in modern apps, whether for photo editing, social media, or automation. In this article, you'll learn how to build a cross Background removal l...
Custom Tabbar with SwiftUI (3 min) [Tags: SwiftUI, TabBar]
In this post, we will explore how to create a custom tab bar using SwiftUI. A TabView is a user interface component that allows users to switch between different views or sections of an app. Unlike...
Hidden macOS features (2 min) [Tags: macOS]
In this post we're going to explore some hidden features of macOS that can enhance your productivity and improve your workflow. To move a file in finder you can use ⌘C (Command + C) to copy the f...
Sensory feedback in SwiftUI (3 min) [Tags: SwiftUI, Trigger]
This post explores the concept of sensory feedback in SwiftUI, a modifier to provide feedback to users based on their interactions. Sensory Feedback in SwiftUI is a powerful feature that allows dev...

October

In October I've released 16 articles

Hacktoberfest 2025 (2 min) [Tags: Hacktoberfest]
As the leaves change color and the air turns crisp, developers around the world gear up for one of the most exciting events in the openThis annual celebration, organized by DigitalOcean, GitHub, and...
ViewThatFits (3 min) [Tags: SwiftUI, ViewThatFits]
SwiftUI is all about declarative UI and adaptive design. But sometimes, you need your view to intelligently choose between multiple layout options depending on the available space. That's where ViewT...
Swift Package: ImagePicker (1 min) [Tags: SwiftPM, ImagePicker]
In this post, we will explore the ImagePicker Swift Package, a powerful tool for selecting images in your applications. ImagePicker is a Swift Package that simplifies the process of selecting image...
Contextmenu (2 min) [Tags: SwiftUI, Contextmenu]
SwiftUI continues to surprise us with its elegant solutions to common UI patterns. One such gem is the ContextMenu)—a powerful modifier that lets you attach contextual actions to any view. Think of...
Swift Package: FilePicker (2 min) [Tags: SwiftPM, FilePicker]
FilePicker is a Swift Package to open and save files in SwiftUI. It provides a simple way to open and save files in SwiftUI views. To install FilePicker, add it to your Package.swift file: `swift...
Swift Package: iCloudStorage (1 min) [Tags: SwiftPM, iCloudStorage]
In this post, we will explore the iCloudStorage Swift Package, a powerful tool for managing iCloud key iCloudStorage is a Swift Package that simplifies the process of storing and retrieving key To ...
Swift Package: SecureStorage (2 min) [Tags: SwiftPM, SecureStorage]
In this post, we will explore the SecureStorage Swift Package, a powerful tool for managing sensitive data in your applications. SecureStorage is a Swift Package that simplifies the process of stor...
Supporting Reduced Motion accessibility setting in SwiftUI (2 min) [Tags: SwiftUI, Accessibility]
In this post, we will explore how to support the Reduced Motion accessibility setting in SwiftUI applications. The Reduced Motion accessibility setting in iOS allows users to minimize the amount of...
Swift Package: XCUITestHelper (2 min) [Tags: SwiftPM, XCUITestHelper]
In this post, we will explore the XCUITestHelper Swift Package, a powerful tool for simplifying UI testing in your applications. XCUITestHelper is a Swift Package that provides a set of utilities a...
Swift Package: PreventScreenshot (2 min) [Tags: SwiftPM, PreventScreenshot]
In this post, we will explore a Swift package designed to prevent screenshots in iOS applications. PreventScreenshot is a Swift package that provides a simple way to prevent users from taking scree...
Swift Package: NetworkMonitor (3 min) [Tags: SwiftPM, NetworkMonitor]
In this post, we will explore a Swift package designed to monitor network connectivity in iOS applications. NetworkMonitor is a Swift package that provides a simple way to monitor the network conne...
Identifiable protocol (3 min) [Tags: Swift, Identifiable]
Identifiable is a protocol in Swift that allows you to uniquely identify instances of a type. The Identifiable protocol is a protocol in Swift that allows you to uniquely identify instances of a ty...
Swift Package: SwiftCronParser (1 min) [Tags: SwiftPM, SwiftCronParser]
In this post, we will explore the SwiftCronParser Swift Package, a package to parse cron expressions in Swift. SwiftCronParser is a Swift package that provides a simple and efficient way to parse c...
Swift Package: SwiftExtras (2 min) [Tags: SwiftPM, SwiftExtras]
In this post, we will explore the SwiftExtras Swift Package, a package that provides additional functionality and utilities for Swift developers. SwiftExtras is a Swift package that offers a collec...

November

In November I've released 4 articles

Quick actions in SwiftUI (4 min) [Tags: SwiftUI, QuickActions]
Quick actions are a powerful feature in SwiftUI that allows developers to add contextually relevant actions to their views. These actions can be triggered by user interactions, such as tapping and ho...
Picker in SwiftUI (4 min) [Tags: SwiftUI, Picker]
The Picker is a SwiftUI view that presents a set of options for the user to choose from. It can be displayed as a dropdown menu, a segmented control, or a wheel, depending on the context and the numb...
Monospace digits (2 min) [Tags: SwiftUI, Monospace]
Monospace digits are a type of font where each character takes up the same amount of horizontal space. This is particularly useful in programming and data presentation, as it allows for better alignm...
Environment: OpenURL (1 min) [Tags: Environment, OpenURL]
@Environment(.openURL) allows you to open URLs from your SwiftUI views. @Environment(.openURL) is a property wrapper that provides a way to open URLs in your SwiftUI application. It gives you acc...

December

In December I've released 6 articles

Make your app visible with alternative app names (1 min) [Tags: INAlternativeAppNames]
With INAlternativeAppNames, you can provide alternative names for your app so that the user can find your app more easily. You can provide alternative names like Deposit, Safe, Bank, or Finance to ...
Tracking Screen Views in SwiftUI with a Custom ViewModifier (2 min) [Tags: SwiftUI, ViewModifier, Analytics]
In this post we'll create a small extension to track which screens are being viewed in a SwiftUI application. Tracking screen views is essential for understanding user behavior within your app. By ...
Task.sleep() vs. Task.yield(): The differences explained (2 min) [Tags: Swift, Task]
Task.sleep() vs. Task.yield() The differences explained With Task.sleep()), you can suspend the execution of a task for a specified duration. This is useful when you want to introduce a delay in yo...
Form in SwiftUI (2 min) [Tags: SwiftUI, Form]
User input powers almost every app. From reminders to events, contacts, or sign The simplest way to start is by grouping TextField inside a Form. SwiftUI automatically handles grouping, scrolling, a...
How to Position Views in SwiftUI (1 min) [Tags: SwiftUI]
Sometimes you want to position your views precisely within a SwiftUI layout. You can use the position) modifier to place a view at a specific point within its parent. `swift import Swift struct C...
It's a wrap (2025) (1 min) [Tags: Wrapped, 2025]
In 2025 I have written 68 articles! The most used tags are: <a href="/blog/tag/SwiftUI" style="color: In January I've released 4 articles In February I've released 4 articles In March ...

Reading minutes per month

January: 17 minutes
February: 10 minutes
March: 27 minutes
April: 30 minutes
May: 20 minutes
June: 8 minutes
July: 19 minutes
August: 31 minutes
September: 18 minutes
October: 28 minutes
November: 11 minutes
December: 9 minutes

The total reading time of all articles is about 228 minutes (3.8 hours)!

Welcome 2026

Mon, 13 Apr 2026 16:32:43 +0200

Welcome to 2026!

I hope you'll all have a fantastic year and that all your wishes may become true.

We're going to start this year with accessibility in mind. Stay tuned for more updates and exciting content throughout the year.

Date	Topic
06-JAN-2026	Dark Mode
13-JAN-2026	Reduced Motion (plus prefers-reduced-motion CSS media query for your websites!)
20-JAN-2026	Sufficient Contrast
27-JAN-2026	Larger Text
03-FEB-2026	Differentiate without color
10-FEB-2026	VoiceOver
17-FEB-2026	Voice Control
24-FEB-2026	Captions
03-MAR-2026	Audio Descriptions

I'm excited to share more with you all!

I would love to hear your thoughts and suggestions. Please feel free to reach out or leave a comment below!

In addition to those important topics, I want to explore and learn about Game Center, HealthKit, and other underused frameworks and technologies.

I must make some hurry for writing the blogs, usually I'm about 2-3 months ahead, but I didn't had the energy to do so in the last monts of 2025, I already did one of the most diffucult things, setting subjects for the blogs.

As of writing this (01-JAN-2026), I have planned blog posts until March 2026, so stay tuned for more exciting content!

Some personal updates from 2025:

I got diagnosed with Diabetes type 2, this was devastating news, but I'm doing everything I can to live a healthier life, I exercise 7 days a week now and I'm on a strict diet. (I may quit the diabetes medication soon if my blood glucose levels stay good!)
I'm finally on a healthy weight (92 kg / 203 lbs), I lost 25+ kg (55 lbs) in 2025. (in total it's about 65 kg / 143 lbs since 2019).
I have a girlfriend (Tanya), we are very happy!

Let's make 2026 a great year together!

- Wesley de Groot.

Dark Mode

Mon, 13 Apr 2026 16:32:43 +0200

Dark Mode is an important feature that many users appreciate for its aesthetic appeal, and for people with visual impairments.

When do we need Dark Mode support?

Dark Mode support is essential.
supporting Dark Mode can enhance accessibility for users with visual impairments who may find it easier to read content on a dark background.

How to implement Dark Mode in SwiftUI

Implementing Dark Mode in SwiftUI is straightforward. SwiftUI mostly adapts automatically to the system's appearance settings, you may use a theming system to use dark and light colors without reading the environment variable .colorScheme all the time.

Automatic Support

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack {
            Text("SwiftUI Will Handle Dark Mode Automatically")
                .foregroundColor(.primary)
                .background(.background)
        }
    }
}

Custom View

struct ThemedView: View {
    @Environment(\.colorScheme)
    var colorScheme

    var foregroundColor: Color {
        colorScheme == .dark ? .black : .white
    }

    var backgroundColor: Color {
        colorScheme == .dark ? .white : .black
    }

    var body: some View {
        Text("This view adapts to Dark Mode, using custom colors!")
            .foregroundColor(foregroundColor)
            .background(backgroundColor)
    }
}

Use Assets Catalog

You can define colors in your Assets catalog that automatically adapt to Light and Dark modes. When you create a new color set, you can specify different colors for "Any Appearance" and "Dark Appearance".

Forcing interface style

If you want to force a specific interface style for a view or the entire app, you can use the .preferredColorScheme(_:) modifier:

struct ForcedDarkModeView: View {
    var body: some View {
        VStack {
            Text("This view is always in Dark Mode")
        }
        .preferredColorScheme(.dark)
    }
}

Libraries and Tools:

My package Colors provides a convenient way to manage colors in your SwiftUI projects, including support for Dark Mode. You can define colors that automatically adjust based on the current appearance.

Wrap up

SwiftUI handles most of Dark Mode automatically — using semantic colors and .preferredColorScheme(_:) is all most apps need. Read the \.colorScheme environment value only when you genuinely need to branch behavior.

Resources:

Reduced Motion

Mon, 30 Mar 2026 16:57:33 +0200

Reduced motion is an important accessibility feature that helps create a comfortable user experience for individuals sensitive to motion effects.

What is `Reduced Motion`?

Reduced Motion is an accessibility feature available on iOS, macOS, and other Apple platforms that minimizes the amount of motion and animation in the user interface. This feature is designed to help users who may experience motion sickness or discomfort from excessive animations and transitions.

When Reduced Motion is enabled, the system reduces or eliminates certain animations, such as parallax effects, screen transitions, and other dynamic visual effects. Developers can also respect this setting in their apps by checking the user's preference and adjusting their animations accordingly.

How to Check for Reduced Motion in SwiftUI

In SwiftUI, you can check if the user has enabled Reduced Motion by using the accessibilityReduceMotion environment value. You can then conditionally apply animations based on this setting.

import SwiftUI

struct ContentView: View {
    @Environment(\.accessibilityReduceMotion) var reduceMotion
    @State private var isVisible = false

    var body: some View {
        VStack {
            Button("Toggle Text") {
                if reduceMotion {
                    isVisible.toggle()
                } else {
                    withAnimation {
                        isVisible.toggle()
                    }
                }
            }

            if isVisible {
                Text("Hello, SwiftUI!")
                    .transition(.slide)
            }
        }
    }
}

Bonus: CSS

You can also reduce animations on your website (if you have any).
You can copy & paste the following code in your css.

/* Reduce motion support */
@media (prefers-reduced-motion: reduce) {
    *,
    ::before,
    ::after {
        animation-delay: -1ms !important;
        animation-duration: 1ms !important;
        animation-iteration-count: 1 !important;
        background-attachment: initial !important;
        scroll-behavior: auto !important;
        transition-duration: 0s !important;
        transition-delay: 0s !important;
    }
}

source: https://web.dev/articles/prefers-reduced-motion#bonus_forcing_reduced_motion_on_all_websites

Wrap up

In this post we've explored Reduced Motion and how to respect user preferences in SwiftUI. By checking the accessibilityReduceMotion environment value, you can ensure a comfortable experience for users who are sensitive to motion.

Resources:

Sufficient Contrast

Mon, 30 Mar 2026 16:57:33 +0200

Sufficient contrast makes your text and UI elements readable for everyone — especially users with low vision or color blindness. WCAG recommends a minimum ratio of 4.5:1 for normal text and 3:1 for large text.

What is `Sufficient Contrast`?

Sufficient contrast refers to the difference in luminance or color that makes an object distinguishable from other objects and the background. In the context of user interfaces, it ensures that text and interactive elements are easily readable and accessible to all users, including those with visual impairments.

Why is Sufficient Contrast Important?

Sufficient contrast is vital for accessibility as it ensures that users with visual impairments, such as color blindness or low vision, can read and interact with content effectively. Poor contrast can lead to eye strain and make it difficult for users to navigate and understand information, ultimately excluding them from using your application.

How to Measure Contrast

Contrast is typically measured using a contrast ratio, which compares the luminance of the foreground (text or element) to the background. The Web Content Accessibility Guidelines (WCAG) recommend a minimum contrast ratio of 4.5:1 for normal text and 3:1 for large text.

Pro tip: My app iWebTools has a built-in contrast checker that you can use to evaluate the contrast ratios of your color choices.

Contrast checker

Foreground Color

Background Color

Ratio

Normal Text Minimum contrast ratio of 4.5:1

WCAG AA
WCAG AAA

Normal Text Example

Large Text Minimum contrast ratio of 3:1

WCAG AA
WCAG AAA

Large Text Example

Graphical Objects and User Interface Components Minimum contrast ratio of 3:1

WCAG AA
WCAG AAA

★ UI Component Example

Wrap up

Getting contrast right is one of the more impactful accessibility improvements you can make — and it benefits everyone, not just users with visual impairments.

Resources:

Larger Text

Mon, 30 Mar 2026 16:57:34 +0200

iOS lets users set their preferred text size system-wide through Accessibility settings. SwiftUI's dynamic type support handles most of this automatically — as long as you use semantic font styles like .body or .headline rather than fixed sizes.

Why Larger Text?

Larger text improves readability and accessibility for users with visual impairments or those who prefer bigger fonts for comfort. It ensures that content is easily legible, reducing eye strain and enhancing the overall user experience.

Implementation in SwiftUI

SwiftUI provides built-in support for dynamic type if the user has enabled larger text sizes in their device settings. To make your SwiftUI app support larger text, you can use the .font modifier with dynamic type styles.

Caveats

Larger text can lead to layout issues if not handled properly. Ensure that your UI components can adapt to different text sizes without clipping or overlapping. Use flexible layouts and consider testing with various text sizes.

You can use ViewThatFits to create views that adapt to different text sizes gracefully.
You can also use the .minimumScaleFactor(_:) modifier to allow text to shrink if necessary, ensuring it fits within its bounds.

Testing Larger Text

To test larger text support, you can

Use the Accessibility Inspector in Xcode to simulate different text sizes.
Change the text size in the Accessibility settings on your device or simulator. Navigate to Settings > Accessibility > Display & Text Size > Larger Text, and adjust the slider to see how your app responds to different text sizes.

View Example

import SwiftUI

struct ContentView: View {
    var body: some View {
        ViewThatFits {
            Text("This is an example of larger text support in SwiftUI.")
                .font(.largeTitle) // Use a dynamic type style
                .padding()

            Text("This is an example of larger text support in SwiftUI.")
                .font(.title) // Fallback for smaller sizes
                .padding()
        }
    }
}

Wrap up

Supporting dynamic type mostly means choosing the right font styles and testing with larger sizes. ViewThatFits and .minimumScaleFactor(_:) are useful when layouts get tight.

Resources:

Differentiate Without Color

Mon, 30 Mar 2026 16:57:34 +0200

Color is a powerful design tool, but relying solely on color to convey information creates accessibility barriers for users with color blindness or low vision. In this post, we'll explore how to make your SwiftUI apps more accessible by ensuring that information is communicated through multiple visual channels, not just color alone.

What is Differentiate Without Color?

Differentiate Without Color is an accessibility feature that helps users who have difficulty distinguishing colors. Approximately 8% of men and 0.5% of women have some form of color vision deficiency, making it essential to provide alternative ways to convey information.

When users enable "Differentiate Without Color" in their accessibility settings, your app should supplement color-based information with additional visual indicators such as:

Icons and symbols
Text labels
Patterns and textures
Shapes and borders
Position and size differences

For example, instead of using only red and green to show error and success states, you should also include an X icon for errors and a checkmark for success.

How to Implement in SwiftUI

SwiftUI provides the accessibilityDifferentiateWithoutColor environment variable to detect when users have enabled this setting. You can use this to adapt your UI accordingly.

Checking the Environment Variable

import SwiftUI

struct ContentView: View {
    @Environment(\.accessibilityDifferentiateWithoutColor) 
    var differentiateWithoutColor

    var body: some View {
        VStack {
            if differentiateWithoutColor {
                Text("Differentiate Without Color is enabled")
            } else {
                Text("Using standard color scheme")
            }
        }
    }
}

Bad Practice: Color Only

Here's an example of what NOT to do - using color alone to convey status:

struct BadStatusView: View {
    let isSuccess: Bool

    var body: some View {
        Text("Operation Complete")
            .padding()
            .background(isSuccess ? Color.green : Color.red)
            .cornerRadius(8)
    }
}

This design fails because color-blind users may not be able to distinguish between the red and green states.

Good Practice: Color + Icons

Here's a better approach that uses both color and icons:

struct GoodStatusView: View {
    @Environment(\.accessibilityDifferentiateWithoutColor) 
    var differentiateWithoutColor
    let isSuccess: Bool

    var statusIcon: String {
        isSuccess ? "checkmark.circle.fill" : "xmark.circle.fill"
    }

    var statusColor: Color {
        isSuccess ? .green : .red
    }

    var body: some View {
        HStack {
            Image(systemName: statusIcon)
                .foregroundColor(differentiateWithoutColor ? .primary : statusColor)

            Text(isSuccess ? "Success" : "Error")
                .foregroundColor(differentiateWithoutColor ? .primary : statusColor)
        }
        .padding()
        .background(
            RoundedRectangle(cornerRadius: 8)
                .stroke(differentiateWithoutColor ? Color.primary : statusColor, lineWidth: 2)
        )
    }
}

Chart Example with Patterns

When creating charts or graphs, use patterns in addition to colors:

struct AccessibleChartView: View {
    @Environment(\.accessibilityDifferentiateWithoutColor) 
    var differentiateWithoutColor

    let data: [(String, Double, String)] = [
        ("Category A", 0.3, "circle.fill"),
        ("Category B", 0.5, "square.fill"),
        ("Category C", 0.2, "triangle.fill")
    ]

    var body: some View {
        VStack(spacing: 20) {
            ForEach(data, id: \.0) { item in
                HStack {
                    // Icon helps differentiate
                    if differentiateWithoutColor {
                        Image(systemName: item.2)
                            .frame(width: 30)
                    }

                    Text(item.0)
                        .frame(width: 100, alignment: .leading)

                    // Visual bar
                    Rectangle()
                        .fill(colorForCategory(item.0))
                        .frame(width: CGFloat(item.1) * 200, height: 30)
                        .overlay(
                            // Add pattern when needed
                            differentiateWithoutColor ? 
                                Image(systemName: item.2)
                                    .resizable()
                                    .scaledToFit()
                                    .padding(4) : nil
                        )
                }
            }
        }
        .padding()
    }

    func colorForCategory(_ category: String) -> Color {
        switch category {
        case "Category A": return .blue
        case "Category B": return .orange
        case "Category C": return .purple
        default: return .gray
        }
    }
}

Button States Example

For interactive elements like buttons, combine color with shape and text:

struct AccessibleButton: View {
    @Environment(\.accessibilityDifferentiateWithoutColor) 
    var differentiateWithoutColor

    let isActive: Bool
    let action: () -> Void

    var body: some View {
        Button(action: action) {
            HStack {
                // Always show text
                Text(isActive ? "Active" : "Inactive")

                // Add icon for clarity
                Image(systemName: isActive ? "checkmark.circle" : "circle")
            }
            .padding()
            .background(
                RoundedRectangle(cornerRadius: 8)
                    .fill(isActive && !differentiateWithoutColor ? 
                          Color.blue : Color.gray.opacity(0.2))
                    .overlay(
                        RoundedRectangle(cornerRadius: 8)
                            .stroke(isActive ? Color.primary : Color.gray, 
                                   lineWidth: differentiateWithoutColor ? 3 : 1)
                    )
            )
        }
    }
}

Best Practices

Always provide multiple indicators: Never rely on color alone. Use icons, labels, patterns, or shapes alongside color.
Test with color blindness simulators: Use tools to see how your app appears to users with different types of color vision deficiency.
Use semantic colors: SwiftUI's semantic colors (.primary, .secondary, .accentColor) adapt to user preferences automatically.
Provide clear labels: Text labels should always accompany color-coded information.
Consider contrast: Even when adding icons, maintain sufficient color contrast for users with low vision.
Respect user preferences: Check the accessibilityDifferentiateWithoutColor environment variable and adapt your UI accordingly.

Wrap up

Color alone is never enough to convey meaning — pair it with icons, labels, or patterns. The accessibilityDifferentiateWithoutColor environment variable makes it straightforward to adapt your UI when users have this preference enabled.

Resources:

VoiceOver

Mon, 30 Mar 2026 16:57:34 +0200

VoiceOver is Apple's screen reader that enables blind and low vision users to navigate and interact with iOS, iPadOS, and macOS devices. In this post, we'll explore how to make your SwiftUI apps fully accessible to VoiceOver users by providing clear, descriptive labels and implementing proper accessibility support.

What is VoiceOver?

VoiceOver is a gesture-based screen reader that speaks aloud the elements on the screen, allowing users who are blind or have low vision to use their devices without seeing the display. Users navigate through interface elements sequentially, and VoiceOver announces what each element is and what it does.

VoiceOver is used by millions of people worldwide and is considered one of the most powerful assistive technologies built into modern operating systems. When a user touches an element on screen (or focuses it with keyboard navigation), VoiceOver announces:

What the element is (button, text field, image, etc.)
The element's label or content
The element's state (selected, disabled, etc.)
A hint about how to interact with it (if provided)

How to Implement VoiceOver Support in SwiftUI

SwiftUI provides excellent default VoiceOver support, but you can enhance it with accessibility modifiers to create an even better experience.

Basic Accessibility Labels

Use .accessibilityLabel(_:) to provide descriptive text for elements that don't have clear text content:

import SwiftUI

struct BasicAccessibilityView: View {
    var body: some View {
        VStack(spacing: 20) {
            // Bad: No context for icon-only button
            Button(action: shareContent) {
                Image(systemName: "square.and.arrow.up")
            }

            // Good: Clear label for VoiceOver users
            Button(action: shareContent) {
                Image(systemName: "square.and.arrow.up")
            }
            .accessibilityLabel("Share")
        }
    }

    func shareContent() {
        print("Sharing content")
    }
}

Accessibility Hints

Use .accessibilityHint(_:) to provide additional context about what will happen when the user interacts with an element:

struct HintExample: View {
    @State private var itemCount = 0

    var body: some View {
        VStack(spacing: 20) {
            Text("Items: \(itemCount)")

            Button("Add Item") {
                itemCount += 1
            }
            .accessibilityLabel("Add Item")
            .accessibilityHint("Increases the item count by one")

            Button(action: clearItems) {
                Image(systemName: "trash")
            }
            .accessibilityLabel("Clear all items")
            .accessibilityHint("Removes all items from your collection")
        }
    }

    func clearItems() {
        itemCount = 0
    }
}

Grouping Accessibility Elements

Use .accessibilityElement(children:) to group related elements so VoiceOver reads them as a single unit:

struct CardView: View {
    let title: String
    let subtitle: String
    let description: String

    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text(title)
                .font(.headline)

            Text(subtitle)
                .font(.subheadline)
                .foregroundColor(.secondary)

            Text(description)
                .font(.body)
        }
        .padding()
        .background(Color.gray.opacity(0.1))
        .cornerRadius(12)
        // Combine all text into one announcement
        .accessibilityElement(children: .combine)
    }
}

For more complex grouping:

struct ProfileCard: View {
    let name: String
    let role: String
    let isOnline: Bool

    var body: some View {
        HStack(spacing: 16) {
            Image(systemName: "person.circle.fill")
                .resizable()
                .frame(width: 50, height: 50)
                .accessibilityHidden(true) // Decorative, hide from VoiceOver

            VStack(alignment: .leading) {
                Text(name)
                    .font(.headline)

                Text(role)
                    .font(.subheadline)
                    .foregroundColor(.secondary)

                HStack {
                    Circle()
                        .fill(isOnline ? Color.green : Color.gray)
                        .frame(width: 8, height: 8)

                    Text(isOnline ? "Online" : "Offline")
                        .font(.caption)
                }
            }
        }
        .padding()
        .accessibilityElement(children: .combine)
        .accessibilityLabel("\(name), \(role), \(isOnline ? "Online" : "Offline")")
    }
}

Custom Controls and Views

For custom interactive controls, make sure to provide all necessary accessibility information:

struct CustomSlider: View {
    @State private var value: Double = 50

    var body: some View {
        VStack {
            Text("Volume: \(Int(value))%")

            Slider(value: $value, in: 0...100, step: 1)
                .accessibilityLabel("Volume")
                .accessibilityValue("\(Int(value)) percent")
                .accessibilityHint("Adjusts the volume level")
        }
        .padding()
    }
}

For custom views with complex interactions:

struct CustomRatingControl: View {
    @Binding var rating: Int
    let maxRating: Int = 5

    var body: some View {
        HStack {
            ForEach(1...maxRating, id: \.self) { star in
                Image(systemName: star <= rating ? "star.fill" : "star")
                    .foregroundColor(star <= rating ? .yellow : .gray)
                    .onTapGesture {
                        rating = star
                    }
            }
        }
        // Combine all stars into one accessibility element
        .accessibilityElement(children: .ignore)
        .accessibilityLabel("Rating")
        .accessibilityValue("\(rating) out of \(maxRating) stars")
        .accessibilityAdjustableAction { direction in
            switch direction {
            case .increment:
                if rating < maxRating { rating += 1 }
            case .decrement:
                if rating > 0 { rating -= 1 }
            @unknown default:
                break
            }
        }
    }
}

Form Fields

Properly label form fields and provide clear error messages:

struct AccessibleForm: View {
    @State private var email = ""
    @State private var password = ""
    @State private var emailError: String?

    var body: some View {
        Form {
            Section {
                TextField("Email", text: $email)
                    .textContentType(.emailAddress)
                    .keyboardType(.emailAddress)
                    .accessibilityLabel("Email address")
                    .accessibilityHint("Enter your email address")

                if let error = emailError {
                    Text(error)
                        .foregroundColor(.red)
                        .font(.caption)
                        .accessibilityLabel("Email error: \(error)")
                }

                SecureField("Password", text: $password)
                    .textContentType(.password)
                    .accessibilityLabel("Password")
                    .accessibilityHint("Enter your password")
            }

            Section {
                Button("Sign In") {
                    validateAndSignIn()
                }
                .accessibilityLabel("Sign In")
                .accessibilityHint("Submits the form to sign in")
            }
        }
    }

    func validateAndSignIn() {
        if !email.contains("@") {
            emailError = "Please enter a valid email address"
        }
    }
}

Lists and Dynamic Content

For lists with many items, provide meaningful labels:

struct MessageList: View {
    let messages: [Message]

    var body: some View {
        List(messages) { message in
            MessageRow(message: message)
                .accessibilityElement(children: .combine)
                .accessibilityLabel("""
                    Message from \(message.sender), \
                    received \(message.time), \
                    \(message.isRead ? "read" : "unread")
                    """)
                .accessibilityHint("Double tap to open message")
        }
    }
}

struct Message: Identifiable {
    let id = UUID()
    let sender: String
    let preview: String
    let time: String
    let isRead: Bool
}

struct MessageRow: View {
    let message: Message

    var body: some View {
        HStack {
            VStack(alignment: .leading) {
                Text(message.sender)
                    .font(.headline)
                Text(message.preview)
                    .font(.subheadline)
                    .foregroundColor(.secondary)
            }

            Spacer()

            VStack(alignment: .trailing) {
                Text(message.time)
                    .font(.caption)

                if !message.isRead {
                    Circle()
                        .fill(Color.blue)
                        .frame(width: 8, height: 8)
                }
            }
        }
    }
}

Best Practices for VoiceOver Support

Be Descriptive but Concise: Labels should be clear and to the point. Avoid redundancy (don't say "button" - VoiceOver announces the element type).
Provide Context: Use hints to explain what will happen when the user interacts with an element, especially for non-obvious actions.
Hide Decorative Elements: Use .accessibilityHidden(true) for purely decorative images and icons.
Group Related Content: Use .accessibilityElement(children: .combine) to group related elements that should be read as one unit.
Update Accessibility Info Dynamically: When content changes, make sure accessibility labels and values update too.
Test with VoiceOver: Always test your app with VoiceOver enabled. Enable it in Settings > Accessibility > VoiceOver, or use the triple-click home/side button shortcut.
Announce State Changes: For dynamic content that changes without user interaction, consider using accessibility notifications to alert VoiceOver users.
Avoid Long Labels: Keep accessibility labels under 2-3 sentences. Very long labels can be frustrating for VoiceOver users.

Wrap up

VoiceOver support starts with good labels and traits. Test with VoiceOver turned on — navigating your own app with it running is the fastest way to find gaps you wouldn't spot otherwise.

Resources:

Voice Control

Mon, 30 Mar 2026 16:57:35 +0200

Voice Control enables users to navigate and interact with their devices entirely through voice commands, without touching the screen or using a keyboard. In this post, we'll explore how to ensure your SwiftUI apps work seamlessly with Voice Control, making them accessible to users with motor impairments and those who prefer hands-free interaction.

What is Voice Control?

Voice Control is an accessibility feature that allows users to control their devices using only their voice. Unlike VoiceOver (which is for blind users), Voice Control is designed for users who have difficulty with physical interaction—such as those with motor impairments, repetitive strain injuries, or temporary injuries.

With Voice Control enabled, users can:

Navigate through apps by saying "Tap [label]"
Speak numbers that appear on screen elements
Use voice commands for gestures like scrolling and swiping
Dictate text into fields
Control the entire device without physical touch

Voice Control displays numbers or names over interactive elements, allowing users to precisely target what they want to interact with by voice.

How Voice Control Differs from VoiceOver

While both are voice-based accessibility features, they serve different purposes:

VoiceOver: Screen reader for blind users. Reads content aloud and uses gestures for navigation.
Voice Control: Hands-free navigation for users with motor impairments. Users speak commands to interact with visible interface elements.

Understanding this distinction is crucial for proper implementation. Voice Control users can see the screen but may not be able to touch it effectively.

How to Implement Voice Control Support in SwiftUI

The good news is that most Voice Control support comes from proper VoiceOver support. However, there are specific considerations for Voice Control users.

Basic Button Accessibility

Voice Control relies on accessibility labels to identify elements. Users speak the label to interact with an element:

import SwiftUI

struct VoiceControlExample: View {
    var body: some View {
        VStack(spacing: 20) {
            // User can say "Tap Submit"
            Button("Submit") {
                submitForm()
            }

            // For icon-only buttons, provide a clear label
            Button(action: refreshData) {
                Image(systemName: "arrow.clockwise")
            }
            .accessibilityLabel("Refresh")
            // User can say "Tap Refresh"

            // Complex button with multiple elements
            Button(action: shareContent) {
                HStack {
                    Image(systemName: "square.and.arrow.up")
                    Text("Share")
                }
            }
            .accessibilityLabel("Share")
            .accessibilityHint("Opens the share sheet")
        }
    }

    func submitForm() {
        print("Form submitted")
    }

    func refreshData() {
        print("Refreshing data...")
    }

    func shareContent() {
        print("Sharing content")
    }
}

Using `.accessibilityInputLabels(_:)` for Alternative Commands

Voice Control users might try different phrases to interact with your buttons. Use .accessibilityInputLabels(_:) to provide alternative voice commands:

struct AlternativeLabelsExample: View {
    var body: some View {
        VStack(spacing: 20) {
            // User can say "Tap Save", "Tap Submit", or "Tap Send"
            Button("Save") {
                saveDocument()
            }
            .accessibilityLabel("Save")
            .accessibilityInputLabels(["Save", "Submit", "Send"])

            // User can say "Tap Delete", "Tap Remove", or "Tap Trash"
            Button(action: deleteItem) {
                Image(systemName: "trash")
            }
            .accessibilityLabel("Delete")
            .accessibilityInputLabels(["Delete", "Remove", "Trash"])

            // Shopping cart with multiple commands
            Button(action: checkout) {
                HStack {
                    Image(systemName: "cart")
                    Text("Cart")
                }
            }
            .accessibilityLabel("Shopping Cart")
            .accessibilityInputLabels([
                "Shopping Cart",
                "Cart",
                "Basket",
                "Checkout"
            ])
        }
    }

    func saveDocument() {
        print("Document saved")
    }

    func deleteItem() {
        print("Item deleted")
    }

    func checkout() {
        print("Checking out...")
    }
}

Interactive Form Elements

For forms, ensure all interactive elements have clear, speakable labels:

struct VoiceControlForm: View {
    @State private var username = ""
    @State private var email = ""
    @State private var agreeToTerms = false

    var body: some View {
        Form {
            Section(header: Text("Account Information")) {
                TextField("Username", text: $username)
                    .accessibilityLabel("Username")
                    .accessibilityInputLabels(["Username", "User name", "Login name"])

                TextField("Email", text: $email)
                    .accessibilityLabel("Email address")
                    .accessibilityInputLabels(["Email", "Email address", "E-mail"])
            }

            Section {
                Toggle("I agree to the terms and conditions", isOn: $agreeToTerms)
                    .accessibilityLabel("Agree to terms")
                    .accessibilityInputLabels([
                        "Agree to terms",
                        "Terms and conditions",
                        "Accept terms"
                    ])
            }

            Section {
                Button("Create Account") {
                    createAccount()
                }
                .accessibilityLabel("Create Account")
                .accessibilityInputLabels([
                    "Create Account",
                    "Sign up",
                    "Register"
                ])
            }
        }
    }

    func createAccount() {
        guard !username.isEmpty, !email.isEmpty, agreeToTerms else {
            print("Please fill in all fields and agree to the terms")
            return
        }
        print("Account created for \(username)")
    }
}

Custom Controls

For custom controls, ensure they're focusable and have appropriate labels:

struct CustomStarRating: View {
    @Binding var rating: Int
    let maxRating: Int = 5

    var body: some View {
        HStack(spacing: 12) {
            ForEach(1...maxRating, id: \.self) { index in
                Button(action: {
                    rating = index
                }) {
                    Image(systemName: index <= rating ? "star.fill" : "star")
                        .foregroundColor(index <= rating ? .yellow : .gray)
                        .font(.title)
                }
                .accessibilityLabel("\(index) star\(index == 1 ? "" : "s")")
                .accessibilityInputLabels([
                    "\(index) star\(index == 1 ? "" : "s")",
                    "Star \(index)",
                    "\(index)"
                ])
                .accessibilityHint("Sets rating to \(index) out of \(maxRating)")
            }
        }
        .accessibilityElement(children: .contain)
    }
}

struct RatingView: View {
    @State private var rating = 0

    var body: some View {
        VStack {
            Text("Rate this item")
                .font(.headline)

            CustomStarRating(rating: $rating)

            Text("Current rating: \(rating) stars")
                .font(.subheadline)
        }
        .padding()
    }
}

Navigation and Lists

For lists and navigation, ensure each item is clearly labeled:

struct VoiceControlList: View {
    let items = ["Home", "Settings", "Profile", "Help", "About"]

    var body: some View {
        NavigationView {
            List {
                ForEach(items, id: \.self) { item in
                    NavigationLink(destination: DetailView(title: item)) {
                        HStack {
                            Image(systemName: iconForItem(item))
                            Text(item)
                        }
                    }
                    .accessibilityLabel(item)
                    .accessibilityInputLabels([item, "Go to \(item)"])
                }
            }
            .navigationTitle("Menu")
        }
    }

    func iconForItem(_ item: String) -> String {
        switch item {
        case "Home": return "house"
        case "Settings": return "gear"
        case "Profile": return "person"
        case "Help": return "questionmark.circle"
        case "About": return "info.circle"
        default: return "doc"
        }
    }
}

struct DetailView: View {
    let title: String

    var body: some View {
        Text("\(title) Details")
            .navigationTitle(title)
    }
}

Context Menus and Actions

Ensure context menu items are accessible with Voice Control:

struct ContextMenuExample: View {
    @State private var selectedItem: String?

    var body: some View {
        VStack {
            Text("Long press or say 'Show Actions' for the box")
                .padding()

            RoundedRectangle(cornerRadius: 12)
                .fill(Color.blue)
                .frame(width: 200, height: 200)
                .contextMenu {
                    Button(action: copyAction) {
                        Label("Copy", systemImage: "doc.on.doc")
                    }
                    .accessibilityLabel("Copy")

                    Button(action: shareAction) {
                        Label("Share", systemImage: "square.and.arrow.up")
                    }
                    .accessibilityLabel("Share")

                    Button(role: .destructive, action: deleteAction) {
                        Label("Delete", systemImage: "trash")
                    }
                    .accessibilityLabel("Delete")
                }
                .accessibilityLabel("Content box")
                .accessibilityHint("Long press for actions menu")
        }
    }

    func copyAction() {
        print("Item copied to clipboard")
    }

    func shareAction() {
        print("Sharing item...")
    }

    func deleteAction() {
        print("Item deleted")
    }
}

Best Practices for Voice Control

Use Clear, Speakable Labels: Choose labels that are easy to pronounce and remember. Avoid technical jargon when possible.
Provide Alternative Input Labels: Use .accessibilityInputLabels(_:) to give users multiple ways to refer to the same element.
Keep Labels Short: Shorter labels are easier to speak. "Save" is better than "Save Document to Cloud Storage".
Avoid Ambiguous Labels: Don't have multiple buttons with the same label. Voice Control users need unique identifiers.
Test Common Phrases: Think about what users might naturally say to interact with your elements and include those as input labels.
Make All Interactive Elements Accessible: Every button, link, and control should have a proper accessibility label.
Use Descriptive Text: When possible, use actual text labels instead of just icons. This makes Voice Control more intuitive.
Group Related Actions: For complex views, consider grouping related actions under a single accessible element.
Test with Voice Control: Enable Voice Control (Settings > Accessibility > Voice Control) and try navigating your app using only your voice.

Testing Voice Control

To test your app with Voice Control:

Go to Settings > Accessibility > Voice Control
Turn on Voice Control
A microphone icon appears when Voice Control is listening
Say "Show numbers" to see numbered overlays on interactive elements
Say "Show names" to see text labels on interactive elements
Try saying "Tap [label]" for your buttons

Common voice commands:

"Tap [name]" - Activates a button or control
"Show numbers" / "Show names" - Displays overlays
"Scroll down" / "Scroll up" - Scrolls content
"Go home" - Returns to home screen
"Open [app name]" - Opens an app

Wrap up

Voice Control mostly works automatically if you've already handled VoiceOver. The main thing to add is .accessibilityInputLabels(_:) on elements where the visible label doesn't match what a user would naturally say.

Resources:

Captions

Mon, 30 Mar 2026 16:57:35 +0200

Captions and subtitles make video and audio content accessible to deaf and hard of hearing users, as well as non-native speakers and users in sound-sensitive environments. In this post, we'll explore how to implement caption support in your SwiftUI apps and respect user preferences for displaying captions.

What are Captions?

Captions (also called subtitles or closed captions) are text overlays that display spoken dialogue, sound effects, and other audio information in video content. They enable:

Deaf and hard of hearing users to access audio content
Non-native speakers to better understand dialogue
Users in quiet environments where audio can't be played
Users in noisy environments where audio is hard to hear
Language learners to improve comprehension
Users who prefer reading to listening

There are two types of captions:

Closed Captions (CC): Can be turned on/off by the user
Open Captions: Always visible, burned into the video

In accessible apps, you should always provide closed captions so users can choose whether to display them.

Detecting User Caption Preferences

iOS provides an accessibility setting that allows users to indicate they prefer captions. You can detect this preference using the accessibilityShowsClosedCaptions environment variable:

import SwiftUI

struct CaptionPreferenceView: View {
    @Environment(\.accessibilityShowsClosedCaptions) 
    var showCaptions

    var body: some View {
        VStack(spacing: 20) {
            Text("Caption Preference")
                .font(.headline)

            if showCaptions {
                Text("✓ User prefers captions enabled")
                    .foregroundColor(.green)
            } else {
                Text("User has not enabled caption preference")
                    .foregroundColor(.secondary)
            }
        }
        .padding()
    }
}

Adding Captions to Video in SwiftUI

SwiftUI uses AVFoundation for video playback, which has built-in support for captions through subtitle tracks. Here's how to implement it:

Basic Video Player with Caption Support

import SwiftUI
import AVKit

struct VideoPlayerWithCaptions: View {
    @Environment(\.accessibilityShowsClosedCaptions) 
    var showCaptions

    @State private var player: AVPlayer?

    var body: some View {
        VStack {
            if let player = player {
                VideoPlayer(player: player)
                    .frame(height: 300)
                    .onAppear {
                        configureCaptions(for: player)
                    }
            } else {
                ProgressView("Loading video...")
                    .frame(height: 300)
            }

            Text("Video with captions")
                .font(.headline)
                .padding()
        }
        .onAppear {
            setupPlayer()
        }
    }

    func setupPlayer() {
        // Replace with your video URL
        guard let videoURL = Bundle.main.url(
            forResource: "sample",
            withExtension: "mp4"
        ) else { return }

        player = AVPlayer(url: videoURL)
    }

    func configureCaptions(for player: AVPlayer) {
        // Enable captions based on user preference
        guard let currentItem = player.currentItem else { return }

        // Get available media selection options
        let legibleGroup = currentItem.asset.mediaSelectionGroup(
            forMediaCharacteristic: .legible
        )

        if let legibleGroup = legibleGroup {
            // Find the appropriate caption track
            let selectedOption: AVMediaSelectionOption?

            if showCaptions {
                // Select caption track if available
                selectedOption = legibleGroup.options.first
            } else {
                // No captions
                selectedOption = nil
            }

            currentItem.select(selectedOption, in: legibleGroup)
        }
    }
}

Advanced Video Player with Caption Controls

struct AdvancedVideoPlayer: View {
    @Environment(\.accessibilityShowsClosedCaptions) 
    var userPrefersClosedCaptions

    @State private var player: AVPlayer?
    @State private var showCaptions: Bool = false
    @State private var availableCaptionLanguages: [String] = []
    @State private var selectedCaptionLanguage: String?

    var body: some View {
        VStack(spacing: 0) {
            if let player = player {
                VideoPlayer(player: player)
                    .frame(height: 300)
            }

            // Caption controls
            VStack(alignment: .leading, spacing: 16) {
                Toggle("Show Captions", isOn: $showCaptions)
                    .onChange(of: showCaptions) { newValue in
                        updateCaptions()
                    }

                if showCaptions && !availableCaptionLanguages.isEmpty {
                    VStack(alignment: .leading, spacing: 8) {
                        Text("Caption Language")
                            .font(.subheadline)
                            .foregroundColor(.secondary)

                        Picker("Language", selection: $selectedCaptionLanguage) {
                            ForEach(availableCaptionLanguages, id: \.self) { lang in
                                Text(lang).tag(lang as String?)
                            }
                        }
                        .pickerStyle(MenuPickerStyle())
                        .onChange(of: selectedCaptionLanguage) { _ in
                            updateCaptions()
                        }
                    }
                }
            }
            .padding()
        }
        .onAppear {
            setupPlayer()
            // Respect user's system preference
            showCaptions = userPrefersClosedCaptions
        }
    }

    func setupPlayer() {
        guard let videoURL = Bundle.main.url(
            forResource: "sample",
            withExtension: "mp4"
        ) else { return }

        player = AVPlayer(url: videoURL)

        // Load available caption languages
        loadAvailableCaptions()
    }

    func loadAvailableCaptions() {
        guard let currentItem = player?.currentItem else { return }

        let legibleGroup = currentItem.asset.mediaSelectionGroup(
            forMediaCharacteristic: .legible
        )

        if let options = legibleGroup?.options {
            availableCaptionLanguages = options.compactMap { option in
                option.displayName
            }

            if !availableCaptionLanguages.isEmpty {
                selectedCaptionLanguage = availableCaptionLanguages.first
            }
        }
    }

    func updateCaptions() {
        guard let currentItem = player?.currentItem,
              let legibleGroup = currentItem.asset.mediaSelectionGroup(
                forMediaCharacteristic: .legible
              ) else { return }

        if showCaptions, let selectedLang = selectedCaptionLanguage {
            // Find and select the caption track matching the language
            let option = legibleGroup.options.first { option in
                option.displayName == selectedLang
            }
            currentItem.select(option, in: legibleGroup)
        } else {
            // Turn off captions
            currentItem.select(nil, in: legibleGroup)
        }
    }
}

Creating Caption Files

Captions are typically provided in WebVTT (.vtt) or SRT (.srt) format. Here's an example WebVTT file:

WEBVTT

00:00:00.000 --> 00:00:02.000
Welcome to our app tutorial.

00:00:02.500 --> 00:00:05.000
Today we'll show you how to get started.

00:00:05.500 --> 00:00:08.000
[upbeat music playing]

00:00:08.500 --> 00:00:12.000
First, tap the plus button to create a new project.

Adding Caption Files to Your Video

import AVFoundation

func createPlayerItemWithCaptions(
    videoURL: URL,
    captionURL: URL
) -> AVPlayerItem {
    let asset = AVURLAsset(url: videoURL)
    let playerItem = AVPlayerItem(asset: asset)

    // Create a mutable composition
    let composition = AVMutableComposition()

    // Add video track
    guard let videoTrack = asset.tracks(
        withMediaType: .video
    ).first else {
        return playerItem
    }

    let compositionVideoTrack = composition.addMutableTrack(
        withMediaType: .video,
        preferredTrackID: kCMPersistentTrackID_Invalid
    )

    try? compositionVideoTrack?.insertTimeRange(
        CMTimeRangeMake(start: .zero, duration: asset.duration),
        of: videoTrack,
        at: .zero
    )

    // Add caption track
    let subtitleAsset = AVURLAsset(url: captionURL)

    if let subtitleTrack = subtitleAsset.tracks(
        withMediaType: .text
    ).first {
        let compositionSubtitleTrack = composition.addMutableTrack(
            withMediaType: .text,
            preferredTrackID: kCMPersistentTrackID_Invalid
        )

        try? compositionSubtitleTrack?.insertTimeRange(
            CMTimeRangeMake(start: .zero, duration: asset.duration),
            of: subtitleTrack,
            at: .zero
        )
    }

    return AVPlayerItem(asset: composition)
}

Best Practices for Captions

Respect User Preferences: Always check accessibilityShowsClosedCaptions and enable captions by default if the user has expressed this preference.
Provide Accurate Timing: Captions should appear in sync with the audio, ideally staying on screen long enough to be read comfortably.
Include Sound Effects: Caption important non-speech sounds like [door closes], [applause], or [suspenseful music].
Identify Speakers: When multiple people speak, identify who is talking, especially if they're off-screen.
Use Standard Formatting:
- Keep lines to 32-42 characters
- Maximum 2 lines per caption
- Display for 1-7 seconds based on reading speed
Provide Caption Controls: Give users the ability to toggle captions on/off and select language if multiple tracks are available.
Test Readability: Ensure captions are readable against your video content. Good players provide a semi-transparent background.
Support Multiple Languages: Provide captions in multiple languages when possible for international users.
Quality Over Auto-Generation: While auto-generated captions are better than nothing, human-reviewed captions are significantly more accurate and accessible.

Caption Styling

While native video players handle caption styling, if you're creating a custom player, ensure your captions have:

struct CustomCaptionStyle {
    static let textColor = Color.white
    static let backgroundColor = Color.black.opacity(0.75)
    static let font = Font.system(size: 18, weight: .semibold)
    static let padding: CGFloat = 8
    static let cornerRadius: CGFloat = 4
}

struct CaptionOverlay: View {
    let text: String

    var body: some View {
        Text(text)
            .font(CustomCaptionStyle.font)
            .foregroundColor(CustomCaptionStyle.textColor)
            .padding(CustomCaptionStyle.padding)
            .background(
                RoundedRectangle(cornerRadius: CustomCaptionStyle.cornerRadius)
                    .fill(CustomCaptionStyle.backgroundColor)
            )
            .multilineTextAlignment(.center)
    }
}

Wrap up

Captions help deaf and hard of hearing users, but they also benefit people watching in noisy environments or learning a language — they're a usability feature as much as an accessibility one. Use accessibilityShowsClosedCaptions to respect the user's system preference and enable them by default when it's set.

Resources:

Audio Descriptions

Mon, 30 Mar 2026 16:57:35 +0200

Audio descriptions provide narration of visual elements in video content, making it accessible to blind and low vision users. In this post, we'll explore what audio descriptions are, how to detect user preferences for them, and how to implement audio description support in your SwiftUI apps.

What are Audio Descriptions?

Audio descriptions (also called video descriptions or descriptive narration) are audio tracks that describe important visual information in videos during natural pauses in dialogue. They narrate:

Actions and gestures: What characters are doing
Scene changes: Where the action takes place
On-screen text: Titles, captions, or important text
Expressions and emotions: Non-verbal communication
Visual effects: Important visual elements that convey meaning

Audio descriptions enable blind and low vision users to understand visual content they cannot see. For example, in a cooking video, audio descriptions might say: "She pours flour into a large mixing bowl, then cracks two eggs into the center."

Who Benefits from Audio Descriptions?

Blind users who cannot see the video at all
Low vision users who may miss visual details
Users with cognitive disabilities who benefit from additional context
Users in situations where they can't watch the screen (driving, exercising, etc.)

Detecting User Preferences in SwiftUI

iOS provides accessibility settings for audio descriptions. You can detect if a user prefers audio descriptions using the accessibilityDifferentiateWithoutColor environment variable (for older iOS versions) or by checking AVPlayer's accessibility options:

import SwiftUI
import AVFoundation

struct AudioDescriptionPreferenceView: View {
    @State private var userPrefersAudioDescriptions = false

    var body: some View {
        VStack(spacing: 20) {
            Text("Audio Description Settings")
                .font(.headline)

            if userPrefersAudioDescriptions {
                Text("✓ User prefers audio descriptions")
                    .foregroundColor(.green)
            } else {
                Text("Standard audio track will be used")
                    .foregroundColor(.secondary)
            }
        }
        .padding()
        .onAppear {
            checkAudioDescriptionPreference()
        }
    }

    func checkAudioDescriptionPreference() {
        // Check if user has enabled audio descriptions
        // This is typically done through AVFoundation's media selection
        userPrefersAudioDescriptions = AVAudioSession.sharedInstance()
            .currentRoute.outputs.contains { output in
                // Check for accessibility features
                output.portType == .headphones
            }
    }
}

Implementing Audio Descriptions with AVFoundation

AVFoundation supports multiple audio tracks, allowing you to provide both standard audio and audio with descriptions:

Basic Video Player with Audio Description Support

import SwiftUI
import AVKit

struct VideoPlayerWithAudioDescriptions: View {
    @State private var player: AVPlayer?
    @State private var hasAudioDescriptions = false

    var body: some View {
        VStack {
            if let player = player {
                VideoPlayer(player: player)
                    .frame(height: 300)
            }

            VStack(alignment: .leading, spacing: 16) {
                Text("Audio Track Options")
                    .font(.headline)

                if hasAudioDescriptions {
                    HStack {
                        Image(systemName: "checkmark.circle.fill")
                            .foregroundColor(.green)
                        Text("Audio descriptions available")
                    }
                } else {
                    HStack {
                        Image(systemName: "info.circle")
                            .foregroundColor(.secondary)
                        Text("Standard audio only")
                    }
                }
            }
            .padding()
        }
        .onAppear {
            setupPlayer()
        }
    }

    func setupPlayer() {
        guard let videoURL = Bundle.main.url(
            forResource: "sample_with_descriptions",
            withExtension: "mp4"
        ) else { return }

        let asset = AVURLAsset(url: videoURL)
        let playerItem = AVPlayerItem(asset: asset)
        player = AVPlayer(playerItem: playerItem)

        // Check for audio description tracks
        checkForAudioDescriptions(in: asset)

        // Configure audio descriptions
        configureAudioDescriptions(for: playerItem)
    }

    func checkForAudioDescriptions(in asset: AVAsset) {
        let audibleGroup = asset.mediaSelectionGroup(
            forMediaCharacteristic: .audible
        )

        if let audibleGroup = audibleGroup {
            // Check if any audio track has descriptions
            hasAudioDescriptions = audibleGroup.options.contains { option in
                option.hasMediaCharacteristic(.describesVideoForAccessibility)
            }
        }
    }

    func configureAudioDescriptions(for playerItem: AVPlayerItem) {
        guard let audibleGroup = playerItem.asset.mediaSelectionGroup(
            forMediaCharacteristic: .audible
        ) else { return }

        // Find audio track with descriptions
        let audioWithDescriptions = audibleGroup.options.first { option in
            option.hasMediaCharacteristic(.describesVideoForAccessibility)
        }

        // Select the audio description track if available
        if let descriptiveTrack = audioWithDescriptions {
            playerItem.select(descriptiveTrack, in: audibleGroup)
        }
    }
}

Advanced Player with Audio Track Selection

struct AdvancedAudioDescriptionPlayer: View {
    @State private var player: AVPlayer?
    @State private var audioTracks: [AudioTrackInfo] = []
    @State private var selectedTrack: AudioTrackInfo?
    @State private var showTrackPicker = false

    struct AudioTrackInfo: Identifiable, Hashable {
        let id = UUID()
        let displayName: String
        let hasDescriptions: Bool
        let option: AVMediaSelectionOption
    }

    var body: some View {
        VStack(spacing: 0) {
            if let player = player {
                VideoPlayer(player: player)
                    .frame(height: 300)
            }

            VStack(alignment: .leading, spacing: 16) {
                Text("Audio Options")
                    .font(.headline)

                if !audioTracks.isEmpty {
                    Button(action: { showTrackPicker.toggle() }) {
                        HStack {
                            VStack(alignment: .leading) {
                                Text(selectedTrack?.displayName ?? "Default")
                                    .font(.body)

                                if selectedTrack?.hasDescriptions == true {
                                    Text("Includes audio descriptions")
                                        .font(.caption)
                                        .foregroundColor(.green)
                                }
                            }

                            Spacer()

                            Image(systemName: "chevron.down")
                        }
                        .padding()
                        .background(Color.gray.opacity(0.1))
                        .cornerRadius(8)
                    }
                    .sheet(isPresented: $showTrackPicker) {
                        AudioTrackPicker(
                            tracks: audioTracks,
                            selectedTrack: $selectedTrack,
                            onSelect: { track in
                                selectAudioTrack(track)
                                showTrackPicker = false
                            }
                        )
                    }
                }
            }
            .padding()
        }
        .onAppear {
            setupPlayer()
        }
    }

    func setupPlayer() {
        guard let videoURL = Bundle.main.url(
            forResource: "sample",
            withExtension: "mp4"
        ) else { return }

        let asset = AVURLAsset(url: videoURL)
        let playerItem = AVPlayerItem(asset: asset)
        player = AVPlayer(playerItem: playerItem)

        loadAudioTracks(from: asset)

        // Auto-select audio descriptions if available
        if let trackWithDescriptions = audioTracks.first(where: { $0.hasDescriptions }) {
            selectedTrack = trackWithDescriptions
            selectAudioTrack(trackWithDescriptions)
        } else if let firstTrack = audioTracks.first {
            selectedTrack = firstTrack
        }
    }

    func loadAudioTracks(from asset: AVAsset) {
        guard let audibleGroup = asset.mediaSelectionGroup(
            forMediaCharacteristic: .audible
        ) else { return }

        audioTracks = audibleGroup.options.map { option in
            AudioTrackInfo(
                displayName: option.displayName,
                hasDescriptions: option.hasMediaCharacteristic(
                    .describesVideoForAccessibility
                ),
                option: option
            )
        }
    }

    func selectAudioTrack(_ track: AudioTrackInfo) {
        guard let playerItem = player?.currentItem,
              let audibleGroup = playerItem.asset.mediaSelectionGroup(
                forMediaCharacteristic: .audible
              ) else { return }

        playerItem.select(track.option, in: audibleGroup)
        selectedTrack = track
    }
}

struct AudioTrackPicker: View {
    let tracks: [AdvancedAudioDescriptionPlayer.AudioTrackInfo]
    @Binding var selectedTrack: AdvancedAudioDescriptionPlayer.AudioTrackInfo?
    let onSelect: (AdvancedAudioDescriptionPlayer.AudioTrackInfo) -> Void

    var body: some View {
        NavigationView {
            List(tracks) { track in
                Button(action: {
                    onSelect(track)
                }) {
                    HStack {
                        VStack(alignment: .leading) {
                            Text(track.displayName)
                                .font(.body)

                            if track.hasDescriptions {
                                Label("Audio descriptions", 
                                      systemImage: "speaker.wave.3")
                                    .font(.caption)
                                    .foregroundColor(.green)
                            }
                        }

                        Spacer()

                        if selectedTrack?.id == track.id {
                            Image(systemName: "checkmark")
                                .foregroundColor(.blue)
                        }
                    }
                }
                .foregroundColor(.primary)
            }
            .navigationTitle("Audio Track")
            .navigationBarTitleDisplayMode(.inline)
        }
    }
}

Creating Audio Description Tracks

Audio descriptions are typically created as separate audio tracks and mixed with the original audio. The process involves:

Script Writing: Watch the video and write descriptions for visual elements during dialogue pauses
Voice Recording: Record the descriptions in a clear, professional voice
Audio Mixing: Mix the descriptions with the original audio
Track Encoding: Add the descriptive audio as an alternative track in your video file

Adding Audio Description Track to Video

import AVFoundation

func createVideoWithAudioDescriptions(
    videoURL: URL,
    standardAudioURL: URL,
    descriptiveAudioURL: URL,
    outputURL: URL,
    completion: @escaping (Bool) -> Void
) {
    let composition = AVMutableComposition()
    let videoAsset = AVURLAsset(url: videoURL)

    // Add video track
    guard let videoTrack = videoAsset.tracks(withMediaType: .video).first,
          let compositionVideoTrack = composition.addMutableTrack(
            withMediaType: .video,
            preferredTrackID: kCMPersistentTrackID_Invalid
          ) else {
        completion(false)
        return
    }

    do {
        try compositionVideoTrack.insertTimeRange(
            CMTimeRange(start: .zero, duration: videoAsset.duration),
            of: videoTrack,
            at: .zero
        )

        // Add standard audio track
        let standardAudio = AVURLAsset(url: standardAudioURL)
        if let standardTrack = standardAudio.tracks(withMediaType: .audio).first,
           let compositionAudioTrack = composition.addMutableTrack(
            withMediaType: .audio,
            preferredTrackID: kCMPersistentTrackID_Invalid
           ) {
            try compositionAudioTrack.insertTimeRange(
                CMTimeRange(start: .zero, duration: videoAsset.duration),
                of: standardTrack,
                at: .zero
            )
        }

        // Add descriptive audio track
        let descriptiveAudio = AVURLAsset(url: descriptiveAudioURL)
        if let descriptiveTrack = descriptiveAudio.tracks(withMediaType: .audio).first,
           let compositionDescriptiveTrack = composition.addMutableTrack(
            withMediaType: .audio,
            preferredTrackID: kCMPersistentTrackID_Invalid
           ) {
            try compositionDescriptiveTrack.insertTimeRange(
                CMTimeRange(start: .zero, duration: videoAsset.duration),
                of: descriptiveTrack,
                at: .zero
            )
        }

        // Export the composition
        guard let exportSession = AVAssetExportSession(
            asset: composition,
            presetName: AVAssetExportPresetHighestQuality
        ) else {
            completion(false)
            return
        }

        exportSession.outputURL = outputURL
        exportSession.outputFileType = .mp4

        exportSession.exportAsynchronously {
            completion(exportSession.status == .completed)
        }

    } catch {
        print("Error creating video with audio descriptions: \(error)")
        completion(false)
    }
}

Best Practices for Audio Descriptions

Describe What Matters: Focus on visual information that's essential to understanding the content.
Use Natural Pauses: Insert descriptions during natural breaks in dialogue to avoid overlapping with important audio.
Be Objective: Describe what you see, not what you interpret. Say "She frowns" not "She looks angry."
Be Concise: Descriptions should be clear and brief, fitting naturally into available time.
Identify Speakers: When new people appear on screen, describe them so users know who's speaking.
Describe Text: Read important on-screen text like titles, signs, or messages.
Maintain Tone: Match the style and mood of the content in your descriptions.
Provide Context: Describe scene changes and settings so users understand where the action takes place.
Test with Users: Have blind or low vision users review your descriptions for clarity and usefulness.

Automatic Selection of Audio Descriptions

import AVFoundation

extension AVPlayerItem {
    func selectPreferredMediaOptions() {
        // Select audio descriptions if available
        if let audibleGroup = asset.mediaSelectionGroup(
            forMediaCharacteristic: .audible
        ) {
            let preferredOptions = AVMediaSelectionGroup.mediaSelectionOptions(
                from: audibleGroup.options,
                with: Locale.current
            )

            // Prioritize tracks with descriptions
            let trackWithDescriptions = preferredOptions.first { option in
                option.hasMediaCharacteristic(.describesVideoForAccessibility)
            }

            if let descriptiveTrack = trackWithDescriptions {
                select(descriptiveTrack, in: audibleGroup)
            }
        }
    }
}

Wrap up

Audio descriptions are required if your app contains video with meaningful visual content. AVFoundation makes it manageable — include a separate audio track and select it automatically when the user has audio descriptions enabled.

Resources:

Keyboard Navigation

Mon, 30 Mar 2026 16:57:36 +0200

Keyboard navigation enables users to navigate and interact with your app using only a keyboard or assistive input devices. In this post, we'll explore how to implement comprehensive keyboard navigation support in SwiftUI, making your apps accessible to users with motor impairments, power users, and anyone who prefers keyboard-based interaction.

What is Keyboard Navigation?

Keyboard navigation allows users to navigate through an app using keyboard keys (Tab, arrow keys, Enter, etc.) or external assistive devices like switch controls, rather than touch or mouse input. This is essential for:

Users with motor impairments who have difficulty with precise touch or mouse movements
Switch control users who navigate using adaptive switches
Power users who prefer keyboard efficiency
iPad users with external keyboards who want a desktop-like experience
Users with tremors or limited dexterity

Good keyboard navigation means users can access every interactive element, understand where focus is at all times, and complete all tasks without needing touch or mouse input.

Understanding Focus in SwiftUI

Focus determines which element receives keyboard input. SwiftUI provides several tools for managing focus:

@FocusState: Property wrapper to track and control focus state
.focused(_:equals:): Modifier to bind focus to a specific value
.focusable(): Makes non-standard elements focusable
Automatic tab order: SwiftUI automatically creates a logical tab order

Basic Focus Management

import SwiftUI

struct BasicFocusExample: View {
    enum Field: Hashable {
        case username
        case password
        case email
    }

    @FocusState private var focusedField: Field?
    @State private var username = ""
    @State private var password = ""
    @State private var email = ""

    var body: some View {
        Form {
            Section {
                TextField("Username", text: $username)
                    .focused($focusedField, equals: .username)
                    .textContentType(.username)

                SecureField("Password", text: $password)
                    .focused($focusedField, equals: .password)
                    .textContentType(.password)

                TextField("Email", text: $email)
                    .focused($focusedField, equals: .email)
                    .textContentType(.emailAddress)
                    .keyboardType(.emailAddress)
            }

            Section {
                Button("Sign Up") {
                    handleSignUp()
                }
            }
        }
        .onAppear {
            // Set initial focus
            focusedField = .username
        }
    }

    func handleSignUp() {
        // Validate and process
        if username.isEmpty {
            focusedField = .username
        } else if password.isEmpty {
            focusedField = .password
        } else if email.isEmpty {
            focusedField = .email
        }
    }
}

Programmatic Focus Control

struct FocusControlExample: View {
    enum FormField: Hashable {
        case field1, field2, field3
    }

    @FocusState private var focusedField: FormField?
    @State private var field1Text = ""
    @State private var field2Text = ""
    @State private var field3Text = ""

    var body: some View {
        VStack(spacing: 20) {
            TextField("Field 1", text: $field1Text)
                .focused($focusedField, equals: .field1)
                .textFieldStyle(.roundedBorder)
                .onSubmit {
                    focusedField = .field2
                }

            TextField("Field 2", text: $field2Text)
                .focused($focusedField, equals: .field2)
                .textFieldStyle(.roundedBorder)
                .onSubmit {
                    focusedField = .field3
                }

            TextField("Field 3", text: $field3Text)
                .focused($focusedField, equals: .field3)
                .textFieldStyle(.roundedBorder)
                .onSubmit {
                    submitForm()
                }

            HStack(spacing: 16) {
                Button("Previous") {
                    moveFocusToPrevious()
                }
                .keyboardShortcut(.upArrow, modifiers: .command)

                Button("Next") {
                    moveFocusToNext()
                }
                .keyboardShortcut(.downArrow, modifiers: .command)

                Button("Submit") {
                    submitForm()
                }
                .keyboardShortcut(.return, modifiers: .command)
            }
        }
        .padding()
    }

    func moveFocusToPrevious() {
        switch focusedField {
        case .field2:
            focusedField = .field1
        case .field3:
            focusedField = .field2
        default:
            break
        }
    }

    func moveFocusToNext() {
        switch focusedField {
        case .field1:
            focusedField = .field2
        case .field2:
            focusedField = .field3
        default:
            break
        }
    }

    func submitForm() {
        print("Form submitted")
    }
}

Making Custom Views Focusable

Not all views are focusable by default. Use .focusable() to make custom views keyboard-navigable:

struct CustomButton: View {
    let title: String
    let action: () -> Void
    @FocusState private var isFocused: Bool

    var body: some View {
        Text(title)
            .padding()
            .background(isFocused ? Color.blue : Color.gray)
            .foregroundColor(.white)
            .cornerRadius(8)
            .focusable()
            .focused($isFocused)
            .onTapGesture {
                action()
            }
            .onKeyPress(.space) {
                action()
                return .handled
            }
            .onKeyPress(.return) {
                action()
                return .handled
            }
    }
}

struct CustomFocusableView: View {
    var body: some View {
        VStack(spacing: 20) {
            CustomButton(title: "First Button") {
                print("First tapped")
            }

            CustomButton(title: "Second Button") {
                print("Second tapped")
            }

            CustomButton(title: "Third Button") {
                print("Third tapped")
            }
        }
        .padding()
    }
}

Keyboard Shortcuts

Enhance keyboard navigation with shortcuts for common actions:

struct KeyboardShortcutsExample: View {
    @State private var items: [String] = ["Item 1", "Item 2", "Item 3"]
    @State private var selectedItem: String?
    @State private var showingAddSheet = false

    var body: some View {
        NavigationView {
            List(items, id: \.self, selection: $selectedItem) { item in
                Text(item)
            }
            .navigationTitle("Items")
            .toolbar {
                ToolbarItemGroup {
                    Button(action: addItem) {
                        Label("Add", systemImage: "plus")
                    }
                    .keyboardShortcut("n", modifiers: .command)

                    Button(action: deleteSelectedItem) {
                        Label("Delete", systemImage: "trash")
                    }
                    .keyboardShortcut(.delete, modifiers: .command)
                    .disabled(selectedItem == nil)

                    Button(action: refreshItems) {
                        Label("Refresh", systemImage: "arrow.clockwise")
                    }
                    .keyboardShortcut("r", modifiers: .command)
                }
            }
        }
    }

    func addItem() {
        items.append("New Item \(items.count + 1)")
    }

    func deleteSelectedItem() {
        if let selected = selectedItem {
            items.removeAll { $0 == selected }
            selectedItem = nil
        }
    }

    func refreshItems() {
        print("Refreshing items...")
    }
}

Arrow Key Navigation in Custom Views

For custom collections or grids, implement arrow key navigation:

struct GridKeyboardNavigation: View {
    @State private var selectedIndex: Int = 0
    let items = Array(0..<20)
    let columns = 4

    var body: some View {
        VStack {
            Text("Use arrow keys to navigate")
                .font(.headline)
                .padding()

            LazyVGrid(
                columns: Array(repeating: GridItem(.flexible()), count: columns),
                spacing: 16
            ) {
                ForEach(items, id: \.self) { index in
                    GridCell(
                        index: index,
                        isSelected: selectedIndex == index
                    )
                    .onTapGesture {
                        selectedIndex = index
                    }
                }
            }
            .padding()
            .focusable()
            .onKeyPress(.upArrow) {
                moveSelection(by: -columns)
                return .handled
            }
            .onKeyPress(.downArrow) {
                moveSelection(by: columns)
                return .handled
            }
            .onKeyPress(.leftArrow) {
                moveSelection(by: -1)
                return .handled
            }
            .onKeyPress(.rightArrow) {
                moveSelection(by: 1)
                return .handled
            }
        }
    }

    func moveSelection(by offset: Int) {
        let newIndex = selectedIndex + offset
        if newIndex >= 0 && newIndex < items.count {
            selectedIndex = newIndex
        }
    }
}

struct GridCell: View {
    let index: Int
    let isSelected: Bool

    var body: some View {
        ZStack {
            RoundedRectangle(cornerRadius: 8)
                .fill(isSelected ? Color.blue : Color.gray.opacity(0.3))

            Text("\(index)")
                .foregroundColor(isSelected ? .white : .primary)
        }
        .frame(height: 80)
        .overlay(
            RoundedRectangle(cornerRadius: 8)
                .stroke(isSelected ? Color.blue : Color.clear, lineWidth: 3)
        )
    }
}

Focus Sections and Groups

Group related content to improve keyboard navigation flow:

struct FocusedSectionsExample: View {
    enum FocusedSection: Hashable {
        case sidebar
        case content
        case details
    }

    @FocusState private var focusedSection: FocusedSection?
    @State private var selectedItem: String?

    var body: some View {
        HStack(spacing: 0) {
            // Sidebar
            VStack(alignment: .leading) {
                Text("Sidebar")
                    .font(.headline)
                    .padding()

                List {
                    ForEach(["Item 1", "Item 2", "Item 3"], id: \.self) { item in
                        Button(item) {
                            selectedItem = item
                        }
                    }
                }
            }
            .frame(width: 200)
            .background(Color.gray.opacity(0.1))
            .focusable()
            .focused($focusedSection, equals: .sidebar)

            Divider()

            // Main content
            VStack {
                Text("Main Content")
                    .font(.headline)
                    .padding()

                if let item = selectedItem {
                    Text("Selected: \(item)")
                        .padding()
                } else {
                    Text("No selection")
                        .foregroundColor(.secondary)
                        .padding()
                }
            }
            .frame(maxWidth: .infinity, maxHeight: .infinity)
            .background(Color.white)
            .focusable()
            .focused($focusedSection, equals: .content)

            Divider()

            // Details panel
            VStack(alignment: .leading) {
                Text("Details")
                    .font(.headline)
                    .padding()

                Spacer()
            }
            .frame(width: 200)
            .background(Color.gray.opacity(0.05))
            .focusable()
            .focused($focusedSection, equals: .details)
        }
        .onKeyPress(.tab, modifiers: .command) {
            cycleFocusedSection()
            return .handled
        }
    }

    func cycleFocusedSection() {
        switch focusedSection {
        case .sidebar:
            focusedSection = .content
        case .content:
            focusedSection = .details
        case .details:
            focusedSection = .sidebar
        default:
            focusedSection = .sidebar
        }
    }
}

Accessible Menus and Dropdowns

struct KeyboardAccessibleMenu: View {
    @State private var isMenuOpen = false
    @FocusState private var menuFocused: Bool

    var body: some View {
        VStack {
            Menu {
                Button(action: newDocument) {
                    Label("New", systemImage: "doc")
                }
                .keyboardShortcut("n", modifiers: .command)

                Button(action: openDocument) {
                    Label("Open", systemImage: "folder")
                }
                .keyboardShortcut("o", modifiers: .command)

                Divider()

                Button(action: saveDocument) {
                    Label("Save", systemImage: "square.and.arrow.down")
                }
                .keyboardShortcut("s", modifiers: .command)
            } label: {
                Label("File", systemImage: "doc.text")
            }
            .focused($menuFocused)
        }
        .padding()
    }

    func newDocument() { print("New") }
    func openDocument() { print("Open") }
    func saveDocument() { print("Save") }
}

Best Practices for Keyboard Navigation

Logical Tab Order: Ensure focus moves in a logical, predictable order (usually left-to-right, top-to-bottom).
Visible Focus Indicators: Make it obvious which element has focus with clear visual styling.
Skip Links: In complex layouts, provide shortcuts to jump to main content sections.
Keyboard Shortcuts: Use standard keyboard shortcuts (⌘N for new, ⌘S for save, etc.) when applicable.
Support All Interactions: Everything possible with touch/mouse should be possible with keyboard.
Test Thoroughly: Navigate your entire app using only the keyboard to find issues.
Preserve Context: When opening/closing views, return focus to a logical location.
Handle Edge Cases: Define behavior when reaching the first or last focusable element.
Document Shortcuts: Provide a help screen or menu showing available keyboard shortcuts.

Testing Keyboard Navigation

To test keyboard navigation:

Connect an external keyboard to your iOS device or use the simulator
Use the Tab key to move between focusable elements
Use arrow keys for directional navigation
Press Enter or Space to activate buttons
Test all keyboard shortcuts
Verify focus indicators are visible
Ensure all functionality is accessible

Common keys for navigation:

Tab / Shift+Tab: Move forward/backward through focusable elements
Arrow keys: Navigate within a group or list
Enter / Space: Activate focused button or control
Escape: Close dialogs or cancel actions
Command+key: Execute shortcuts

Wrap up

Keyboard navigation matters most for users with external keyboards and assistive input devices. SwiftUI's @FocusState gives you the control to set logical tab order and handle keyboard shortcuts — test by unplugging your trackpad and navigating with Tab alone.

Resources:

withAnimation

Mon, 30 Mar 2026 16:57:36 +0200

withAnimation wraps state changes to produce smooth transitions. It's one of the most common ways to add animation to a SwiftUI view.

Use Case

A common use case for withAnimation is when you want to animate the appearance or disappearance of a view based on a state change. For example, you might want to animate a button that toggles the visibility of a text label.

import SwiftUI  
struct ContentView: View {
    @State private var isVisible = false

    var body: some View {
        VStack {
            Button("Toggle Text") {
                withAnimation {
                    isVisible.toggle()
                }
            }

            if isVisible {
                Text("Hello, SwiftUI!")
                    .transition(.slide)
            }
        }
    }
}

In this example, when the button is pressed, the isVisible state toggles within a withAnimation block, causing the text to slide in and out smoothly.

Caveats

While withAnimation is powerful, there are a few caveats to keep in mind:

Performance: Overusing animations can lead to performance issues, especially on older devices. Use animations judiciously to ensure a smooth user experience.
State Changes: Ensure that the state changes you want to animate are directly related to the views being animated. If the state change does not affect the view hierarchy, the animation may not work as expected.
Animation Types: Not all view changes can be animated. Some properties may not support animation, so be sure to test your animations thoroughly.

Accessibility

When using animations, it's important to consider accessibility. Some users may have motion sensitivity and prefer reduced motion settings. SwiftUI respects the user's system preferences for reduced motion, so animations will be disabled if the user has enabled this setting in their device's accessibility options.

See Respecting Reduced Motion for more information.

Wrap up

withAnimation is the simplest way to add animation to a SwiftUI app. Keep reduced motion in mind — check out the Reduced Motion post for how to handle that properly.

Resources:

withanimation(::)

Focus State in SwiftUI

Mon, 30 Mar 2026 16:57:37 +0200

Managing focus state in SwiftUI is essential for creating accessible and user-friendly forms and interactive interfaces. The @FocusState property wrapper allows you to programmatically control which field has focus, improving keyboard navigation and user experience.

What is `@FocusState`?

@FocusState is a property wrapper introduced in iOS 15 that enables you to track and control which view has keyboard focus. This is particularly useful for forms, text fields, and creating accessible user interfaces where keyboard navigation is important.

Basic Usage for a search view

Here's an example of using @FocusState in a search view:

import SwiftUI

struct SearchView: View {
    @State private var searchText = ""
    @FocusState private var isSearchFieldFocused: Bool

    var body: some View {
        VStack {
            TextField("Search...", text: $searchText)
                .focused($isSearchFieldFocused)
        }
        .padding()
        .task {
            isSearchFieldFocused = true // Automatically focus the search field when the view appears
        }
    }
}

Basic Usage (User Login Form)

Here's a simple example of using @FocusState with a text field:

import SwiftUI

struct LoginView: View {
    @State private var username = ""
    @State private var password = ""
    @FocusState private var focusedField: Field?

    enum Field {
        case username
        case password
    }

    var body: some View {
        Form {
            TextField("Username", text: $username)
                .focused($focusedField, equals: .username)

            SecureField("Password", text: $password)
                .focused($focusedField, equals: .password)

            Button("Login") {
                focusedField = nil // Dismiss keyboard
            }
        }
        .onAppear {
            focusedField = .username
        }
    }
}

Use Case: Form Validation (Sign-Up Form)

You can use @FocusState to automatically move focus to the next field after validation or to highlight invalid fields:

struct SignUpForm: View {
    @State private var email = ""
    @State private var password = ""
    @State private var confirmPassword = ""
    @FocusState private var focusedField: Field?

    enum Field: Hashable {
        case email, password, confirmPassword
    }

    var body: some View {
        Form {
            TextField("Email", text: $email)
                .focused($focusedField, equals: .email)
                .onSubmit {
                    focusedField = .password
                }

            SecureField("Password", text: $password)
                .focused($focusedField, equals: .password)
                .onSubmit {
                    focusedField = .confirmPassword
                }

            SecureField("Confirm Password", text: $confirmPassword)
                .focused($focusedField, equals: .confirmPassword)
                .onSubmit {
                    submitForm()
                }
        }
    }

    func submitForm() {
        guard !email.isEmpty else {
            focusedField = .email
            return
        }
        guard password == confirmPassword else {
            focusedField = .confirmPassword
            return
        }
        focusedField = nil
    }
}

Accessibility Benefits

Using @FocusState improves accessibility by:

Enabling better keyboard navigation
Supporting assistive technologies
Providing clear focus indicators
Allowing programmatic focus control for better UX

Wrap up

@FocusState is a powerful tool for managing keyboard focus in SwiftUI applications. It enhances both the user experience and accessibility of your forms and interactive views by providing fine-grained control over focus management.

Resources:

TextField Styles in SwiftUI

Mon, 30 Mar 2026 16:57:37 +0200

SwiftUI provides various built-in text field styles that allow you to customize the appearance of text input fields. Understanding these styles helps you create consistent and polished user interfaces that match your app's design language.

What are TextField Styles?

TextField styles in SwiftUI are modifiers that change the visual appearance of text fields. SwiftUI includes several built-in styles like .automatic, .plain, and .roundedBorder, and you can also create custom styles using the TextFieldStyle protocol.

Built-in TextField Styles

Here are the main built-in text field styles:

import SwiftUI

struct TextFieldStylesView: View {
    @State private var text1 = ""
    @State private var text2 = ""
    @State private var text3 = ""

    var body: some View {
        Form {
            Section("Automatic Style") {
                TextField("Enter text", text: $text1)
                    .textFieldStyle(.automatic)
            }

            Section("Plain Style") {
                TextField("Enter text", text: $text2)
                    .textFieldStyle(.plain)
            }

            Section("Rounded Border Style") {
                TextField("Enter text", text: $text3)
                    .textFieldStyle(.roundedBorder)
            }
        }
    }
}

Creating Custom TextField Styles

You can create your own custom text field styles by conforming to the TextFieldStyle protocol:

struct CustomTextFieldStyle: TextFieldStyle {
    func _body(configuration: TextField<Self._Label>) -> some View {
        configuration
            .padding()
            .background(
                RoundedRectangle(cornerRadius: 10)
                    .fill(Color.blue.opacity(0.1))
            )
            .overlay(
                RoundedRectangle(cornerRadius: 10)
                    .stroke(Color.blue, lineWidth: 2)
            )
    }
}

struct ContentView: View {
    @State private var text = ""

    var body: some View {
        TextField("Custom styled field", text: $text)
            .textFieldStyle(CustomTextFieldStyle())
            .padding()
    }
}

Platform-Specific Considerations

Different platforms handle text field styles differently:

On iOS, .automatic typically provides an underlined style in forms
On macOS, the default style is plain with a focus ring
The .roundedBorder style provides the familiar rounded rectangle border

Accessibility

When customizing text field styles, ensure that:

Focus indicators remain visible for keyboard navigation
Color contrast meets accessibility guidelines
Touch targets are appropriately sized (at least 44x44 points)

Wrap up

TextField styles in SwiftUI cover most needs out of the box. If you need something more custom, TextFieldStyle is straightforward to implement.

Resources:

AsyncImage in SwiftUI

Sun, 05 Apr 2026 20:18:13 +0200

AsyncImage is a SwiftUI view that simplifies loading and displaying images from remote URLs. It handles the asynchronous nature of network requests, provides loading states, and manages caching automatically.

What is `AsyncImage`?

AsyncImage is a SwiftUI view introduced in iOS 15 that loads and displays images from a URL asynchronously. It eliminates the need for manual URLSession code and state management when displaying remote images.

Basic Usage

Here's a simple example of using AsyncImage:

import SwiftUI

struct ImageView: View {
    var body: some View {
        AsyncImage(url: URL(string: "https://wesleydegroot.nl/assets/avatar/avatar.png"))
            .frame(width: 200, height: 200)
    }
}

Handling Different States

You can customize the appearance during different loading phases:

struct EnhancedImageView: View {
    let imageURL = URL(string: "https://wesleydegroot.nl/assets/avatar/avatar.png")

    var body: some View {
        AsyncImage(url: imageURL) { phase in
            switch phase {
            case .empty:
                ProgressView()
            case .success(let image):
                image
                    .resizable()
                    .aspectRatio(contentMode: .fit)
            case .failure:
                Image(systemName: "photo")
                    .foregroundColor(.gray)
            @unknown default:
                EmptyView()
            }
        }
        .frame(width: 200, height: 200)
    }
}

Use Case: Image Gallery

Here's an example of using AsyncImage in a grid layout:

struct ImageGalleryView: View {
    let imageUrls = [
        "https://wesleydegroot.nl/assets/avatar/avatar_401.png",
        "https://wesleydegroot.nl/assets/avatar/avatar_402.png",
        "https://wesleydegroot.nl/assets/avatar/avatar_403.png",
        "https://wesleydegroot.nl/assets/avatar/avatar_404.png"
    ]

    var body: some View {
        LazyVGrid(columns: [GridItem(.adaptive(minimum: 100))]) {
            ForEach(imageUrls, id: \.self) { urlString in
                AsyncImage(url: URL(string: urlString)) { image in
                    image
                        .resizable()
                        .aspectRatio(contentMode: .fill)
                } placeholder: {
                    Color.gray.opacity(0.3)
                }
                .frame(width: 100, height: 100)
                .clipped()
                .cornerRadius(8)
            }
        }
        .padding()
    }
}

Caveats

AsyncImage does not provide advanced caching options
For more control, consider using third-party libraries or building a custom solution
Images are cached automatically by URLSession, but cache control is limited
For better performance with many images, consider using CachedAsyncImage or similar libraries

Alternatives

For more advanced image loading features, check out:

CachedAsyncImage - My package for enhanced async image loading with better caching
SDWebImageSwiftUI - Popular third-party library
Kingfisher - Another popular option with extensive features

Wrap up

AsyncImage is a convenient built-in solution for loading remote images in SwiftUI. While it works well for basic use cases, consider alternatives for apps that require advanced caching or loading features.

Resources:

Searchable Modifier in SwiftUI

Mon, 13 Apr 2026 16:31:49 +0200

The searchable modifier in SwiftUI makes it easy to add search functionality to your views. It provides a native search experience with automatic keyboard handling, search suggestions, and integration with the navigation bar.

What is the `searchable` Modifier?

The searchable modifier, introduced in iOS 15, adds a search field to your view. It integrates seamlessly with NavigationStack and List views, providing a familiar search experience that users expect.

Basic Usage

Here's a simple example of adding search to a list:

import SwiftUI

struct SearchableListView: View {
    @State private var searchText = ""
    let items = ["Apple", "Banana", "Cherry", "Date", "Elderberry"]

    var filteredItems: [String] {
        if searchText.isEmpty {
            return items
        }
        return items.filter { $0.localizedCaseInsensitiveContains(searchText) }
    }

    var body: some View {
        NavigationStack {
            List(filteredItems, id: \.self) { item in
                Text(item)
            }
            .navigationTitle("Fruits")
            .searchable(text: $searchText, prompt: "Search fruits")
        }
    }
}

Search Suggestions

You can provide search suggestions that appear as the user types:

struct SearchWithSuggestionsView: View {
    @State private var searchText = ""
    let allItems = ["Swift", "SwiftUI", "UIKit", "Combine", "CoreData"]

    var searchResults: [String] {
        if searchText.isEmpty {
            return allItems
        }
        return allItems.filter { $0.localizedCaseInsensitiveContains(searchText) }
    }

    var body: some View {
        NavigationStack {
            List(searchResults, id: \.self) { item in
                Text(item)
            }
            .navigationTitle("Technologies")
            .searchable(text: $searchText) {
                ForEach(popularSearches, id: \.self) { suggestion in
                    Text(suggestion)
                        .searchCompletion(suggestion)
                }
            }
        }
    }

    var popularSearches: [String] {
        ["Swift", "SwiftUI", "Combine"]
    }
}

Search Scopes

You can add search scopes to filter results by category:

struct SearchWithScopesView: View {
    @State private var searchText = ""
    @State private var searchScope: SearchScope = .all

    enum SearchScope: String, CaseIterable {
        case all = "All"
        case recent = "Recent"
        case favorites = "Favorites"
    }

    var body: some View {
        NavigationStack {
            List {
                // Your content here
            }
            .navigationTitle("Search")
            .searchable(text: $searchText)
            .searchScopes($searchScope) {
                ForEach(SearchScope.allCases, id: \.self) { scope in
                    Text(scope.rawValue)
                }
            }
        }
    }
}

Accessibility

The searchable modifier provides good accessibility support out of the box:

VoiceOver announces the search field
Keyboard navigation works automatically
Search is dismissible with the cancel button

Wrap up

The .searchable modifier is the quickest way to add search to a SwiftUI app. Scopes and suggestions are opt-in, so start simple and add them only if your content needs them.

Resources:

ScrollView Performance in SwiftUI

Mon, 30 Mar 2026 16:57:38 +0200

Slow scroll views are one of the most noticeable performance problems in SwiftUI apps. Optimizing them can make a significant difference, especially when dealing with large datasets or complex layouts.

Understanding ScrollView Performance

ScrollView in SwiftUI doesn't have built-in view recycling like UITableView or UICollectionView. This means all views are created upfront, which can lead to performance issues with large datasets. However, LazyVStack and LazyHStack provide lazy loading capabilities.

Use LazyVStack and LazyHStack

For better performance, use lazy stacks instead of regular ones inside ScrollView:

import SwiftUI

struct PerformantScrollView: View {
    let items = Array(1...1000)

    var body: some View {
        ScrollView {
            // Good: LazyVStack creates views on demand
            LazyVStack {
                ForEach(items, id: \.self) { item in
                    ItemRow(number: item)
                }
            }
        }
    }
}

struct ItemRow: View {
    let number: Int

    var body: some View {
        Text("Item \(number)")
            .frame(height: 50)
            .frame(maxWidth: .infinity)
            .background(Color.blue.opacity(0.1))
            .cornerRadius(8)
            .padding(.horizontal)
    }
}

Avoid Heavy Computations in Views

Move expensive operations outside the view body:

struct OptimizedItemView: View {
    let item: Item
    let processedData: String // Computed outside the view

    var body: some View {
        VStack {
            Text(item.title)
            Text(processedData)
        }
    }
}

// Instead of:
// var body: some View {
//     Text(expensiveComputation()) // Called on every render — avoid this
// }

Use LazyVGrid and LazyHGrid for Grids

For grid layouts, use lazy grids:

struct GridView: View {
    let items = Array(1...100)
    let columns = [
        GridItem(.adaptive(minimum: 100))
    ]

    var body: some View {
        ScrollView {
            LazyVGrid(columns: columns) {
                ForEach(items, id: \.self) { item in
                    RoundedRectangle(cornerRadius: 10)
                        .fill(Color.blue)
                        .frame(height: 100)
                        .overlay(Text("\(item)"))
                }
            }
            .padding()
        }
    }
}

Optimize Image Loading

Use AsyncImage or cached image loading for remote images:

struct ImageListView: View {
    let imageUrls: [URL]

    var body: some View {
        ScrollView {
            LazyVStack {
                ForEach(imageUrls, id: \.self) { url in
                    AsyncImage(url: url) { image in
                        image.resizable()
                    } placeholder: {
                        Color.gray
                    }
                    .frame(height: 200)
                }
            }
        }
    }
}

Monitor Performance

Use Instruments to profile your scroll views:

Time Profiler to identify slow code
SwiftUI Profiler to see view updates
Memory profiler to check for leaks

Caveats

LazyVStack/LazyHStack don't support all modifiers the same way as regular stacks
Be careful with onAppear/onDisappear in lazy stacks as they're called when views enter/exit viewport
Complex view hierarchies still impact performance even with lazy loading

Wrap up

Optimizing ScrollView performance in SwiftUI involves using lazy stacks, minimizing expensive computations, and being mindful of view creation. These techniques will help you build smooth, responsive scrolling experiences.

Resources:

Custom Shapes in SwiftUI

Mon, 30 Mar 2026 16:57:38 +0200

Creating custom shapes in SwiftUI allows you to draw unique graphics and build creative user interfaces. By conforming to the Shape protocol, you can create reusable, scalable vector graphics that integrate seamlessly with SwiftUI's rendering system.

What are Custom Shapes?

Custom shapes in SwiftUI are types that conform to the Shape protocol. They define a path that SwiftUI can fill, stroke, or use for clipping. Shapes are resolution-independent and scale beautifully.

Creating a Basic Custom Shape

Here's how to create a simple triangle shape:

import SwiftUI

struct Triangle: Shape {
    func path(in rect: CGRect) -> Path {
        var path = Path()

        path.move(to: CGPoint(x: rect.midX, y: rect.minY))
        path.addLine(to: CGPoint(x: rect.minX, y: rect.maxY))
        path.addLine(to: CGPoint(x: rect.maxX, y: rect.maxY))
        path.closeSubpath()

        return path
    }
}

struct ContentView: View {
    var body: some View {
        Triangle()
            .fill(Color.blue)
            .frame(width: 200, height: 200)
    }
}

Advanced Custom Shape: Star

Here's a more complex example creating a star shape:

struct Star: Shape {
    let points: Int
    let smoothness: Double

    func path(in rect: CGRect) -> Path {
        let center = CGPoint(x: rect.width / 2, y: rect.height / 2)
        let outerRadius = min(rect.width, rect.height) / 2
        let innerRadius = outerRadius * smoothness
        var angle: Double = -.pi / 2
        let angleIncrement = .pi * 2 / Double(points * 2)

        var path = Path()

        for point in 0..<points * 2 {
            let radius = point.isMultiple(of: 2) ? outerRadius : innerRadius
            let x = center.x + CGFloat(cos(angle)) * radius
            let y = center.y + CGFloat(sin(angle)) * radius

            if point == 0 {
                path.move(to: CGPoint(x: x, y: y))
            } else {
                path.addLine(to: CGPoint(x: x, y: y))
            }

            angle += angleIncrement
        }

        path.closeSubpath()
        return path
    }
}

struct StarView: View {
    var body: some View {
        Star(points: 5, smoothness: 0.45)
            .fill(Color.yellow)
            .frame(width: 200, height: 200)
    }
}

Animatable Shapes

You can make shapes animatable by conforming to Animatable:

struct AnimatableStar: Shape {
    var points: Double

    var animatableData: Double {
        get { points }
        set { points = newValue }
    }

    func path(in rect: CGRect) -> Path {
        Star(points: Int(points), smoothness: 0.45).path(in: rect)
    }
}

struct AnimatedStarView: View {
    @State private var points: Double = 5

    var body: some View {
        VStack {
            AnimatableStar(points: points)
                .fill(Color.blue)
                .frame(width: 200, height: 200)
                .animation(.easeInOut, value: points)

            Slider(value: $points, in: 3...10, step: 1)
        }
        .padding()
    }
}

Use Cases

Custom shapes are perfect for:

Creating unique UI elements
Building custom charts and graphs
Designing logos and icons
Creating progress indicators
Building custom buttons and controls

Wrap up

The Shape protocol is straightforward — implement path(in:) and SwiftUI handles the rest. Custom shapes scale infinitely and work with any fill, stroke, or trim modifier.

Resources:

Shape
Path

GeometryReader in SwiftUI

Mon, 30 Mar 2026 16:57:39 +0200

GeometryReader is a SwiftUI view that provides access to the size and position of its parent container. It's essential for creating responsive layouts, custom alignments, and size-dependent views.

What is `GeometryReader`?

GeometryReader is a container view that makes its child view aware of its size and coordinate space. It passes a GeometryProxy to its content closure, which you can use to query dimensional information.

Basic Usage

Here's a simple example of using GeometryReader:

import SwiftUI

struct GeometryExample: View {
    var body: some View {
        GeometryReader { geometry in
            VStack {
                Text("Width: \(geometry.size.width)")
                Text("Height: \(geometry.size.height)")
            }
            .frame(width: geometry.size.width, height: geometry.size.height)
            .background(Color.blue.opacity(0.3))
        }
    }
}

Creating Responsive Layouts

Use GeometryReader to create layouts that adapt to available space:

struct ResponsiveGrid: View {
    var body: some View {
        GeometryReader { geometry in
            let columns = Int(geometry.size.width / 100)
            let spacing: CGFloat = 10
            let itemWidth = (geometry.size.width - (CGFloat(columns + 1) * spacing)) / CGFloat(columns)

            ScrollView {
                LazyVGrid(
                    columns: Array(repeating: GridItem(.fixed(itemWidth), spacing: spacing), count: columns),
                    spacing: spacing
                ) {
                    ForEach(1...50, id: \.self) { item in
                        RoundedRectangle(cornerRadius: 8)
                            .fill(Color.blue)
                            .frame(height: itemWidth)
                            .overlay(Text("\(item)"))
                    }
                }
                .padding(spacing)
            }
        }
    }
}

Coordinate Spaces

GeometryReader can convert coordinates between different coordinate spaces:

struct CoordinateExample: View {
    var body: some View {
        GeometryReader { geometry in
            ScrollView {
                ForEach(0..<20) { index in
                    GeometryReader { itemGeometry in
                        let minY = itemGeometry.frame(in: .global).minY
                        let screenHeight = geometry.size.height
                        let progress = (screenHeight - minY) / screenHeight

                        Text("Item \(index)")
                            .frame(height: 100)
                            .frame(maxWidth: .infinity)
                            .background(
                                Color.blue.opacity(Double(progress))
                            )
                    }
                    .frame(height: 100)
                }
            }
        }
    }
}

Creating Circular Progress View

Here's a practical example using GeometryReader:

struct CircularProgressView: View {
    let progress: Double

    var body: some View {
        GeometryReader { geometry in
            ZStack {
                Circle()
                    .stroke(Color.gray.opacity(0.3), lineWidth: 20)

                Circle()
                    .trim(from: 0, to: progress)
                    .stroke(Color.blue, style: StrokeStyle(lineWidth: 20, lineCap: .round))
                    .rotationEffect(.degrees(-90))

                Text("\(Int(progress * 100))%")
                    .font(.system(size: geometry.size.width * 0.3, weight: .bold))
            }
        }
        .aspectRatio(1, contentMode: .fit)
    }
}

Caveats

GeometryReader takes all available space by default
Can cause layout issues if not properly constrained
Overusing GeometryReader can impact performance
Consider using layout protocols (iOS 16+) for some use cases

Wrap up

GeometryReader is a powerful tool for creating responsive and adaptive layouts in SwiftUI. While it should be used judiciously, it's essential for scenarios where you need to know the size and position of views.

Resources:

Wesley de Groot

Safari in SwiftUI

Swipe actions in Swift

Easy Publishers

Published object

(SwiftUI) View

Full code

Observable Geocoder

Usage

New Website

New Website!

New Features

Features

Test

Snippet: @EnvironmentVariable

OTP Code Generation with CryptoKit: A Swift Approach

Introduction

What Is an OTP?

Understanding TOTP (Time-Based OTP)

Generating TOTP with CryptoKit

Conclusion

Implementing Admob in SwiftUI

Which problems did i encounter?

Admob Banner not showing up

What did i try to fix the padding?

The new EU consent policy UMPConsentInformation

Updating the consent status

Ad area unusable if ad is not shown

Reset the consent status

Before the library

With the library

Xcode shortcuts

Mastering Xcode: Boost Your Productivity with Essential Shortcuts

Why Xcode Shortcuts Matter

Navigating the Xcode Landscape

Essential Xcode Shortcuts

Summary / list

SwiftUI property wrappers

Understanding SwiftUI Property Wrappers

Custom Property Wrappers

Example 2: Mimicing @Published

Conclusion

iCloud Drive Tips & Tricks

What Is iCloud Drive?

Must know commandline commands

Debugging & more

Full list of commands

Help

Tips

Conclusion

async/await

What is async/await?

Example 1: Fetching Data

Example 2: Multiple API Calls

Running multiple tasks concurrently

Wait/Sleep in a Task

Cancellation

Difference between Task and Task.detached

Ensure that your code is (not)running on the main thread

Limitations

Conclusion

@dynamicMemberLookup

What is @dynamicMemberLookup?

Use Case: Dynamic Properties

Conclusion

SimpleNetworking

Installation

Async / Await Examples

Closure Examples

Debugging

Wrap up

Aurora Editor

Aurora Editor: A Swift-Powered IDE for Efficient Coding

Introduction

What Is Aurora Editor?

Key Features

Why Aurora Editor?

Meet the Community

Conclusion

Learn More About Aurora Editor

The new EU consent policy `UMPConsentInformation`

What is `async/await`?

Difference between `Task` and `Task.detached`

What is `@dynamicMemberLookup`?

What is `continuation`?

`withCheckedThrowingContinuation` vs `withUnsafeContinuation`

What is `@MainActor`?

Use Case: `@MainActor`

Why Explicitly Use `@MainActor`?

What is `ContentUnavailableView`?

What is `Pull-to-refresh`?