Swift Concurrency Blog

Draw your iOS app architecture with CFA. Explain AppModel, feature ownership, task lifetime and shared state in a practical whiteboard challenge.

Understand concurrency in Swift: how tasks make progress, how the runtime schedules work, and why suspension and cooperation keep iOS apps responsive.

Understand the iOS main thread: how app execution begins, why UI work belongs there, and how blocking it prevents the interface from updating.

Learn how race conditions arise when concurrent operations share mutable state, how they differ from data races, and how serialization prevents lost updates.

Explore how the Swift Concurrency runtime schedules tasks, jobs and executors, manages suspension and resumption, and cooperates with operating-system threads.

Learn why iOS developers need to understand Swift Concurrency now, how it fits with SwiftUI and existing code, and how to plan a safe, gradual migration.

Understand what a Swift Task represents, how it executes in periods, suspends at await, inherits context, and differs fundamentally from a thread.

Learn exactly what async means in Swift, how it changes a function's contract, when suspension can occur, and why async does not create a task or thread.

Understand what await means in Swift, how a task may suspend without blocking its thread, and why await is neither a pause nor a background-thread command.

Compare blocking and suspension in Swift, see how each affects threads and interface responsiveness, and learn why async code can still block an application.

Learn how Swift's cooperative scheduler runs eligible jobs, why suspension creates scheduling opportunities, and how long synchronous work delays other tasks.

Learn how MainActor protects main-facing state, how isolation is inherited and crossed, and when to use type annotations or MainActor.run in Swift.

Learn how Swift actors protect mutable state through isolated access, why external calls require await, and why an actor is neither a task nor a thread.

Understand actor isolation in Swift: who may access protected state, when await marks a boundary crossing, and why isolation is about permission, not threads.

Learn how Sendable identifies values that can safely cross Swift concurrency boundaries, including value types, reference types and compiler enforcement.

Learn how @Sendable marks closures that can safely cross concurrency boundaries, what they may capture, and how compiler checks prevent unsafe transfers.

Understand Swift structured concurrency, task trees, async let, parent-child lifetimes, cancellation, error propagation and bounded concurrent work.

Learn how Swift task groups create a dynamic number of structured child tasks, return results in completion order and handle errors and cancellation.

Understand cooperative task cancellation in Swift, how code observes cancellation, when to check before publishing results and who should own task lifetime.

Learn how unstructured Swift tasks created with Task {} outlive their scope, inherit context and require explicit ownership of results and cancellation.

Understand what Task {} inherits in Swift, including actor isolation, priority and task-local values, and why inherited context does not create a child task.

Learn what Task.detached does in Swift, what context it does not inherit, how cancellation works, and when a detached task is the right tool.

Discover why Task does not automatically run on a background thread, how actor isolation and executors determine execution, and when synchronous work blocks.

Understand Swift task priority as a scheduling hint, how priority is inherited or escalated, and why it cannot guarantee execution order or choose a thread.

Learn how Swift child tasks are created with async let and task groups, remain bounded by their parent scope, and inherit cancellation, priority and context.

Learn how Swift task-local values carry contextual information through async calls and child tasks, support tracing, and restore previous values after a scope.

Understand actor reentrancy in Swift, how state can change across await despite data-race safety, and how to prevent stale assumptions when an actor resumes.

Learn how logical races occur when safe concurrent operations finish out of order, why actors do not prevent them, and how to enforce latest-result policies.

Learn what nonisolated means in Swift, which actor members can opt out of isolation, what state they may access and how it supports synchronous protocols.

Understand Swift global actors, how they isolate declarations across types and files, how to define one and when crossing the boundary requires await.

Learn Swift Concurrency from the ground up by understanding processes, threads, race conditions and the problems the modern concurrency runtime was designed to solve. Build the mental model first, then move into tasks, actors, executors and cooperative code.

Understand what an iOS app process actually is, where the main thread lives, how threads access shared memory, and how your code ultimately reaches the processor. Build the foundation you need before moving into threads, race conditions and Swift Concurrency.

Learn how the operating system switches between threads, what a context switch actually does, and why thread execution can interleave unpredictably. Build the mental model that connects OS scheduling, race conditions and Swift Concurrency’s cooperative approach.

Learn how Swift code becomes machine instructions, how a CPU core executes work from a scheduled thread, and why one line of Swift is not necessarily one indivisible operation. Build the hardware-level mental model that makes race conditions and Swift Concurrency much easier to understand.

GCD global queues can grow to approximately 64 worker threads — but that is not the same as saying an iOS process can contain only 64 threads. Learn what the 64-thread figure actually means, why threads consume resources, how thread explosion happens, and why Swift Tasks provide a better model for large amounts of asynchronous work.

Yes. Every iOS application begins execution with an initial thread — the main thread. Learn where the main thread comes from, how it fits inside your app's process, why UI work is associated with it, what the main run loop does, and how DispatchQueue.main and @MainActor relate to the same underlying execution architecture.

A thread — not an entire process — provides the execution context that the OS schedules onto a CPU core. Learn how processes provide an app's memory environment, how threads execute within that process, what the OS actually schedules, and where GCD queues and Swift Tasks fit above the underlying processor architecture.

Threads belong to individual app processes, but the operating system schedules runnable threads from across the entire system onto available CPU cores. Learn how process ownership, shared memory, system-wide scheduling and Swift Concurrency fit together in one complete execution model.

Swift Concurrency needs a runtime because Tasks are not threads. Learn why the OS thread scheduler alone cannot provide Swift's Task, suspension, executor and actor-isolation model, and see how Swift's cooperative concurrency system fits above threads, the OS scheduler and CPU cores.

