Swift 6 Strict Concurrency: Enabling Strict Mode in a Small App Without Downtime

To enable strict concurrency in a small application without risking stability or requiring a total codebase rewrite, you should adopt a per-target migration strategy. Because Swift 6 concurrency is a compile-time language mode, it does not introduce runtime "downtime" in the sense of server outages, but it can cause build failures if applied globally to legacy code.

Incremental Activation Strategy

The most stable path is to keep your existing codebase in Swift 5 mode while enabling Swift 6 for new modules or isolated targets. This allows you to validate new features under strict safety while legacy code remains functional.

1. Per-Target Configuration

Instead of changing the project-wide language version, modify the build settings for specific targets:

• Xcode: Navigate to Build Settings > Swift Language Version and set the specific target to Swift 6.
• Swift Package Manager: Define the swiftLanguageMode in the package manifest for the specific target.

Existing modules will continue to compile under Swift 5 rules, while new modules will enforce data-race safety. If your app consists of only a single target, you cannot mix modes; you must either migrate the whole target or use Strict Concurrency Checking warnings in Swift 5.10 to identify issues before switching to Swift 6.

2. Managing Module Boundaries

When a Swift 6 module imports a Swift 5 module that hasn't yet adopted Sendable, the compiler will trigger diagnostics. Use @preconcurrency import to suppress these warnings:

@preconcurrency import LegacyModule

This tells the compiler that the imported module is not yet concurrency-aware, allowing the Swift 6 module to remain strict without being blocked by the legacy dependency.

Balancing Safety and Effort

The choice between full Sendable enforcement and @unchecked Sendable depends on the nature of the type:

Strategy	Best Use Case	Risk
Full Enforcement	New types, value types (structs), or Actor-isolated state.	Higher initial refactoring cost.
@unchecked Sendable	Legacy classes with proven internal locking/synchronization.	Hides actual data races from the compiler.

Binary Compatibility and Deployment

Activating strict concurrency is a compile-time change. It does not change the binary ABI or the minimum deployment target of your app. You can ship a binary compiled with Swift 6 to any OS version supported by your current deployment target. However, if you are distributing a binary framework, changing a public type to Sendable may affect source compatibility for your clients.

Verification Steps

• Build Log Audit: Verify the -swift-version 6 flag is present only for the intended targets in the build logs.
• TSan Validation: Run your test suite with the Thread Sanitizer (TSan) enabled to ensure that any @unchecked Sendable opt-outs are actually thread-safe.

Diagnostic Detail Needed: Is your application structured as a single monolithic target or as multiple separate modules/packages? If it is a single target, the per-target strategy is not applicable, and a warning-based migration in Swift 5.10 is required first.