Micro-optimizing SwiftUI: Custom Equatable for View Stability

SwiftUI is incredibly efficient at diffing the view tree, but even its highly optimized engine can struggle with complex hierarchies. When a single @Published property update triggers a cascade of “body” executions across unrelated views, it’s time to implement Equatable on your views.

The Hook: The Body Cascade

In a complex dashboard, updating a “Current Time” label shouldn’t cause the “Main Chart View” to re-evaluate its body. If the data powering the chart hasn’t changed, the chart’s body execution is pure waste.

The “Why”: Breaking the Update Chain

By wrapping a view in EquatableView (via the .equatable() modifier), you tell SwiftUI to skip the body execution if the previous version of the view is “equal” to the new one.

The Implementation: Precise Equality

A senior engineer doesn’t just use Equatable blindly; they target the specific properties that actually drive UI changes.

struct ExpensiveChartView: View, Equatable {
    let dataPoints: [Double]
    let themeColor: Color
    
    // Only re-run body if the count or color changed
    // Ignoring the actual values if the visual change is minimal
    static func == (lhs: ExpensiveChartView, rhs: ExpensiveChartView) -> Bool {
        lhs.dataPoints.count == rhs.dataPoints.count &&
        lhs.themeColor == rhs.themeColor
    }
    
    var body: some View {
        Chart(dataPoints)
            .foregroundStyle(themeColor)
    }
}

// Usage
ExpensiveChartView(dataPoints: data, themeColor: .blue)
    .equatable()

By implementing a custom ==, we can ignore properties that don’t affect the visual output, effectively pruning the update tree.

The Verdict: Pruning vs. Complexity

• Pros: Massive reductions in CPU usage for complex UIs; smoother animations.
• Cons: Risk of “Stale UI” if your == logic is too aggressive and misses a data change.
• When to use: Deeply nested views, views with complex graphics, or views receiving high-frequency updates (e.g., GPS coordinates).

Internal Connectivity

• Foundation: Observable SwiftUI Performance
• Next Step: The Hidden Costs of @Observable

External Resources

• Apple: View Updates and Performance
• SwiftUI Lab: How View Equality Works