Swift 6 Migration Guide: Step-by-Step With Example

 

⚡ Prepare your Swift codebase for Swift 6 with this practical guide to concurrency migration. Learn how to safely adopt actors, @MainActor, async/await, and Sendable using a real-world example.

👀 Why You Should Care

Swift 6 brings strict enforcement of concurrency rules to eliminate data races. That means:

• No more unsafe access to shared mutable state
• Only Sendable types can cross concurrency boundaries
• The compiler won’t let your app compile if concurrency is unsafe

The good news? You can start preparing right now — while still using Swift 5 — with complete concurrency checking.

🛠 Step 1: Enable Complete Concurrency Checking

Turn on concurrency warnings in Xcode:

🧭 Build Settings → Swift Compiler → Concurrency Checking
Set to ✅ Complete

You’ll now see compiler warnings for code that would be illegal in Swift 6. Fix these now, and your project will be ready to flip the Swift 6 switch later.

🧹 Step 2: Refactor Shared Mutable State with Actors

Before (unsafe):

var tasks: [Task] = []

func add(_ task: Task) {
    tasks.append(task) // ❌ Not thread-safe
}

After (safe):

actor TaskStore {
    private var tasks: [Task] = []

func add(_ task: Task) {
        tasks.append(task)
    }
    func allTasks() -> [Task] {
        tasks
    }
}

✅ actor isolates mutable state and ensures safe, serialized access.

🧑‍🎨 Step 3: Annotate ViewModel with @MainActor

SwiftUI updates must happen on the main thread. Enforce this:

@MainActor
class TaskViewModel: ObservableObject {
    @Published var taskList: [Task] = []

let store: TaskStore
    init(store: TaskStore) {
        self.store = store
    }
    func loadTasks() async {
        taskList = await store.allTasks()
    }
}

This keeps all your state and bindings UI-safe by default.

🔁 Step 4: Replace GCD with Structured Concurrency

Old:

DispatchQueue.global().async {
    // background task
}

New:

Task.detached {
    await store.add(Task(...))
}

Want to return to the main thread?

Task.detached {
    let tasks = await store.allTasks()

await MainActor.run {
        self.taskList = tasks
    }
}

🔄 Step 5: Modernize Delegate & Completion APIs

Old callback-style code:

func syncData(completion: @escaping (Bool) -> Void)

Convert to async:

func syncData() async -> Bool {
    await withCheckedContinuation { continuation in
        syncData { result in
            continuation.resume(returning: result)
        }
    }
}

Call it cleanly:

let success = await syncData()

🧼 Structured concurrency removes the callback mess.

🔐 Step 6: Mark Types as Sendable

Swift 6 enforces that only Sendable types can cross concurrency domains.

✅ Structs are usually fine:

struct Task: Sendable {
    let id: UUID
    var title: String
}

🛑 Classes require careful handling:

final class TaskService: @unchecked Sendable {
    // You promise this is safe
}

🌐 Step 7: Refactor Global State with Actors

Bad:

var logMessages: [String] = []

func log(_ message: String) {
    logMessages.append(message) // ❌ Unsafe
}

Good:

actor Logger {
    func log(_ message: String) {
        print("[LOG]: \(message)")
    }
}

Even better:

let logger = Logger()

Task {
    await logger.log("App launched")
}

🧩 Step 8: Migrate One Module at a Time

Migrating your entire app can be overwhelming. Use this strategy:

1. Enable concurrency checking in 1 module
2. Refactor shared state → actor
3. Add @MainActor to ViewModels
4. Replace DispatchQueue with Task
5. Convert completion handlers to async
6. Fix Sendable issues
7. Repeat for each module

✅ Swift 6 Concurrency Migration Checklist

• Enabled Complete Concurrency Checking
• All shared state is isolated (via actors)
• UI code uses @MainActor
• Replaced GCD with structured concurrency
• Completion handlers converted to async/await
• No compiler warnings in concurrency mode
• Sendable types validated or wrapped safely

🧠 Final Thoughts

Migrating to Swift 6 concurrency might feel like work, but it’s an investment in:

✅ Safer code
✅ Compiler-enforced correctness
✅ Easier testing and debugging
✅ More expressive async logic

By starting now and applying the tools available in Swift 5.10+, you’ll ensure your code is future-proof, race-condition-free, and fully ready for Swift 6.