Write Safer Async Swift. Understand What Your Code Is Actually Doing.
Move beyond memorising async and await.
Learn how tasks, actors, isolation, cancellation, Sendable,
MainActor and structured concurrency fit together in real iOS apps.
Concurrency Is About More Than Making Code Asynchronous
The hard part is understanding execution, isolation, ownership and cancellation.
A piece of code can compile and still be difficult to reason about. Strong concurrency code makes it clear what can run at the same time, which state is protected, where UI work belongs and what should happen when work is cancelled.
This hub focuses on those decisions — not just syntax.
Understand the Model Behind Modern Async Swift
Learn the concepts that make concurrent code easier to reason about, test and explain.
Structure Tasks Clearly
Understand async functions, child tasks, task groups and how structured concurrency keeps lifetimes easier to reason about.
Protect Shared State
Learn what actor isolation means, why data races happen and how actors change the way shared mutable state is designed.
Reason About Sendable
Understand why values cross concurrency boundaries, what Sendable communicates and where compiler warnings are pointing to real design problems.
Handle Cancellation & UI Work
Make cancellation intentional, avoid unnecessary work and understand when MainActor isolation belongs in your application.
Ask Better Questions Than “Which Thread Is This On?”
Modern Swift concurrency is easier to understand when you reason about tasks, isolation and suspension points instead of trying to map every line directly to a thread.
That shift makes code reviews, debugging and interview explanations much stronger.
Swift Concurrency Articles
Practical explanations for writing asynchronous Swift that is easier to reason about and maintain.
Build the Concurrency Mental Model First
Use the learning path above to understand tasks, isolation, Sendable and cancellation, then apply those ideas in a complete SwiftUI application.
Swift Concurrency From Fundamentals to Production Code
Use these topics as a map of the ideas worth understanding, not just APIs worth memorising.
Code That Compiles Can Still Be Hard to Reason About
These are the habits that often make async Swift more confusing, fragile or difficult to explain.
Wrapping Everything in Task
Creating unstructured work by default can hide lifetimes and make cancellation harder to follow.
Putting Too Much on @MainActor
MainActor is for isolation, not a blanket fix for every concurrency warning or state-management problem.
Assuming await Means “Background Thread”
Suspension and thread choice are not the same thing. That mental model quickly creates incorrect assumptions.
Ignoring Cancellation
Async work that outlives the screen or user intent can waste resources and update stale state.
Using Detached Tasks Without a Clear Reason
Detached work drops useful structure and inherited context, so it should be an intentional choice.
Silencing Sendable Warnings
Compiler warnings often expose real ownership or isolation problems. Treat them as design feedback.
Learn Concurrency in the Order You’ll Actually Use It
Start with readable asynchronous code, then build toward isolation, cancellation and production-level design.
Learn what suspension means and how async call chains fit together.
02 Structure tasksUse child tasks and task groups without losing control of lifetimes.
03 Protect shared stateIntroduce actors when multiple tasks need safe access to mutable state.
04 Reason about isolationUnderstand MainActor, actor boundaries and Sendable requirements.
05 Handle cancellationMake work stoppable and avoid keeping obsolete tasks alive.
06 Apply it in SwiftUIConnect asynchronous state to a real interface without hiding the lifecycle.
Questions You Should Be Able to Explain
What actually happens when an async function reaches an await?
What is the difference between creating a Task and using a TaskGroup?
What problem does actor isolation solve?
When should code be isolated to MainActor?
Why does Sendable matter when values cross concurrency boundaries?
How should cancellation propagate through asynchronous work?
How would you test concurrent code without relying on arbitrary delays?
Learn Concurrency as an Engineering Skill
I'm Kevin Reid, an iOS developer with more than seven years of professional experience, including work at Apple, J.P. Morgan and LexisNexis.
iOS Insights focuses on helping you understand why the code works, where the risks are and how to explain the decisions behind the implementation.
Use Concurrency Inside a Complete iOS App
Move from isolated async examples to applications where networking, state, cancellation and UI updates all have to work together.