Swift 6 turned data races from a debugging nightmare into a compiler error, and that changed what it means to write Swift. This intermediate course teaches the modern concurrency model the way you actually meet it: not as a feature list, but as a set of rules the compiler will now enforce on every line you write. You will start with structured concurrency — async/await, Task, async let, task groups, and cancellation that actually propagates — and learn why structure is what makes concurrent code readable instead of a web of callbacks. Then you will get properly comfortable with actors: how isolation protects mutable state, why an actor can be suspended in the middle of a method and what reentrancy means for your invariants, when MainActor is the right answer, and how nonisolated and isolated parameters give you an escape hatch that is still safe. Sendable is where most developers get stuck, so it gets a full track: what makes a type safe to hand across an isolation boundary, why a class is usually not, when @unchecked Sendable is honest and when it is a lie, and how region-based isolation lets the compiler prove more than it used to. The hardest part of Swift 6 is rarely the new code — it is the ten years of completion handlers, DispatchQueue, and Combine already in your project, so an entire track is devoted to migrating incrementally: wrapping callbacks with continuations, replacing queues with actors, bridging publishers to AsyncSequence, and moving module by module instead of flipping a switch and drowning in errors. You will finish in production territory: reading strict-concurrency diagnostics without guessing, dealing with Objective-C and third-party frameworks that predate Sendable, building AsyncStream, testing concurrent code deterministically, and knowing which patterns quietly hurt performance. Assumes you already write Swift comfortably. By the end, the compiler stops being an obstacle and becomes the thing that proves your code is correct.