Free mDevCamp ticket up for grabs, enter in 10 seconds. Go to the giveaway →
Giveaway: Free mDevCamp ticket giveaway.
Give your simulator superpowers

RocketSim: An Essential Developer Tool
as recommended by Apple

Threads vs. Tasks in Swift Concurrency

Are Threads the same as Tasks in Swift Concurrency? You may wonder if you're used to writing Swift or Objective-C using Grand Central Dispatch (GCD) and traditional APIs. A so-called threading mindset has helped us develop apps that work with asynchronous functions for years. Modern concurrency uses Swift Concurrency and ...
Concurrency

Modern Swift Lock: Mutex & the Synchronization Framework

Swift offers several solutions to lock access to mutable content and prevent so-called data races. Locks like NSLock, DispatchSemaphore, or a serial DispatchQueue are a popular choice for many. Some articles compare their performance and tell you which one works best, but I'd like to introduce you to a modern ...
Concurrency

Swift Concurrency & Swift 6 Course (Launch offer)

A Swift Concurrency Course that helps you learn all the fundamentals of Swift Concurrency and migrate your projects smoothly to Swift 6 strict concurrency checking. It can be intimidating to start migrating existing projects to Swift 6 and learn about async/await, sendable, and actors simultaneously. A graceful learning process can ...
ConcurrencySwift

Default Actor Isolation in Swift 6.2

Default Actor Isolation in Swift 6.2 allows you to run code on the @MainActor by default. This new Swift compiler setting helps improve the approachability of data-race safety, which was set as a goal for the Swift team in their February 2025 vision document. While new projects are set to ...
Concurrency

@concurrent explained with code examples

Swift 6.2 introduced many changes during WWDC 2025, including a new @concurrent attribute we need when working with Swift Concurrency. You might have read that we'll be able to @MainActor all the things now, which also means we need a way out of the @MainActor for asynchronous functions. For the ...
ConcurrencySwift

Swift 6.2: A first look at how it’s changing Concurrency

Swift 6.2 is the upcoming release of Apple's native language. It's currently in active development, and as you know from my weekly Swift Evolution updates, many proposals are currently being processed. While many of you usually await a new Xcode release before jumping into new changes, I think knowing what's ...
ConcurrencySwift

What is Structured Concurrency?

When we talk about Swift Concurrency, we also often mention Structured Concurrency. It's a fundamental part of async/await in Swift and helps us understand how Swift's latest improvements in concurrency work. Before async/await, we wrote our asynchronous methods using closures and Grand Central Dispatch (GCD). This worked well but often ...
ConcurrencySwift

Task.sleep() vs. Task.yield(): The differences explained

In Swift Concurrency, we can use Task.sleep() and Task.yield() to let a specific task sleep or yield for a period of time. Both look and behave similarly, but there are a few significant differences to be aware of as Swift developers. Knowing these differences allows you to better understand when ...
Concurrency

Swift 6: What’s New and How to Migrate

Apple announced Swift 6 during WWDC 2024 as a major release of their programming language. It became first available in Xcode 16 and aims to create a fantastic development experience. Many of the latest more prominent features like async/await have been part of the road toward this major version bump ...
Concurrency

MainActor usage in Swift explained to dispatch to the main thread

MainActor is a new attribute introduced in Swift 5.5 as a global actor providing an executor that performs its tasks on the main thread. When building apps, it's essential to perform UI updating tasks on the main thread, which can sometimes be challenging when using several background threads. Using the ...
ConcurrencySwift

How to Use URLSession with Async/Await for Network Requests in Swift

URLSession allows you to perform network requests and becomes even more powerful with its async/await APIs. You can request data from a given URL and parse it into a decoded structure before displaying its data in a view. Popular frameworks like Alamofire aim to make it easier to perform requests, ...
Concurrency

Concurrency-safe global variables to prevent data races

Concurrency-safe global variables help you prevent data races and allow you to solve strict-concurrency-related warnings. Since you can access global variables from any context, ensuring access is safe by removing mutability or conforming to Sendable is essential. As a developer, you must prevent data races since they can make your ...
Concurrency