Concurrency on Swift Discovery

How to use SwiftData

Thu, 07 May 2026 07:56:26 +0000

Issue #1040

SwiftData is Apple’s modern persistence framework, introduced in iOS 17. It builds on top of Core Data but exposes a Swift-native API using macros and property wrappers. For most apps targeting iOS 17 or later, it replaces Core Data entirely without needing to touch an xcdatamodeld file or write fetch requests by hand.

Defining a model

The entry point for any SwiftData app is the @Model macro. Apply it to a class and SwiftData automatically makes it persistable and observable.

How to use isolated and nonisolated in Swift 6 concurrency

Thu, 07 May 2026 07:34:33 +0000

Issue #1039

Actor isolation in Swift 6 is not binary. A type can be mostly isolated while selectively exposing some members to callers from any context. A function can accept any actor and run directly on its executor without being bound to it permanently. Two keywords control this: nonisolated opts a member out of its enclosing isolation, and isolated makes a function parameter a live entry point into an actor’s context. Understanding both turns isolation from a wall into a precision tool.

How to use Swift 6 concurrency

Thu, 07 May 2026 07:09:21 +0000

Issue #1038

Swift 6 concurrency replaces Grand Central Dispatch queues, locks, and completion handlers with a structured model built around async/await, actors, and task groups. The compiler enforces isolation rules at build time, and the runtime catches violations that slip through. This article walks through the core tools and the patterns that make them work correctly.

async/await

Marking a function async means it can suspend without blocking the thread it runs on. When it suspends, the thread is freed to do other work. When the awaited value is ready, Swift resumes the function, possibly on a different thread.

How to avoid Swift 6 concurrency crashes

Thu, 07 May 2026 07:01:00 +0000

Issue #1037

Enabling Swift 6 strict concurrency checking (SWIFT_STRICT_CONCURRENCY = complete) catches data races at compile time, but it does not protect you fully at runtime. The compiler also injects dynamic isolation assertions at actor and GCD boundaries. These fire in production, not just in your test suite, often at callsites that produced no compiler warning at all.

The two crash symbols you will see in crash reports are

_dispatch_assert_queue_fail, which fires when code expected a specific dispatch queue but ran on a different one
_swift_task_checkIsolatedSwift, which fires when code expected actor isolation (for example, @MainActor) but ran outside it.

Both originate from the same root cause: a piece of code inherited actor isolation from its definition context and was then called from a different thread.