What is New in the Swift 5.10?


Swift prioritizes code safety by eliminating memory-related issues at compile time. However, concurrent programming can introduce data races, making it challenging to write correct code. To address this, Swift utilizes actors and tasks to enforce data isolation, guaranteeing exclusive access to shared mutable state. This data isolation functionality has been under active development since the introduction of the Swift concurrency roadmap in 2020.

Swift 5.10, released in March 2024, represents a major advancement in concurrency features. This update focuses on achieving full data isolation, aiming to completely eliminate data races and significantly improve the safety and reliability of concurrent Swift code.

Data-races: The Enemy of Safe Concurrency

Imagine two threads trying to access and modify the same piece of data simultaneously. This can lead to unpredictable behavior and crashes, known as data races. By ensuring data isolation, Swift 5.10 guarantees that only one thread can access and modify shared state at a time, preventing these race conditions.

Achieving Full Data Isolation 

Swift 5.10 accomplishes this through stricter enforcement of two key concepts:

  1. Sendable: This protocol defines types that are safe to be shared across threads. In simpler terms, only data types marked as Sendable can be passed between concurrent operations.
  2. Actor Isolation: Actors are units of concurrency that encapsulate data and provide a safe way to access and modify it. Swift 5.10 enforces stricter isolation rules for actors, ensuring that their internal state can only be mutated from within the actor itself.

Example. Thread-Safe Data Access

Let's look the detailed example that incorporates the concepts of Sendable and async introduced in Swift 5.10 to address data races in a counter class:

actor SafeCounter: Sendable {
  private var count = 0
  func increment() async {
    // Isolate access to count using async task
    await withTaskGroup { taskGroup in
      taskGroup.launch {
        // Increment happens within the task
        self.count += 1
  func getCount() -> Int {
    return count

Above code explanation

  • SafeCounter as Sendable: The SafeCounter class now conforms to the Sendable protocol, ensuring it's thread-safe to share across concurrent operations.
  • async for increment: The increment function is marked as async. This allows it to be called from asynchronous contexts, like other actor methods.
  • Isolated Incrementation: The actual increment logic is encapsulated within a separate task launched using withTaskGroup. This task group creates a temporary scope for asynchronous execution. Any modifications to count happen within this isolated task, preventing race conditions with potential concurrent access from other tasks.
  • getCount remains synchronous: The getCount method remains synchronous as it's only reading the current value of count and doesn't modify any state.

Usage Example

actor SomeActor {
  private let counter = SafeCounter()

  func incrementCounter() async {
    await counter.increment()

  func getCounterValue() async -> Int {
    return await counter.getCount()

Above example SomeActor can safely call incrementCounter concurrently  from multiple tasks because SafeCounter enforces data isolation. The getCounterValue method can also be called concurrently to retrieve the latest count without introducing race conditions.

Looking ahead: Swift 6 and Beyond

While Swift 5.10 lays the groundwork for robust concurrency, the focus in future versions will likely be on improving the usability of these strict checks. The goal is to reduce false positives (warnings for safe code) and make it easier for developers to write correct concurrent programs.


Swift 5.10 makes it easier to write safe code for apps that do things at the same time (like downloading data and updating the UI). This update helps prevent crashes and makes your apps more reliable. As Swift gets even better, you'll have even more tools to build awesome apps!

Similar Articles