Approachable Concurrency Quick Reference

Use this reference when the project has opted into the Swift 6.2 approachable concurrency settings and, when appropriate, default MainActor isolation.

Detecting the Mode

Xcode 26: Check build settings under Swift Compiler > Concurrency:

• Swift language version: 6.2+
• Approachable Concurrency: enabled when using the bundled upcoming-feature flags (NonisolatedNonsendingByDefault, isolated-conformance inference, inferred Sendable captures, and related usability flags).
• Default Actor Isolation: MainActor when unannotated code should infer @MainActor isolation.
• Strict Concurrency Checking: Swift 6 language mode is complete and emits errors; Complete / Targeted / Minimal are migration settings for earlier language modes.

SwiftPM: Inspect Package.swift swiftSettings for the corresponding flags.

Behavior Changes

Async functions stay on the caller's actor

In Swift 6.2, nonisolated async functions no longer hop to the global concurrent executor. They stay on whichever actor called them. This eliminates many "sending X risks causing data races" errors.

Default MainActor isolation

With Default Actor Isolation set to MainActor, unannotated declarations in the module are inferred as @MainActor. This means:

• Global and static variables are protected by default.
• Protocol conformances are implicitly isolated.
• Mutable state is safe without explicit annotation.

Isolated conformances

Protocol conformances can be explicitly isolated: extension Foo: @MainActor SomeProtocol. The compiler prevents using the conformance outside the matching isolation context.

Applying Fixes in This Mode

• Prefer minimal annotations. Let default MainActor isolation do the work for UI-bound code.
• Use isolated conformances instead of nonisolated workarounds for protocol conformances.
• Keep global/shared mutable state on MainActor unless there is a clear performance need to offload.
• Remove redundant @MainActor annotations that are now implied by the default isolation mode.

Offloading Work

• Use @concurrent on async functions that must run on the concurrent pool.
• Do not present nonisolated alone as a CPU-offloading mechanism; it opts out of actor isolation, while @concurrent requests the concurrent pool.
• Make types or members nonisolated only when they are truly thread-safe and used off the main actor.
• Continue to respect Sendable boundaries when values cross actors or tasks.

Common Pitfalls

Concurrency Keywords