Swift 6.2 introduced several upcoming features that you can enable in Xcode’s build settings. We’ve discussed a few in detail in this course already, like the Default Actor Isolation and the NonisolatedNonsendingByDefault upcoming feature.

Another build setting you might discover is called “Approachable Concurrency”. As the name implies, it aims to make concurrency more approachable. It does this by enabling a combination of other upcoming features all at once.

Exploring the Approachable Concurrency build setting

You can find the Approachable Concurrency build setting in Xcode 26 and above. After navigating to the build settings, you’ll have to search for “Approachable Concurrency”. The quick help on the right side will show you which upcoming features it will enable.

At the moment of writing this lesson, the summary is as follows:

Enables upcoming features that aim to provide a more approachable path to Swift Concurrency: DisableOutwardActorInference, GlobalActorIsolatedTypesUsability, InferIsolatedConformances, InferSendableFromCaptures, and NonisolatedNonsendingByDefault.

I’m explicitly saying “at the moment of writing” since this list of upcoming features might change in the future.

Enabled by default for new projects, opt-in for existing

It’s essential to be aware that this feature is enabled by default for new projects, but you must opt in for existing ones. The latter is for a reason: it changes the behavior of existing code. I highly want to recommend migrating to each individual feature manually using the next lesson’s migration tooling. This way, your existing code will update to new features like @concurrent, and you’ll be able to apply relevant code changes manually.

If you enable Approachable Setting without manual migration, your code may suddenly behave unexpectedly differently. The best example is NonisolatedNonsendingByDefault, where nonisolated asynchronous methods suddenly run on the callee’s actor instead of a new global executor. A manual migration would attribute methods with @concurrent before enabling.

A closer look at the enabled upcoming features

To better understand what happens after enabling approachable Concurrency, it’s good to discuss each upcoming feature individually.

Disable Outward Actor Isolation Inference

Removes the rule where a property wrapper with global actor isolation (like @MainActor) could automatically apply that isolation to the entire type using it. This behavior was confusing and often surprising—changing one property could unexpectedly affect other code. Starting in Swift 6, actor isolation must now be explicitly declared on the type, making isolation clearer and easier to understand.

Usability of global-actor-isolated types

Makes global-actor-isolated types (like @MainActor structs and classes) easier to use by removing unnecessary restrictions. It lets you access Sendable properties more easily, automatically treats certain functions and closures as @Sendable, and safely allows capturing non-Sendable values in isolated closures. It also fixes inheritance issues by letting subclasses add global actor isolation, as long as they don’t become Sendable if it would be unsafe. Overall, it simplifies writing safe concurrent code.

Global-actor isolated conformances

Allows types isolated to a global actor (like @MainActor) to conform to protocols in a way that’s limited to their actor’s context. For example, a @MainActor class can now conform to Equatable using an isolated conformance, which works only when called from the main actor. This avoids messy workarounds like nonisolated functions and improves safety by letting the compiler enforce where conformances can be used. It also introduces checks to prevent these conformances from accidentally leaking across concurrency boundaries, keeping your code safe from data races while improving how actor-isolated types interact with protocols and generics.

Inferring Sendable for methods and key path literals

Improves Swift’s concurrency usability by automatically inferring @Sendable for methods and key path literals when it’s safe. If a method belongs to a Sendable type, you no longer need to manually mark partial or unapplied references as @Sendable—the compiler will do it for you. Similarly, key paths only need to be Sendable when they’re used in concurrent contexts, avoiding confusing warnings. This feature also allows you to explicitly mark key paths as Sendable when needed. This change reduces boilerplate and surprises when writing concurrent Swift code.

nonisolated(nonsending) by Default

In short: Runs nonisolated async functions on the caller’s actor by default unless the function is explicitly marked @concurrent. We’ve already covered this one in detail in the lesson Dispatching to different threads.

Can I opt-in to these features one-by-one?

Yes, as mentioned earlier, that’s actually recommended. You’ll learn how to use Swift’s migration tooling to migrate to each feature individually.

Do I have to wait for Swift 6.2 and Xcode 26 for Approachable Concurrency?

The Approachable Concurrency build setting is only available in Xcode 26 and up, but its related features are available for earlier versions of Swift. The above list mentions the relevant proposal ánd Swift version. In case one of the features got implemented in Swift 6, you might be able to start using it already in older Xcode & Swift versions. You just need to opt-in for a specific feature manually.

The impact on existing projects

New projects in Xcode 26 and above will have many of these features enabled by default. For existing projects, however, this is different.

This could differ based on when you’ve created your project, but it’s essential to be aware of these settings’ default states. For my personal project RocketSim, this was the state of all upcoming features and Approachable Concurrency:

As you can see, everything’s turned off. What’s interesting is what happens when you change the Approachable Concurrency setting:

Xcode is smart enough to enable all relevant upcoming features, neat!

And for those wondering: I did not just flip the switch. I went over all packages individually and enabled each upcoming feature one by one. I did keep a focus on all packages on a single feature. For example, I first migrated all packages to NonisolatedNonsendingByDefault. This way, I created a focused environment, and I stayed within the same feature context.

Enabling Approachable Concurrency for packages

You can also enable Approachable Concurrency inside packages. For this, you’ll have to enable the Swift 6.2 tools version:

// swift-tools-version: 6.2

And manually enable all relevant upcoming features. I’ve gone ahead and did this for you, so you only have to copy and paste:

.target(
    name: "YourPackageTarget",
    swiftSettings: [
        .enableUpcomingFeature("DisableOutwardActorInference"),
        .enableUpcomingFeature("GlobalActorIsolatedTypesUsability"),
        .enableUpcomingFeature("InferIsolatedConformances"),
        .enableUpcomingFeature("InferSendableFromCaptures"),
        .enableUpcomingFeature("NonisolatedNonsendingByDefault")
    ]
)

Summary

The Approachable Concurrency build setting helps us make Swift Concurrency more approachable. Several upcoming features will be enabled by default, making the transition to Swift Concurrency smoother.