Cal Stephens

@Martma12 @v_pradeilles Helpful improvement but unrelated! The behavior you’re talking about is for Equatable properties on @Observable classes. The blog post discusses stored properties directly on a SwiftUI view itself. No changes there.

@DonnyWals Does this sample code have a retain cycle? Can’t spot one

Tasks in Swift allow you to access self without using self explicitly. You don't need to capture self, it's just there. This means that it's quite easy to create retain cycles without the compiler stopping you... I talk about this and much more in Practical Swift Concurrency. Now available with 30% off, link the replies

@ivanopcode @AetherAurelia @AirbnbEng Here’s an open source implementation that matches the behavior of our Equatable macro: github.com/ordo-one/equat…

@calstephens98 @AetherAurelia @AirbnbEng But anyway, I am fully into making strict rules about views being explicitly equitable (kudos for macro based solution, consider sharing its implementation!) **and** using independent view structs instead of helper funcs. Those are great and must have SwiftUI patterns.

lil RenderMeThis demo Observable gives fine‑grained updates: only the views that depend on a property recompute. ObservedObject is coarse: any change makes all dependent views recompute

@ivanopcode @AetherAurelia @AirbnbEng We agree on this point — decreasing view body evaluations can improve performance. I also agree that many screens are simple enough that view body evaluations aren’t an issue and reducing them aren’t going to move the needle. Different story for really complicated screens though!

@calstephens98 @AetherAurelia @AirbnbEng Obv is you decrease evaluation of body you improve performance but oftentimes there are hidden computations there which are real cause of inefficient rendering. I.e. fighting body recalculations is wrong path imo. (…)

@ivanopcode @AetherAurelia @AirbnbEng Haha, definitely don’t agree 😛 if you’re evaluating the view body of a root view with many descendants, that is definitely not “free”. If every view body in the tree had to be evaluated every time any state changed, then the feature would definitely not perform well.

@calstephens98 @AetherAurelia @AirbnbEng Evaluating view body is close to being free if within evaluation path there is no complexity e.g. sort array passed to ForEach, or access element from collection in vm plus some accidental quadratic there. (…)

@ivanopcode @AetherAurelia @AirbnbEng We found experimentally that reducing redundant view body evaluations improves real world performance for users 🤷🏼‍♂️ evaluating the view body is not free, seems obvious that reducing redundant work should result in some sort of performance improvement…

@AetherAurelia This confuses 99% of SwiftUI devs, including very senior ones. Welcome to the 1% club. Here’s @AirbnbEng’s article on SwiftUI performance, where they fall into the exact same trap: hooking a random color to body recalcs and using it as proof of rerendering. (fyi: @calstephens98)

You're having performance issues with SwiftUI and you're struggling to solve them? 😫 So did Airbnb and they've just published the method that solved them! Let me walk you through it 😌

@DanielLurie Love it, let’s get it done

San Francisco just got a proposal for the tallest tower on the West Coast. And this is not just about one building. This plan would transform a vacant city block into a dynamic mix of housing, office space, retail, and public space by developing the former PG&E and Matson headquarters. This shows what's possible when people believe in our city's future. Let's go, San Francisco.

@rxmustdie A view that is re-evaluated might not be re-rendered, but a view that isn’t re-evaluated at all will _definitely_ not be re-rendered 😀

@rxmustdie We demonstrated with production performance data that reducing redundant view body re-evaluations improves performance for end users. You’re right that a re-evaluation doesn’t necessarily imply that the view will be re-rendered, but the evaluation still has a cost!

Published a new blog post about SwiftUI performance & tools we’re using at Airbnb to improve performance at scale medium.com/airbnb-enginee…

@rxmustdie EquatableView is supposed to guarantee that == will always be called even if the view is POD. I don’t think that matters much because (1) POD views are pretty uncommon (2) a custom Equatable implementation should only be an optimization, not required for functional correctness

@rxmustdie SwiftUI won’t call == by default if the view is POD (plain ol data, so no classes. Strings aren’t POD). In that case it instead performs a more efficient bitwise comparison on the properties. In this example where the view has an Int instead of a String, == is never called

@squeakytoy Thanks! I watched the talk (good stuff in there) and am looking forward to trying out the new instrument.

@calstephens98 When you get a chance to try the new SwiftUI instrument, please let me know if you learn anything interesting! There’s also some interesting stuff we haven’t shared before in this talk: developer.apple.com/videos/play/ww…

@tiborbodecs SwiftFormat has many, many more rules and options than swift-format 😉

🤔 Which option do you think is better and why (comment below):

@g_sabran Impressive!

Xcode 26's new AI assistant is a step forward, but still pretty basic. No agents, just chat. In this post I show a creative workaround to bring state of the art AI to Xcode, though honestly we shouldn't need hacks for decent AI tooling in 2025 🤷‍♂️ @guillaumesabran/whats-finally-shipping-in-swift-assist-and-how-to-bring-it-to-modern-days-ai-with-claude-code-fbe874634c0e" target="_blank" rel="nofollow noopener">medium.com/@guillaumesabr…

@eneko Makes sense that the task is retaining the view, but how is the view retaining the task?

Really wish Xcode displayed escaping closures differently than non-escaping ones. Different Swift syntax would be great, imo, something like {} for non-escaping, and ^{} for escaping. Meanwhile, the following causes a retain cycle (ocf) class myView: UIView { func a () { Task { await b() } } @MainActor func b() async { ... } }

Just published SwiftFormat 0.56.0 — it includes over a dozen new rules and options added by the community! github.com/nicklockwood/S…

@united SFO BKK 👀

It may be April 1, but this isn’t a joke. New routes incoming. Tomorrow. 8 a.m. ET. Drop your guesses below. ⬇