dpearson2699/swift-ios-skills / skills/swift-concurrency
swift-concurrency
VerifiedResolve Swift concurrency compiler errors, adopt approachable concurrency (SE-0466), and write data-race-safe async code. Use when fixing Sendable conformance errors, actor isolation warnings, or strict concurrency diagnostics; when adopting default MainActor isolation, @concurrent, nonisolated(nonsending), or Task.immediate; when designing actor-based architectures, structured concurrency with TaskGroup, or background work offloading; or when migrating from @preconcurrency to full Swift 6 strict concurrency.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 19.5 KB |
| evals/evals.json | config | 8.4 KB |
| references/approachable-concurrency.md | markdown | 3.9 KB |
| references/async-algorithms.md | markdown | 2.6 KB |
| references/bridging-interop.md | markdown | 9.1 KB |
| references/concurrency-patterns.md | markdown | 8.5 KB |
| references/diagnostics.md | markdown | 4.2 KB |
| references/swiftui-concurrency.md | markdown | 5.1 KB |
| references/synchronization-primitives.md | markdown | 13.6 KB |
references/swiftui-concurrency.md
View on GitHub# SwiftUI Concurrency Guide
Concurrency patterns and best practices specific to SwiftUI applications.
## Contents
- [MainActor Default in SwiftUI](#mainactor-default-in-swiftui)
- [Where SwiftUI Runs Code Off the Main Thread](#where-swiftui-runs-code-off-the-main-thread)
- [Sendable Closures and Data-Race Safety](#sendable-closures-and-data-race-safety)
- [Structuring Async Work](#structuring-async-work)
- [The .task Modifier](#the-task-modifier)
- [`@Observable View Models`](#observable-view-models)
- [Async Observation with Observations (SE-0475)](#async-observation-with-observations-se-0475)
- [Performance-Driven Concurrency](#performance-driven-concurrency)
- [Common SwiftUI Concurrency Mistakes](#common-swiftui-concurrency-mistakes)
## MainActor Default in SwiftUI
- `View` is `@MainActor` isolated by default; `body` and all members inherit
this isolation.
- Swift 6.2 can infer `@MainActor` for all types in a module via default actor
isolation (SE-0466).
- This default aligns with UIKit/AppKit `@MainActor` APIs and simplifies UI
code.
## Where SwiftUI Runs Code Off the Main Thread
SwiftUI may evaluate some view logic on background threads for performance:
- `Shape` path generation
- `Layout` methods (`sizeThatFits`, `placeSubviews`)
- `visualEffect` closures
- `onGeometryChange` closures
These APIs often require `Sendable` closures to reflect their off-main-thread
runtime semantics.
## Sendable Closures and Data-Race Safety
Accessing `@MainActor` state from a `Sendable` closure is unsafe and flagged by
the compiler.
**Fix:** Capture value copies in the closure capture list.
```swift
// WRONG: Captures @MainActor state directly
.visualEffect { content, proxy in
content.offset(y: self.offset) // Error: @MainActor state in Sendable closure
}
// CORRECT: Capture a copy
let currentOffset = offset
// ... use in closure:
.visualEffect { [currentOffset] content, proxy in
content.offset(y: currentOffset)
}
```
Avoid sending `self` into a `Sendable` closure just to read a single property.
## Structuring Async Work
SwiftUI action callbacks are synchronous so UI updates (like loading states) can
be immediate.
```swift
struct ContentView: View {
@State private var isLoading = false
@State private var result: String?
var body: some View {
Button("Load") {
isLoading = true // Immediate UI update
Task {
result = await fetchData()
isLoading = false
}
}
}
}
```
**Pattern:** Use state as the boundary. Async work updates model/state; UI
reacts synchronously.
## The .task Modifier
Prefer `.task` over manual `Task` creation in views:
```swift
.task {
await loadInitialData()
}
```
**Advantages:**
- Automatically cancels on view disappear.
- Inherits the view's actor isolation (`@MainActor`).
- No need to store `Task` references for cancellation.
Use `.task(id:)` to restart work when a value changes:
```swift
.task(id: selectedItem) {
details = await fetchDetails(for: selectedItem)
}
```
## `@Observable` View Models
- Annotate view models with both `@Observable` and `@MainActor`.
- Use `@State` to own an `@Observable` instance (replaces `@StateObject`).
- Avoid `@ObservedObject` / `@StateObject` / `ObservableObject` in new code.
```swift
@Observable @MainActor
final class ViewModel {
var items: [Item] = []
var isLoading = false
func load() async {
isLoading = true
items = await fetchItems()
isLoading = false
}
}
struct ItemListView: View {
@State private var viewModel = ViewModel()
var body: some View {
List(viewModel.items) { item in
Text(item.name)
}
.task { await viewModel.load() }
}
}
```
## Async Observation with Observations (SE-0475)
Use `Observations { }` for transactional async observation:
```swift
.task {
for await _ in Observations { viewModel.searchText } {
await viewModel.performSearch()
}
}
```
## Performance-Driven Concurrency
- Offload expensive work from the main actor to avoid hitches.
- Keep time-sensitive UI logic (animations, gesture responses) synchronous.
- Separate UI code from long-running async work.
```swift
@Observable @MainActor
final class ImageProcessor {
var processedImage: UIImage?
func process(data: Data) async {
// Offload heavy work
let result = await Self.runProcessing(data: data)
processedImage = result
}
@concurrent
nonisolated static func runProcessing(data: Data) async -> UIImage {
// Runs on background thread pool
// ...
}
}
```
## Common SwiftUI Concurrency Mistakes
1. **Creating `Task` in `body`.** Use `.task` modifier instead.
2. **Not cancelling tasks.** `.task` does this automatically; manual `Task`
references must be cancelled in `onDisappear`.
3. **Blocking MainActor in view updates.** Move heavy computation to
`@concurrent` functions.
4. **Using `Task.detached` in views.** Loses actor context. Use `Task { }` or
`.task` modifier.
5. **Updating state from background.** Always update `@State` / `@Observable`
properties on `@MainActor`.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation). | Stars: 323k | Updated | Claude CodeCodex | Verified | Install |
| brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK). | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |