Swift 6

I tried a bunch of things but wasn’t able to reproduce this. Here’s an example of what I did: import Foundation import Photos @MainActor func show(imageInfo: (path: String, asset: PHAsset?)) { } class Test { func onCaptureCompleted(_ imageURL: URL, asset: PHAsset?) { let path = imageURL.path() Task { @MainActor in show(imageInfo: (path, asset)) } } } func main() { print(Hello Cruel World!) } main() This compiles just fine with Xcode 16.2 in Swift 6 language mode. Which version of Xcode are you using? Can you post a snippet that shows the problem? Please post it as text rather than an image. See tips 5 and 6 in Quinn’s Top Ten DevForums Tips. Share and Enjoy — Quinn “The Eskimo!” @ Developer Technical Support @ Apple let myEmail = eskimo + 1 + @ + apple.com

Right. There are two terms you need to understand here: Swift compiler version Swift language mode This terminology is defined (recently mind you) in SE-0441 Consider this: % DEVELOPER_DIR=/Users/quinn/XcodeZone/Xcode-beta.app/Contents/Developer xcrun swift --version swift-driver version: 1.127.5.3 Apple Swift version 6.2 … The Swift compiler version build in to Xcode 26.0b2 is 6.2. That compiler supports multiple language modes, and Xcode it show you those in that popup. There is no Swift 6.2 language mode, and that’s fine. Having said that, the Swift 6 language mode in Swift 6.2 does have optional features that are likely important to you. The most important of those is the approachable concurrency features, controlled by the Approachable Concurrency (SWIFT_APPROACHABLE_CONCURRENCY) build setting. Note that it’s possible that Swift might gain a future language mode to cover stuff like this, but that’s a topic for Swift

It's unclear what LabResultDto in the code snippet is. If it is a Sendable type that wraps the data in a SwiftData model, that's fine; if it is a SwiftData model type, because a SwiftData model object is not Sendable, you won't want to pass it across actors – Otherwise, Swift 6 compiler will give you an error. For more information about this topic, see the discussion here. When using SwiftData + SwiftUI, I typically use @Query to create a result set for a view. Under the hood (of @Query), the query controller should be able to detect the changes you made from within a model actor, and trigger a SwiftUI update. Fore more information about observing SwiftData changes, see this WWDC25 video. Best, —— Ziqiao Chen  Worldwide Developer Relations.

I'm also having problems with NSObjects in 16b5. With complete concurrency checking enabled but Swift 5 language mode, the following generates 1 warning and 1 error: import Foundation import UIKit @MainActor class TestObject: NSObject { let testView = UIView(frame: .zero) private func doSomething() { } override init() { // [ERROR] Property 'self.testView' not initialised at super.init call super.init() // [WARNING] Call to main actor-isolated instance method 'doSomething()' in a synchronous nonisolated context; this is an error in the Swift 6 language mode doSomething() } } So, (1) what's up with the let call not instantiating before the init() is called? and (2) how come the override method is now reverting back to the solution of the function being overridden rather than the stated actor/isolation of the object it's being defined in? I really hope Quin's about to put me straight.

But since WKScriptMessageHandlerWithReply is not @MainActor, neither can this method be so marked My WebKit is kinda rusty but I believe that WKScriptMessageHandlerWithReply should be as main-actor isolated, right? That is, all of its methods are expected to be called on the main thread? If so, this devolves into the question “How do I tell the Swift compiler about that fact?” There are various tricks for that but I tend to reach for MainActor.assumeIsolated(_:file:line:): @MainActor class MyClass: NSObject, WKScriptMessageHandlerWithReply { var lastMessage: WKScriptMessage? = nil var counter: Int = 0 nonisolated func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage, replyHandler: @escaping (Any?, String?) -> Void) { MainActor.assumeIsolated { self.lastMessage = message self.counter += 1 replyHandler([counter: self.counter], nil) } } } This compiles without warnings in Xcode 15.3 with strict concurrency enabled. Now how it’s accessing coun

