Dynamic Island: What It Is, Interacting with Dynamic Island

What Is Dynamic Island?

Dynamic Island is an interactive area based on Apple's software-hardware solution, introduced in September 2022 alongside the iPhone 14 Pro. Physically, it is a pill-shaped cutout surrounded by OLED pixels that dynamically change color and shape. Apple uses a combination of a hardware cutout for the camera and Face ID with software rendering of black areas around it, creating the illusion of a "living" island.

The main goal of Dynamic Island is to bridge the gap between system notifications and active content. Instead of notifications appearing in the center of the screen (as on Android) or as banners from the top (as on older iOS versions), Dynamic Island integrates them directly into the hardware zone. This reduces distraction and creates a sense of unified space.

According to Apple data (iOS 17 Adoption Statistics, 2024), Dynamic Island is available on 38% of active iPhones. Starting with iPhone 15 (2023), all models in the lineup received Dynamic Island, including base models. In iOS 18, Apple expanded the Live Activities API, adding support for countdown timers and sports scores directly on Dynamic Island.

Which Models Support Dynamic Island

Dynamic Island is available on iPhone 14 Pro, iPhone 14 Pro Max, iPhone 15, iPhone 15 Plus, iPhone 15 Pro, iPhone 15 Pro Max, iPhone 16, iPhone 16 Plus, iPhone 16 Pro, iPhone 16 Pro Max. Dynamic Island is not available on iPad. Development for Dynamic Island requires Xcode 14.1+ and iOS 16.1+.

How Dynamic Island Works: Three States

Dynamic Island supports three display states: compact, minimal, and expanded. Transitions between states are animated using UIKit animations and Core Animation. The system itself manages activity priority: if multiple apps try to display content simultaneously, iOS uses a queue based on the start time of the last activity.

Compact state is the standard view of Dynamic Island when one background task is active. It appears as a rounded pill with the app icon on the left and a system icon on the right. By default, all Live Activities start in the compact state.

Minimal state occurs when two or more tasks are active simultaneously. Dynamic Island "splits" into two separate elements on the left and right of the camera. The minimal state allows displaying two independent sources of information, such as time until taxi arrival and the current track.

Expanded state is activated by a long press on Dynamic Island. In this mode, a full widget with customizable content is displayed: titles, descriptions, progress bars, buttons. The expanded state supports scrolling and interactive elements.

ActivityKit and Live Activities: Swift API

ActivityKit is a Swift framework introduced in iOS 16.1 that allows apps to publish Live Activities on Dynamic Island and Lock Screen. ActivityKit uses an architecture based on ActivityView and ActivityAttributes: the former defines the content type, the latter defines mutable data. The framework works in conjunction with WidgetKit, but unlike widgets, Live Activities can update in real-time without opening the app.

import ActivityKit
import SwiftUI

// Define activity attributes
struct DeliveryAttributes: ActivityAttributes {
    public struct ContentState: Codable, Hashable {
        var driverName: String
        var distanceToArrival: Double
        var estimatedMinutes: Int
    }
    var orderNumber: String
}

// Start Live Activity
func startDeliveryActivity() {
    let initialState = DeliveryAttributes.ContentState(
        driverName: "Alex",
        distanceToArrival: 3.5,
        estimatedMinutes: 12
    )
    let attributes = DeliveryAttributes(orderNumber: "ORD-2024-8912")
    let activity = try? Activity.request(
        attributes: attributes,
        contentState: initialState,
        pushType: .token
    )
}

Live Activities update through ActivityView, which renders SwiftUI content for Dynamic Island. The system itself determines which template to use (compact, minimal, or expanded) depending on the size of Dynamic Island and the number of activities. To update content, call activity.update(using: contentState). To end — activity.end(dismissalPolicy: .immediate).

Dynamic Notifications with Push Updates

ActivityKit supports push updates via APNs (Apple Push Notification Service). When starting a Live Activity, you can request a pushToken and send updates from the server without needing to launch the app on the device. Push updates work through activity.pushToken and Activity.pushToStartToken for remote Live Activity start.

// Update Live Activity via Push
func updateActivity(activity: Activity<DeliveryAttributes>) {
    let updatedState = DeliveryAttributes.ContentState(
        driverName: "Alex",
        distanceToArrival: 1.2,
        estimatedMinutes: 4
    )
    let alertConfiguration = AlertConfiguration(
        title: "Courier nearby",
        body: "Alex will arrive in 4 minutes",
        sound: .default
    )
    await activity.update(
        using: updatedState,
        alertConfiguration: alertConfiguration
    )
}

AlertConfiguration is an optional parameter that shows a notification on top of Dynamic Island for important updates (e.g., "Courier has arrived"). Without AlertConfiguration, content updates silently, which is suitable for progress bars and timers.

Dynamic Island vs Notch: Comparison

Notch is the hardware cutout of iPhone X–13 that contains the front camera, Face ID sensor, and speaker. The notch is static: its size and shape do not change, and notifications are displayed below it as standard banners. Dynamic Island, on the other hand, uses pixels around the cutout to display content, making the hardware element part of the interface.

According to Apple Human Interface Guidelines (2025), Dynamic Island should not be used for advertising or permanent display of static content. Live Activities are intended only for background tasks with a clear lifecycle: timers, delivery, sports, music, navigation. Violating these rules leads to app rejection in App Store Review.

Lifecycle and Gestures of Dynamic Island

Dynamic Island has a strict lifecycle: an activity begins with a request through Activity.request(), goes through active/paused/updated states, and ends with a call to activity.end(). The system can force-terminate an activity when memory is low (e.g., when the camera is launched). In this case, the app receives a notification via ActivityActivityState.finished.

Gestures on Dynamic Island are handled by SwiftUI content inside ActivityView. Standard gestures: tap on the compact state opens the app, long press expands the expanded state, swipe down closes the expanded state. Custom gestures are added via SwiftUI modifiers (onTapGesture, onLongPressGesture) inside the activity view.

Handling the finished State

When the system ends a Live Activity (or the user swipes to dismiss it), the app should handle the finished state to free resources. It is recommended to subscribe to Activity.activityStateUpdates and remove local references to the activity after completion.

import ActivityKit

func observeActivityState(activity: Activity<DeliveryAttributes>) {
    Task {
        for await state in activity.activityStateUpdates {
            switch state {
            case .active:
                print("Activity active on Dynamic Island")
            case .dismissed:
                print("Activity dismissed by user")
                await activity.end(dismissalPolicy: .immediate)
            case .finished:
                print("Activity ended by system")
                cleanupResources()
            @unknown default:
                break
            }
        }
    }
}

Apple Recommendation (WWDC 2024, Session 10146): do not use Dynamic Island for displaying statuses that do not require user attention. Each Live Activity should have a clear start and end trigger. For background updates without UI, use Background Tasks instead of Live Activities.