TL;DR
This guide breaks down Swift's concurrency features — async/await, Tasks, TaskGroups, and actor-based isolation — aiming to make them easier to understand and use. It covers when code suspends, how to run parallel work, and how Swift enforces safety via actor isolation and compiler checks.
What happened
The source provides a concise, example-driven walkthrough of Swift’s modern concurrency model. It explains async functions and await suspension, shows how async let and TaskGroups enable parallel I/O work, and describes Tasks as controllable units of asynchronous execution that can be created from synchronous contexts or view lifecycle modifiers like .task. The piece then moves to where code runs: distinguishing I/O-bound from CPU-bound work and why the latter should avoid the main thread. It lays out actor-based isolation as the compiler-enforced alternative to manual thread management, detailing the MainActor, user-defined actors, and nonisolated code. Under the hood, Swift Concurrency uses libdispatch for scheduling, while the compiler enforces isolation rules. Finally, it highlights two Xcode build settings — a default MainActor isolation and an approachability flag that keeps nonisolated async functions on the caller’s actor — intended to reduce friction for most apps.
Why it matters
- Makes asynchronous code easier to read and reason about by replacing nested callbacks with sequential-looking code.
- Actor-based isolation and compiler checks reduce the risk of data races that cause crashes or subtle corruption.
- Structured concurrency (Tasks and TaskGroups) provides controlled, cancellable, and composable parallel work.
- New Xcode defaults aim to lower friction for adopting concurrency safely without premature optimization.
Key facts
- Mark functions with async and use await to suspend and resume execution when waiting for work.
- async let launches child tasks immediately so you can start multiple operations in parallel and then await their results.
- A Task is a unit of asynchronous work you can start from synchronous code; it can be awaited or cancelled.
- .task modifier in SwiftUI starts and cancels tasks tied to a view’s lifecycle; .task(id:) restarts when the id changes.
- withThrowingTaskGroup and TaskGroup let you add child tasks that run concurrently; cancellation of the parent propagates to children.
- Errors thrown in a TaskGroup can cancel sibling tasks and will rethrow when results are consumed (e.g., next() or waitForAll()).
- Swift Concurrency uses actor-based isolation (MainActor, actors, nonisolated) to declare who may access protected state, with the compiler enforcing boundaries.
- Under the hood the runtime schedules work on a cooperative thread pool built on libdispatch; the compiler is responsible for isolation safety.
- New Xcode 26 projects enable SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor and SWIFT_APPROACHABLE_CONCURRENCY = YES by default.
What to watch next
- How teams adopt the Xcode defaults (MainActor isolation and approachable concurrency) across larger codebases and whether they need opt-outs.
- Performance implications when moving CPU-bound work off MainActor and how frequently projects require explicit @concurrent or other exports.
- not confirmed in the source
Quick glossary
- async/await: Language-level primitives that let functions suspend (await) while waiting for long-running work and resume later, making asynchronous code appear sequential.
- Task: A controllable unit of asynchronous work that can be started from synchronous code, awaited for a result, or cancelled.
- Actor: An isolation boundary that protects mutable state by ensuring only one logical piece of code accesses that state at a time.
- MainActor: A global actor representing the main-thread isolation domain typically used for UI-related state that requires single-threaded access.
- TaskGroup: A construct for creating and managing multiple child tasks that run concurrently and whose lifetimes are tied to a parent scope.
Reader FAQ
Can you use await anywhere in code?
Await may only be used inside an async function or context; you cannot call await from purely synchronous code without creating a Task.
Does marking something @MainActor force it to run on the main thread?
The source explains @MainActor defines a main-thread isolation domain enforced by the compiler rather than directly specifying thread dispatch semantics.
Are actors the same as threads?
No. Actors are isolation boundaries; the runtime chooses which thread executes actor code. Actors guarantee exclusive access to their state, but they are not threads.
Is SWIFT_DEFAULT_ACTOR_ISOLATION enabled by default?
According to the source, new Xcode 26 projects have SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor and SWIFT_APPROACHABLE_CONCURRENCY = YES enabled by default.
When should I move work off the main actor for performance?
The source recommends using MainActor by default and optimizing only when you measure actual performance problems.
Fucking Approachable Swift Concurrency Finally understand async/await, Tasks, and why the compiler keeps yelling at you. Huge thanks to Matt Massicotte for making Swift concurrency understandable. Put together by Pedro…
Sources
- Fucking Approachable Swift Concurrency
- Fucking Approachable Swift Concurrency | Lobsters
- Swift 6.2: Approachable Concurrency
- For future reference but maybe not.
Related posts
- curl bans strcpy too, replacing it with a checked memcpy-based curlx_strcopy helper
- State Department Orders Return to Times New Roman, Undoing Calibri Default
- What Is a Preamp, and Do I Really Need One? — A Practical Guide