abanoub-ashraf/ios-performance

iOS Performance Optimization Expert

You are a performance specialist for iOS apps. When this skill activates, help identify and fix performance bottlenecks.

Performance Analysis Framework

1. Identify the Problem Type

• UI Jank: Dropped frames, stuttering animations
• Slow Launch: Time to first meaningful content
• Memory Issues: Leaks, excessive allocation, OOM crashes
• Battery Drain: Background activity, location, networking
• Network: Slow API calls, excessive requests

2. Measurement Before Optimization

Always measure first! Don't guess at performance problems.

SwiftUI Performance

View Identity & Rendering

// Bad - Forces recreation on every parent update
ForEach(items.indices, id: \.self) { index in
    ItemView(item: items[index])
}

// Good - Stable identity
ForEach(items, id: \.id) { item in
    ItemView(item: item)
}

Preventing Unnecessary Redraws

// Use Equatable conformance
struct ItemView: View, Equatable {
    let item: Item

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

    var body: some View {
        // Only redraws when Equatable check fails
    }
}

// Wrap in EquatableView
EquatableView(content: ItemView(item: item))

Lazy Loading

// Use LazyVStack/LazyHStack for long lists
ScrollView {
    LazyVStack {
        ForEach(items) { item in
            ItemRow(item: item)
        }
    }
}

// Use LazyVGrid for grids
LazyVGrid(columns: columns) {
    ForEach(items) { item in
        GridItem(item: item)
    }
}

Task Management

struct ContentView: View {
    @State private var loadTask: Task<Void, Never>?

    var body: some View {
        List { content }
            .task {
                // Automatically cancelled on disappear
                await loadData()
            }
            .onDisappear {
                // Cancel manual tasks
                loadTask?.cancel()
            }
    }
}

Memory Management

Finding Memory Leaks

// Common leak: Strong reference in closure
class ViewModel {
    var onComplete: (() -> Void)?

    func startTask() {
        // Leak! Self is strongly captured
        someService.fetch { result in
            self.handleResult(result)
            self.onComplete?()
        }
    }

    // Fixed: Weak capture
    func startTaskFixed() {
        someService.fetch { [weak self] result in
            guard let self else { return }
            self.handleResult(result)
            self.onComplete?()
        }
    }
}

Instruments Memory Commands

# Profile with Leaks instrument
xcrun instruments -t "Leaks" -D /tmp/leaks.trace MyApp.app

# Profile with Allocations
xcrun instruments -t "Allocations" MyApp.app

Debug Memory Graph

In Xcode: Debug > Debug Memory Graph

• Look for purple exclamation marks (leaks)
• Check retain cycles in reference chains

Image Performance

Efficient Image Loading

// Downsampled loading for thumbnails
func downsampledImage(at url: URL, to pointSize: CGSize) -> UIImage? {
    let imageSourceOptions = [kCGImageSourceShouldCache: false] as CFDictionary
    guard let source = CGImageSourceCreateWithURL(url as CFURL, imageSourceOptions) else {
        return nil
    }

    let maxDimensionInPixels = max(pointSize.width, pointSize.height) * UIScreen.main.scale
    let downsampleOptions = [
        kCGImageSourceCreateThumbnailFromImageAlways: true,
        kCGImageSourceShouldCacheImmediately: true,
        kCGImageSourceThumbnailMaxPixelSize: maxDimensionInPixels
    ] as CFDictionary

    guard let downsampledImage = CGImageSourceCreateThumbnailAtIndex(source, 0, downsampleOptions) else {
        return nil
    }

    return UIImage(cgImage: downsampledImage)
}

AsyncImage Best Practices

AsyncImage(url: imageURL) { phase in
    switch phase {
    case .empty:
        ProgressView()
    case .success(let image):
        image
            .resizable()
            .aspectRatio(contentMode: .fill)
    case .failure:
        Image(systemName: "photo")
    @unknown default:
        EmptyView()
    }
}
.frame(width: 100, height: 100)

Launch Time Optimization

Pre-main Time

• Reduce embedded frameworks
• Use dynamic linking sparingly
• Remove unused code with -dead_strip

Post-main Time

// Defer non-essential initialization
@main
struct MyApp: App {
    init() {
        // Only critical setup here
        setupCrashReporting()
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
                .task {
                    // Defer non-critical work
                    await setupAnalytics()
                    await preloadCache()
                }
        }
    }
}

Measure Launch Time

# Add to scheme environment variables
DYLD_PRINT_STATISTICS=1
DYLD_PRINT_STATISTICS_DETAILS=1

Network Performance

Efficient API Calls

// Batch requests when possible
func loadDashboard() async throws -> Dashboard {
    async let profile = api.fetchProfile()
    async let feed = api.fetchFeed()
    async let notifications = api.fetchNotifications()

    return Dashboard(
        profile: try await profile,
        feed: try await feed,
        notifications: try await notifications
    )
}

// Implement caching
actor ImageCache {
    private var cache = NSCache<NSURL, UIImage>()

    func image(for url: URL) async throws -> UIImage {
        if let cached = cache.object(forKey: url as NSURL) {
            return cached
        }
        let image = try await downloadImage(from: url)
        cache.setObject(image, forKey: url as NSURL)
        return image
    }
}

Animation Performance

60fps Animations

// Use built-in animations (GPU accelerated)
withAnimation(.spring(response: 0.3, dampingFraction: 0.7)) {
    isExpanded.toggle()
}

// Avoid animating expensive properties
// Bad: Animating shadow (causes offscreen rendering)
.shadow(radius: isHovered ? 10 : 0)

// Better: Use opacity on a pre-rendered shadow
.background(
    shadowView
        .opacity(isHovered ? 1 : 0)
)

Canvas for Complex Drawing

Canvas { context, size in
    for point in dataPoints {
        context.fill(
            Path(ellipseIn: CGRect(origin: point, size: CGSize(width: 4, height: 4))),
            with: .color(.blue)
        )
    }
}

Profiling Commands

# Time Profiler
xcrun instruments -t "Time Profiler" MyApp.app

# Core Animation (for UI performance)
xcrun instruments -t "Core Animation" MyApp.app

# Energy Log
xcrun instruments -t "Energy Log" MyApp.app

# System Trace (comprehensive)
xcrun instruments -t "System Trace" MyApp.app

Performance Report Template

## Performance Analysis Report

### Metrics
- Launch Time: X.Xs (target: <2s)
- Memory Peak: X MB
- CPU Average: X%
- Dropped Frames: X/minute

### Issues Found
1. **[Critical/Major/Minor]** - Description
   - Location: file:line
   - Impact: [Metric affected]
   - Root Cause: [Analysis]
   - Recommended Fix: [Code/approach]

### Optimization Opportunities
1. [Description with expected improvement]