Concurrency Step-by-Step
by Matt Massicotte
The official material describes the model, while this series shows the actual error messages a learner will hit and reasons backwards to the rule. A series that builds small programs incrementally and stops at every isolation, Sendable and actor error the compiler raises to explain the cause. Continues through designing and conforming to protocols, stateful systems, and reading from storage.
More resources on Swift
Swift Evolution Proposals
The searchable archive of every accepted, rejected and in-review language change, each with motivation, detailed design, alternatives considered and its review thread. Reading SE-0296 async/await, SE-0302 Sendable or SE-0306 actors gives rationale no tutorial carries.
Advanced Swift
The only book-length source that explains why Swift's value types, protocol witness tables and copy-on-write behave as they do rather than just how to use them. A deep treatment of the language's semantics: protocol and generic design, value semantics and copy-on-write, the String and collection models, enums, mutability, memory management, error handling and C interoperability. Fifth edition, updated for Swift 5.6.
Eliminate data races using Swift Concurrency (WWDC22)
Still the best conceptual account of why Swift's concurrency rules exist, and the talk Swift Forums participants keep pointing newcomers to. Swift 6 made these checks mandatory but did not change the underlying model, so the material is structurally current even though its closing section discusses Swift 5.7's opt-in strictness levels — which is why it is paired here with the Swift 6 migration guide rather than used alone. Doug Gregor of the Swift team explains the isolation model behind the language: tasks as self-contained sequential units, actors as isolated state, Sendable as the type-level rule for crossing boundaries, the main actor, and high-level atomicity across await points.
Embracing Swift concurrency (WWDC25)
The most current primary-source explanation of how the language expects you to reason about concurrency, including the 'approachable concurrency' direction that reframed advice given in earlier sessions. Apple engineers present the concurrency model as it stands after Swift 6.2: single-threaded code isolated to the main actor by default, when introducing async functions actually helps, actor isolation, Sendable requirements, and how to move work off the main thread.
Migrating to Swift 6
Official swift.org guide to the Swift 6 language mode's compile-time data-race checking. Explains isolation domains, Sendable conformance, the common compiler errors and their causes, incremental per-module adoption, and bridging existing callback and global-state code. Rather than a tutorial that will rot, it is a maintained explanation of the isolation model plus a taxonomy of the errors strict concurrency produces.
The Swift Programming Language
Apple's official language guide and formal reference, covering optionals, closures, structs versus classes, protocols, generics, opaque types, macros and structured concurrency, ending with a complete grammar. Versioned with each release; currently Swift 6.4.