Swift Concurrency changes how we think about progress. Learn why finishing one operation as quickly as possible can still produce a slow, jerky app, how suspension lets Tasks remain unfinished without blocking a thread, and why cooperative code is about allowing the whole application to keep making progress together.

An executor is the Swift Concurrency service that executes eligible jobs. Learn how executors connect Tasks to system threads, why actors use serial executors, how MainActor reaches main-thread execution, and why an executor is not simply another thread or dispatch queue.

An actor safely handles multiple Tasks by serialising its actor-isolated jobs so that only one executes at a time. Learn what “serialise” actually means, why an actor is more than a lock around a stored property, and how await allows another Task to get a turn without sacrificing data-race safety.

Yes — MainActor-isolated work executes on the main thread. Learn how an async MainActor Task can execute on the main thread, suspend at await, free the main thread for other work, and later resume its MainActor-isolated continuation on the main thread again.

Swift Concurrency makes asynchronous iOS code safer, more structured and easier to reason about. Explore the benefits of Tasks, suspension, actors, MainActor, Sendable, structured concurrency, cancellation, compiler checking and cooperative execution.

Learn how modern iOS architecture organises product features, observable state, dependencies and asynchronous work to create responsive, maintainable SwiftUI applications.

Want AI to build your iOS app? Give it a blueprint first. Install the free CFA AI Toolkit once, then ask for your app "Using CFA" and get a structured, tested Xcode project.

Why our first 4,000 students will pay $49.99 for the complete Swift Concurrency and AI training programme, and the community we want to build together.

A 15-step iOS upskill plan for 2027: understand threads and memory, build cooperative Swift features, and use AI with a clear architectural model.

Why we built the CFA AI Toolkit for iOS: understand Swift Concurrency, organise visible features and work with AI while staying in control of your app.

Turn a tangled SwiftUI entry point into clear, testable features. A practical CFA walkthrough with SwiftData error handling and a reusable AI refactoring prompt.

A clear mental model for the SwiftUI View–ViewModel boundary: disposable declarative screens, feature-backed ViewModels and CFA’s deliberately small dependency route.

Audit your iOS architecture with 12 warning signs: unowned Tasks, stale results, shared state and legacy GCD assumptions stitched into modern Swift code.

Compare two AI agent skills, The Composable Architecture and SwiftLint. Choose practical help for concurrency, SwiftUI, architecture and code review.

A formal overview of Cooperative Feature Architecture (CFA) and the CFA AI Toolkit for iOS: what it is, the layer path, and where each rule lives.

The CFA folder layout for an Xcode project: View, AppModel, App Resources and Swift Extensions, with ownership-based grouping.

The six CFA layers, from View to External System, what each layer may know, and which direction calls and state travel.

What the CFA AppModel stores, how live() builds the graph, and how launch starts each Feature exactly once.

How a concrete CFA Feature owns domain data, operation state and errors, and why it has no protocol and is never a Manager.

How CFA repositories hide storage behind domain-language protocols, when to use a JSON cache or SwiftData, and how storage failures reach the Feature.

How CFA isolates code in Swift 6: Features and ViewModels marked @MainActor by hand, actors for shared storage, and Sendable values between them.

The eight AI skills and the Xcode Project Dashboard in the CFA AI Toolkit for iOS, and when to use each one.

How to install the CFA AI Toolkit for iOS skills and Xcode templates, confirm the installation, and choose a starting point.

How CFA upgrades an existing iOS app from GCD and callbacks to Swift Concurrency: baseline, whole-app change, behaviour preservation and the change gate.

CFA terms defined in one place, and the specification's list of prohibited patterns that reviews reject or refactor.

A single list of CFA decision rules in the form “when X, do Y”, covering where code goes, ownership, tasks, persistence, errors, tests and upgrades.

How each CFA screen owns a private, dedicated ViewModel, what that ViewModel may hold, and how it depends on narrow Features.

How a CFA app starts shared work at the app delegate, keeps App.body structural, and never lets storage gate the first screen.

How CFA assigns an owner to every Task, shares or queues overlapping Feature calls, and handles cancellation and stale results.

How CFA represents failures honestly: thrown domain errors, retained error state in Features, recoverable storage requests and never-lost edits.

How CFA tests the boundaries it advertises: one suite per ViewModel, named Feature tests, isolated AppModel graphs and deterministic doubles.

Six common Swift 6 concurrency compiler errors, the exact message, why it happens, and the CFA fix for each.

The CFA change gate: the route and ownership statement before implementation, the 23 invariants, the delivery checks and the completion record.

The 20-question CFA review checklist from the specification. Every applicable answer must be yes before a change is accepted.

The three CFA Xcode project templates (CFA App, Habit Tracker and Day Streak), what each creates, and how they are installed and maintained.

The CFA Starter Apps (Habit Tracker, Habit Tracker Pro and Todays Twenty): what each contains, how to open it, and how it relates to the templates.

A step-by-step tutorial: create a new iOS app from the CFA App template, read its structure, add a feature with an AI assistant, and pass the change gate.

A step-by-step tutorial: upgrade a whole iOS app from GCD and callbacks to CFA and Swift Concurrency in one change, from baseline to completion record.

Answers to common questions about CFA and the CFA AI Toolkit for iOS: what it is, what it installs, isolation, persistence, testing and upgrades.

The CFA AI Toolkit for iOS release history from the repository changelog, and the Swift, Xcode and iOS versions its projects use.