async/await in Swift — Complete Guide for SwiftUI Developers

The Basics

An async function is declared with async and called with await. The compiler tracks where execution can suspend, and the runtime schedules continuations efficiently.

func fetchUser(id: UUID) async throws -> User {
  let (data, _) = try await URLSession.shared.data(from: userURL(id))
  return try JSONDecoder().decode(User.self, from: data)
}

// Caller:
Task {
  do {
    let user = try await fetchUser(id: currentUserID)
    print(user.name)
  } catch {
    print("Failed: \(error)")
  }
}

async/await in SwiftUI Views

The .task modifier is the SwiftUI-native way to run async work when a view appears. It auto-cancels when the view disappears.

struct TaskListView: View {
  @State private var tasks: [Task] = []

  var body: some View {
    List(tasks) { TaskRow(task: $0) }
      .task {
        // Runs when view appears, cancels on disappear
        tasks = (try? await fetchTasks()) ?? []
      }
  }
}

Actors and Data-Race Safety

When multiple tasks access shared mutable state, you risk data races. Actors serialize access so only one task touches the state at a time.

actor UserCache {
  private var cache: [UUID: User] = [:]

  func get(_ id: UUID) -> User? {
    cache[id]
  }

  func set(_ user: User) {
    cache[user.id] = user
  }
}

// Caller — every method is implicitly async
let cache = UserCache()
await cache.set(user)
let cached = await cache.get(id)

Sendable — Compile-Time Concurrency Safety

Sendable is a marker protocol. Types that conform are safe to pass across task boundaries. Swift 6 strict mode warns when you cross a boundary with non-Sendable types.

• All value types (struct, enum) whose members are Sendable → Sendable automatically
• final class with let-only stored properties → can be Sendable
• Reference types with mutable state → need @unchecked Sendable + manual locking, or use an actor
• Closures that capture state → mark with @Sendable to verify

Task Groups for Concurrent Work

TaskGroup lets you run many async operations in parallel and collect results — without writing manual synchronization.

func fetchAll(ids: [UUID]) async throws -> [User] {
  try await withThrowingTaskGroup(of: User.self) { group in
    for id in ids {
      group.addTask { try await fetchUser(id: id) }
    }
    var users: [User] = []
    for try await user in group { users.append(user) }
    return users
  }
}

Swift 6.2 Approachable Concurrency

Swift 6.2 (2026) introduced a less-strict concurrency mode for solo developers. In Xcode 26.3+, this is the default for new projects.

• @MainActor isolation inferred for many UI types (less ceremony)
• Looser Sendable checking for app code (still strict for library / framework code)
• Better error messages for data-race warnings
• Strict mode opt-in for teams + library authors
• The Swift Kit ships with approachable concurrency enabled

Frequently Asked Questions