Swiftui Performance Audit

SwiftUI Performance Audit is a community skill for optimizing SwiftUI application performance, covering view identity analysis, body computation profiling, state invalidation tracking, rendering pipeline optimization, and Instruments-based performance measurement.

What Is This?

Overview

SwiftUI Performance Audit provides patterns for identifying and fixing performance bottlenecks in SwiftUI applications. It covers view identity analysis to understand when SwiftUI creates, updates, or destroys views in the hierarchy, body computation profiling that measures how often and how expensively view body properties are evaluated, state invalidation tracking to find unnecessary redraws caused by state changes that do not affect visible output, rendering pipeline optimization with drawingGroup, canvas rendering, and layer caching, and Instruments profiling with SwiftUI template for time profiling view updates and layout passes. The skill enables developers to diagnose and fix rendering performance issues in SwiftUI applications systematically.

Who Should Use This

This skill serves iOS developers troubleshooting janky scrolling or slow transitions in SwiftUI interfaces, teams optimizing complex SwiftUI view hierarchies for smooth 60fps rendering, and engineers profiling SwiftUI applications with Instruments for production performance.

Why Use It?

Problems It Solves

SwiftUI re-evaluates view bodies on every state change which can cause excessive computation for complex hierarchies. List performance degrades with large datasets when cell views are expensive to create. State stored in parent views triggers redraws of child views that do not depend on the changed state. Animation stuttering occurs when layout computation competes with rendering on the main thread.

Core Highlights

Body evaluation counter reveals which views recompute unnecessarily. Equatable conformance prevents redraws when inputs have not changed. Lazy containers defer off-screen view creation for scrolling performance. Canvas rendering bypasses the view hierarchy for drawing-intensive interfaces.

How to Use It?

Basic Usage

import SwiftUI

// Debug body evaluation
struct ProfileCard: View {
    let user: User

    var body: some View {
        let _ = Self._printChanges()

        HStack {
            AsyncImage(
                url: user.avatarURL
            ) { image in
                image.resizable()
                    .frame(
                        width: 48,
                        height: 48)
                    .clipShape(
                        Circle())
            } placeholder: {
                Circle()
                    .fill(.gray
                        .opacity(0.3))
                    .frame(
                        width: 48,
                        height: 48)
            }

            VStack(
                alignment:
                    .leading) {
                Text(user.name)
                    .font(
                        .headline)
                Text(user.email)
                    .font(
                        .caption)
                    .foregroundStyle(
                        .secondary)
            }
        }
    }
}

Real-World Examples

import SwiftUI

// Optimized list with extraction
struct OptimizedList: View {
    @State private var items:
        [Item] = []
    @State private var search
        = ""

    var filtered: [Item] {
        guard !search.isEmpty
            else { return items }
        return items.filter {
            $0.title
                .localizedCaseInsensitive
                Contains(search)
        }
    }

    var body: some View {
        NavigationStack {
            List(filtered) {
                item in
                ItemRow(item: item)
            }
            .searchable(
                text: $search)
        }
    }
}

// Equatable row prevents
// unnecessary redraws
struct ItemRow: View,
    Equatable {
    let item: Item

    static func == (
        lhs: ItemRow,
        rhs: ItemRow
    ) -> Bool {
        lhs.item.id
            == rhs.item.id
        && lhs.item.title
            == rhs.item.title
    }

    var body: some View {
        HStack {
            Text(item.title)
            Spacer()
            Text(item.date,
                style: .date)
                .foregroundStyle(
                    .secondary)
        }
    }
}

Advanced Tips

Use Instruments SwiftUI template to identify which views are being created and updated during interactions. Apply drawingGroup() to complex view compositions to flatten them into a single GPU-rendered layer. Move expensive computed properties into @Observable objects to control when recomputation triggers.

When to Use It?

Use Cases

Audit a list-heavy application that stutters during scrolling to find over-evaluated view bodies. Optimize a dashboard with charts and animations that drops frames during transitions. Profile a navigation-heavy app where push and pop animations are not smooth.

Related Topics

SwiftUI rendering, view identity, Instruments profiling, change detection, and GPU rendering.

Important Notes

Requirements

Xcode with Instruments for SwiftUI profiling. Physical device for accurate performance measurement. iOS 17 or later for _printChanges and Observable support.

Usage Recommendations

Do: use _printChanges() during development to identify unnecessary body evaluations. Extract list rows into separate Equatable views to prevent cell redraws. Profile on physical devices since simulator performance is not representative.

Don't: optimize views without first measuring to confirm an actual performance problem. Use AnyView which defeats SwiftUI identity tracking and prevents diff optimizations. Store frequently changing state in parent views that causes entire subtree invalidation.

Limitations

_printChanges is a debug-only tool not available in release builds. SwiftUI view diffing is opaque making it difficult to predict exactly when redraws occur. Some performance characteristics differ between simulator and device.