Thank you, @Frameworks Engineer! In my case your comment helped me a lot. In my app I need to differentiate an iPhone device from other devices like iPad, Mac, etc. because on iPhone I must not select by default first element in my Navigation List, but I must do this on other devices. Initially I was checking like this: if !UIDevice.current.model.starts(with: iPhone) { ... } but it showed me this warning Main actor-isolated class property 'current' can not be referenced from a non-isolated context; this is an error in Swift 6 for such check within the (try? await ...) block. I was curious why, but now I understand, it's because UIDevice is only supported on the main thread. So, now I'm getting the value at once in the beginning: private let device = UIDevice.current.model and then just check the device in other places: if !device.starts(with: iPhone) { ... }

Ok, specific problem then. I downloaded Emoji Rangers, switched language mode to Swift 6, udpated some static vars to static lets, commented out the contents of ImageURLProtocol.stopLoading and finally got to the issue in AdventureView.swift: This error is the one I can't seem to solve - Main actor-isolated value of type '() async -> Void' passed as a strongly transferred parameter; later accesses could race. As far as I understand it, here it basically means that something that is not Sendable is being sent between contexts. It is not possible to remove @MainActor here because activityViewState is isolated to it: And even if this was not a factor, the original error reappears once activityViewState is no longer in the picture: The only workaround I've found feels wrong: extension Activity: @unchecked @retroactive Sendable {}

That setting doesn’t control the Swift compiler version. You always get the Swift compiler that’s built in to Xcode [1]. Rather, it controls the Swift language version, that is, the version of the language that the compiler tries to accommodate. The language version matters in the rare cases where Swift changes behaviour in some incompatible way. The language version don’t limit what features you can use. So you’ll find that many Swift 5 features are available when the language version is set to Swift 4.2, as long as those features don’t cause source-level compatibility problems for existing Swift 4.2 source code. I say “rare cases”, and that’s been true recently. However, the upcoming Swift 6 is going to involve a lot of changes, enforcing data race safety. Given that context, now is a good time to move forward to Swift 5. And, if you’re writing concurrent code, enable Strict Concurrency Checking. Share and Enjoy — Quinn “The Es

Making any required is a feature that's going to be enforced in Swift 6, but that's still a way off in the future. SE-0362 introduced a way to opt in to such future features, and the any requirement is listed as one such, under the identifier ExistentialAny. You'll need to pass this to the compiler in a -enable-upcoming-feature ExistentialAny compiler flag. Regarding main.swift, it sounds like you've manually created a main.swift and you're also using the @main construct from whichever app lifecycle template you chose when creating the project. Those will conflict. If you're using the SwiftUI lifecycle, you should use @UIApplicationDelegateAdaptor to get an app delegate. If not, use @main in the app delegate class declaration instead. Either way, you don't need to (and shouldn't) create a main.swift file.

Note how addPeriodicTimeObserver(…) takes a queue parameter which tells the system the queue on which to run the observer. You’re passing .main, indicating that you want the observer to run on the main queue. In that case, you don’t need to spin up a task. Rather, you can use assumeIsolate(…), which has two functions: At compile time, it tells the compiler that you’re expecting this code to run on the main actor. At runtime, it checks that fact. So, your code might look like this: avPlayer.addPeriodicTimeObserver(forInterval: CMTime(value: 1, timescale: 60), queue: .main) { [weak self] _ in MainActor.assumeIsolated { self?.myMainActorIsolatedMethod() } } There are a bunch of recipes like this in the Migrating to Swift 6 doc. Share and Enjoy — Quinn “The Eskimo!” @ Developer Technical Support @ Apple let myEmail = eskimo + 1 + @ + apple.com

Yeah, that’s a common pitfall. [quote='810625022, Capablanca, /thread/766993?answerId=810625022#810625022, /profile/Capablanca'] Does the following code seem correct to you? [/quote] Yes. And no (-: More below. [quote='810625022, Capablanca, /thread/766993?answerId=810625022#810625022, /profile/Capablanca'] I added the observe method [/quote] Yeah, this recursive structure is the standard way of handling this. The only problem with your code is that it falls foul of Swift 6’s data race checking: observe(job: job) // ^ Capture of 'job' with non-sendable type 'AsyncJob' in a `@Sendable` closure It’s hard for me to recommend a fix for that, because it’s tied into your overall concurrency strategy. Share and Enjoy — Quinn “The Eskimo!” @ Developer Technical Support @ Apple let myEmail = eskimo + 1 + @ + apple.com