Announced at its latest developer conference, WWDC25, Swift Approachable Concurrency is a new feature in Swift 6.2 designed to simplify concurrent programming for the most common use cases in mobile apps.
Enabling approachable concurrency will make the Swift compiler more predictable, reducing the number of errors and warnings it generates, which can be overwhelming and not always related to real issues with the code.
Under the hood, approachable concurrency introduces two new compiler flags: infer isolated conformances and the default enforcement of nonisolated(nonsending).
The first feature introduces the notion of isolated conformance, which restricts conformance to a type to the same isolation domain of the conforming type. For example, say we have MyModelType conforming to Equatable, :
@MainActor
class MyModelType: Equatable {
...
}
MyModelType provides an implementation for all Equatable requirements, which will be bound to MyModelType‘s isolation domain, e.g. @MainActor. However, the conformance declaration does not specify any isolation domain, which means that MyModelType appears to the compiler as Equatable conforming on any isolation domain. So, the compiler will happily compile any call to MyModelType‘s implementations of Equatable requirements but this will generate a runtime error when called from a different actor. Compare this to the following declaration:
@MainActor
class MyModelType: @MainActor Equatable {
...
In this case, the conformance is constrained to the same isolation domain as the class implementing it and the compiler will detect any attempt to call Equatable methods on an instance of MyModelType from a non-main actor.
The new infer isolated conformances feature relieves programmers from having to explicitly restrict conformance to Equatable.
The second feature, enforcing nonisolated(nonsending), will ensure that a nonisolated async function will run on the calling actor’s executor by default instead of running on the global executor. This new behavior unifies that of non-async nonisolated functions.
Approachable concurrency is introduced alongside another important concurrency-related feature: use main actor by default. This enforces the principle that all functions run on the main actor unless explicitly directed otherwise by the programmer.
The new features will be welcome to many Swift developers who found that adopting Swift 6 strict concurrency model opened a pandora box of issues, leading many to wonder whether Swift 6 concurrency has moved too far or too fast in a lengthy but extremely interesting thread on the Swift forums.
While the discussion is deep and full of insight, one way to summarize it is that Swift may have gone too fast in pushing concurrency to developers before the language, ecosystem, and documentation were fully ready. It also went too far for mobile apps, which tend to be simpler than general-purpose concurrent software. In practice, most iOS and iPadOS apps operate primarily on the main thread, with only a handful of tasks offloaded to the background to keep the UI responsive.
As Donny Wals, author of several Swift books, including Practical Swift Concurrenty, noted:
Paired with your code running on the main actor by default for new projects created with Xcode 26, you’ll find that approachable concurrency really does deliver on its promise. It gets rid of certain obscure compiler errors that required weird fixes for non-existent problems.
Approachable Concurrency and default main actor use are just two of several new features aimed at simplifying concurrency programming that will be progressively released in upcoming Xcode 26 betas according to the official vision document by the Swift team.
