This topic area is about the programming languages themselves, not about any specific API or tool. If you have an API question, go to the top level and look for a subtopic for that API. If you have a question about Apple developer tools, start in the Developer Tools & Services topic. For Swift questions: If your question is about the SwiftUI framework, start in UI Frameworks > SwiftUI. If your question is specific to the Swift Playground app, ask over in Developer Tools & Services > Swift Playground If you’re interested in the Swift open source effort — that includes the evolution of the language, the open source tools and libraries, and Swift on non-Apple platforms — check out Swift Forums If your question is about the Swift language, that’s on topic for Programming Languages > Swift, but you might have more luck asking it in Swift Forums > Using Swift. General: Forums topic: Programming Languages Swift: Forums subtopic: Programming Languages > Swift Forums tags: Swift Developer > Swift website Swift Programming Language website The Swift Programming Language documentation Swift Forums website, and specifically Swift Forums > Using Swift Swift Package Index website Concurrency Resources, which covers Swift concurrency How to think properly about binding memory Swift Forums thread Other: Forums subtopic: Programming Languages > Generic Forums tags: Objective-C Programming with Objective-C archived documentation Objective-C Runtime documentation Share and Enjoy — Quinn “The Eskimo!” @ Developer Technical Support @ Apple let myEmail = "eskimo" + "1" + "@" + "apple.com"

Would an old guy (75) who is proficient in Obj-C, only codes for iOS/macOS/tvOS/web, and has spent the last 60 years promising himself “that’s definitely the last language I’m learning”, now find it pleasing/beneficial/productive to learn Swift/SwiftUI? Assume programming is relegated to a hobby and favorite pastime and I’ll live 10 more years :) Thanks.

Swift concurrency is an important part of my day-to-day job. I created the following document for an internal presentation, and I figured that it might be helpful for others. If you have questions or comments, put them in a new thread here on DevForums. Use the App & System Services > Processes & Concurrency topic area and tag it with both Swift and Concurrency. Share and Enjoy — Quinn “The Eskimo!” @ Developer Technical Support @ Apple let myEmail = "eskimo" + "1" + "@" + "apple.com" Swift Concurrency Proposal Index This post summarises the Swift Evolution proposals that went into the Swift concurrency design. It covers the proposal that are currently implemented in the Swift 6.4 beta, plus a few additional ones that aren’t currently available. The focus here is the Swift Evolution proposals. For general information about Swift concurrency, see the documentation referenced by Concurrency Resources. Early Days Some early high-level discussions of concurrency on Swift Evolution: Swift Concurrency Manifesto (Aug 2017) — Introduces async and await and actors, including the main actor. If you’re curious, you can read the Swift Evolution thread that introduced this. Swift Concurrency Roadmap (Oct 2020) — This extended the design to include Task, structured concurrency, and Objective-C interoperability. Each subsystem had its own pitch thread [Concurrency] Asynchronous functions [Concurrency] Structured concurrency [Concurrency] Actors & actor isolation [Concurrency] Interoperability with Objective-C Swift 6.0 The following Swift Evolution proposals form the basis of the Swift 6.0 concurrency design. SE-0176 Enforce Exclusive Access to Memory link: SE-0176 notes: This defines the “Law of Exclusivity”, a critical foundation for both serial and concurrent code. SE-0282 Clarify the Swift memory consistency model ⚛︎ link: SE-0282 notes: This defines Swift’s memory model, that is, the rules about what is and isn’t allowed when it comes to concurrent memory access. SE-0296 Async/await link: SE-0296 introduces: async functions, async, await SE-0297 Concurrency Interoperability with Objective-C link: SE-0297 notes: Specifies how Swift imports an Objective-C method with a completion handler as an async method. Explicitly allows @objc actors. SE-0298 Async/Await: Sequences link: SE-0298 introduces: AsyncSequence, for await syntax notes: This just defines the AsyncSequence protocol. For one concrete implementation of that protocol, see SE-0314. SE-0300 Continuations for interfacing async tasks with synchronous code link: SE-0300 introduces: CheckedContinuation, UnsafeContinuation notes: Use these to create an async function that wraps a legacy request-reply concurrency construct. For information about the non-copyable version, see SE-0528. SE-0302 Sendable and @Sendable closures link: SE-0302 introduces: Sendable, @Sendable closures, marker protocols SE-0304 Structured concurrency link: SE-0304, third-party commentary introduces: unstructured and structured concurrency, Task, TaskPriority, cancellation, CancellationError, withTaskCancellationHandler(…), sleep(…), withTaskGroup(…), withThrowingTaskGroup(…) notes: For the async let syntax, see SE-0317. For more ways to sleep, see SE-0329 and SE-0374. For discarding task groups, see SE-0381. SE-0306 Actors link: SE-0306 introduces: actor syntax notes: For actor-isolated parameters and the nonisolated keyword, see SE-0313. For global actors, see SE-0316. For custom executors and the Actor protocol, see SE-0392. SE-0311 Task Local Values link: SE-0311 introduces: TaskLocal SE-0313 Improved control over actor isolation link: SE-0313 introduces: isolated parameters, nonisolated SE-0314 AsyncStream and AsyncThrowingStream link: SE-0314 introduces: AsyncStream, AsyncThrowingStream, onTermination notes: These are super helpful when you need to publish a legacy notification construct as an async stream. For a simpler API to create a stream, see SE-0388. SE-0316 Global actors link: SE-0316 introduces: GlobalActor, MainActor notes: This includes the @MainActor syntax for closures. SE-0317 async let bindings link: SE-0317 introduces: async let syntax SE-0323 Asynchronous Main Semantics link: SE-0323 SE-0327 On Actors and Initialization link: SE-0327 notes: For a proposal to allow access to non-sendable isolated state in a deinitialiser, see SE-0371. SE-0329 Clock, Instant, and Duration link: SE-0329 introduces: Clock, InstantProtocol, DurationProtocol, Duration, ContinuousClock, SuspendingClock notes: For another way to sleep, see SE-0374. SE-0331 Remove Sendable conformance from unsafe pointer types link: SE-0331 SE-0337 Incremental migration to concurrency checking link: SE-0337 introduces: @preconcurrency, explicit unavailability of Sendable notes: This introduces @preconcurrency on declarations, on imports, and on Sendable protocols. For @preconcurrency conformances, see SE-0423. For the ~Sendable syntax, see SE-0518. SE-0338 Clarify the Execution of Non-Actor-Isolated Async Functions link: SE-0338 notes: This change caught a bunch of folks by surprise and SE-0461 modifies its behaviour significantly. SE-0340 Unavailable From Async Attribute link: SE-0340 introduces: noasync availability kind SE-0343 Concurrency in Top-level Code link: SE-0343 notes: For how strict concurrency applies to global variables, see SE-0412. SE-0374 Add sleep(for:) to Clock link: SE-0374 notes: This builds on SE-0329. SE-0381 DiscardingTaskGroups link: SE-0381 introduces: DiscardingTaskGroup, ThrowingDiscardingTaskGroup notes: Use this for task groups that can run indefinitely, for example, a network server. SE-0388 Convenience Async[Throwing]Stream.makeStream methods link: SE-0388 notes: This builds on SE-0314. SE-0392 Custom Actor Executors link: SE-0392 introduces: Actor protocol, Executor, SerialExecutor, ExecutorJob, assumeIsolated(…) notes: For task executors, a closely related concept, see SE-0417. For custom isolation checking, see SE-0424. SE-0395 Observation link: SE-0395 introduces: Observation module, Observable notes: While this isn’t directly related to concurrency, it’s relationship to Combine, which is an important existing concurrency construct, means that it warrants inclusion in this list. SE-0401 Remove Actor Isolation Inference caused by Property Wrappers link: SE-0401, third-party commentary availability: upcoming feature flag: DisableOutwardActorInference SE-0410 Low-Level Atomic Operations ⚛︎ link: SE-0410 introduces: Synchronization module, Atomic, AtomicLazyReference, WordPair SE-0411 Isolated default value expressions link: SE-0411, third-party commentary SE-0412 Strict concurrency for global variables link: SE-0412 introduces: nonisolated(unsafe) notes: While this is a proposal about globals, the introduction of nonisolated(unsafe) applies to “any form of storage”. SE-0414 Region based Isolation link: SE-0414, third-party commentary notes: To send parameters and results across isolation regions, see SE-0430. SE-0417 Task Executor Preference link: SE-0417, third-party commentary introduces: withTaskExecutorPreference(…), TaskExecutor, globalConcurrentExecutor notes: This is closely related to the custom actor executors defined in SE-0392. SE-0418 Inferring Sendable for methods and key path literals link: SE-0418, third-party commentary availability: upcoming feature flag: InferSendableFromCaptures notes: The methods part of this is for “partial and unapplied methods”. SE-0420 Inheritance of actor isolation link: SE-0420, third-party commentary introduces: #isolation, optional isolated parameters notes: This is what makes it possible to iterate over an async stream in an isolated async function. SE-0421 Generalize effect polymorphism for AsyncSequence and AsyncIteratorProtocol link: SE-0421, third-party commentary notes: Previously AsyncSequence used an experimental mechanism to support throwing and non-throwing sequences. This moves it off that. Instead, it uses an extra Failure generic parameter and typed throws to achieve the same result. This allows it to finally support a primary associated type. Yay! SE-0423 Dynamic actor isolation enforcement from non-strict-concurrency contexts link: SE-0423, third-party commentary introduces: @preconcurrency conformance notes: This adds a number of dynamic actor isolation checks (think assumeIsolated(…)) to close strict concurrency holes that arise when you interact with legacy code. SE-0424 Custom isolation checking for SerialExecutor link: SE-0424, third-party commentary introduces: checkIsolation() notes: This extends the custom actor executors introduced in SE-0392 to support isolation checking. SE-0430 sending parameter and result values link: SE-0430, third-party commentary introduces: sending notes: Adds the ability to send parameters and results between the isolation regions introduced by SE-0414. SE-0431 @isolated(any) Function Types link: SE-0431, third-party commentary, third-party commentary introduces: @isolated(any) attribute on function types, isolation property of functions values notes: This is laying the groundwork for SE-NNNN Closure isolation control. That, in turn, aims to bring the currently experimental @_inheritActorContext attribute into the language officially. SE-0433 Synchronous Mutual Exclusion Lock 🔒 link: SE-0433 introduces: Mutex SE-0434 Usability of global-actor-isolated types link: SE-0434, third-party commentary availability: upcoming feature flag: GlobalActorIsolatedTypesUsability notes: This loosen strict concurrency checking in a number of subtle ways. Swift 6.1 Swift 6.1 has the following additions. Vision: Improving the approachability of data-race safety link: vision SE-0442 Allow TaskGroup’s ChildTaskResult Type To Be Inferred link: SE-0442, third-party commentary notes: This represents a small quality of life improvement for withTaskGroup(…) and withThrowingTaskGroup(…). SE-0449 Allow nonisolated to prevent global actor inference link: SE-0449, third-party commentary notes: This is a straightforward extension to the number of places you can apply nonisolated. Swift 6.2 Xcode 26 has two new build settings: Approachable Concurrency enables the following feature flags: DisableOutwardActorInference, GlobalActorIsolatedTypesUsability, InferIsolatedConformances, InferSendableFromCaptures, and NonisolatedNonsendingByDefault. Default Actor Isolation controls SE-0466 Swift 6.2 has the following additions. SE-0371 Isolated synchronous deinit link: SE-0371, third-party commentary introduces: isolated deinit notes: Allows a deinitialiser to access non-sendable isolated state, lifting a restriction imposed by SE-0327. SE-0457 Expose attosecond representation of Duration link: SE-0457 introduces: attoseconds, init(attoseconds:) SE-0461 Run nonisolated async functions on the caller’s actor by default link: SE-0461 availability: upcoming feature flag: NonisolatedNonsendingByDefault introduces: nonisolated(nonsending), @concurrent notes: This changes the default isolation of async functions, and introduces syntax to override that default. It represents a significant change from SE-0338. SE-0462 Task Priority Escalation APIs link: SE-0462 introduces: withTaskPriorityEscalationHandler(…) notes: Code that uses structured concurrency benefits from priority boosts automatically. This proposal exposes APIs so that code using unstructured concurrency can do the same. SE-0463 Import Objective-C completion handler parameters as @Sendable link: SE-0463 notes: This is a welcome resolution to a source of much confusion. SE-0466 Control default actor isolation inference link: SE-0466, third-party commentary introduces: -default-isolation compiler flag notes: This is a major component of the above-mentioned vision document. SE-0468 Hashable conformance for Async(Throwing)Stream.Continuation link: SE-0468 notes: This is an obvious benefit when you’re juggling a bunch of different async streams. SE-0469 Task Naming link: SE-0469 introduces: name, init(name:…) SE-0470 Global-actor isolated conformances link: SE-0470 availability: upcoming feature flag: InferIsolatedConformances introduces: @SomeActor protocol conformance notes: This is particularly useful when you want to conform an @MainActor type to Equatable, Hashable, and so on. SE-0471 Improved Custom SerialExecutor isolation checking for Concurrency Runtime link: SE-0471 notes: This is a welcome extension to SE-0424. SE-0472 Starting tasks synchronously from caller context link: SE-0472 introduces: immediate[Detached](…), addImmediateTask[UnlessCancelled](…) notes: This introduces the concept of an immediate task, one that initially uses the calling execution context. This is one of those things where, when you need it, you really need it. But it’s hard to summarise when you might need it, so you’ll just have to read the proposal (-: Swift 6.3 Swift 6.3 has the following additions. SE-0473 Clock Epochs link: SE-0473 introduces: systemEpoch notes: This builds on SE-0329 to add ‘zero’ points for SuspendingClock and ContinuousClock. Swift 6.4 Swift 6.4, currently in beta, has the following additions. SE-0493 Support async calls in defer bodies link: SE-0493 notes: And there was much rejoicing! SE-0530 Async Result Support link: SE-0530 introduces: init(catching:) async variant SE-0528 Continuation — Safe and Performant Async Continuations link: SE-0528 introduces: Continuation notes: This supplements CheckedContinuation and UnsafeContinuation, introduced in SE-0300, with a non-copyable continuation type that is both efficient and safer to use. SE-0523 Hashable conformance for UnownedTaskExecutor link: SE-0523 SE-0520 Discardable result use in Task initializers link: SE-0520 notes: This makes it harder to accidentally ignore task errors. SE-0518 ~Sendable for explicitly marking non-Sendable types link: SE-0518 introduces: ~Sendable SE-0504 Task Cancellation Shields link: SE-0504 introduces: withTaskCancellationShield(operation:) In Progress The proposals in the following sections didn’t make Swift 6.3 or 6.4 beta. SE-0478 File-level defaults link: SE-0478 notes: This lets you control default actor isolation (see SE-0466) on a file-by-file basis. SE-0406 Backpressure support for AsyncStream link: SE-0406 availability: returned for revision notes: Currently AsyncStream has very limited buffering options. This was a proposal to improve that. This feature is still very much needed, but the outlook for this proposal is hazy. My best guess is that something like this will land first in the Swift Async Algorithms package. See this thread. SE-NNNN Closure isolation control link: SE-NNNN introduces: @inheritsIsolation availability: not yet approved notes: This aims to bring the currently experimental @_inheritActorContext attribute into the language officially. It’s not clear how this will play out given the changes in SE-0461. SE-NNNN Create official comprehensive concurrency documentation and adopt related enhanced processes link: SE-NNNN availability: currently just a pitch Revision History 2026-07-16 Fixed a serious formatted problem introduced by the previous change. Added TaskPriority to the list of things introduced by SE-0304. Added SE-0478. 2026-07-10 Added Swift 6.3 and Swift 6.4 sections. Made numerous other minor changes. 2026-02-16 Added the Early Days section. 2026-01-07 Added another third-party commentary links. 2025-09-02 Updated for the upcoming release Swift 6.2. 2025-04-07 Updated for the release of Swift 6.1, including a number of things that are still in progress. 2024-11-09 First post.

Hey, so i have been making a python code game and I thought that it would be useful to be able to edit it and run it on my iPad, so I downloaded to and I can’t access it, or edit it. Is there a way to change it (as in to HTML format as an example) or get a compiler or a translation layer? thanks for your time. (PS it uses tinker)

In Xcode project > Build Settings > Swift Compiler - Concurrency. When we have those settings : Approachable Concurrency - Yes Default Actor Isolation - MainActor A sendable struct without @Actor annotation will be stuck to @MainActor. But if we have a sendable struct, by principle, it should be used across Actors. To remediate the situation, we had to prefix the struct with nonisolated keyword. The setting "Default Actor Isolation - MainActor" should not add @MainActor to Sendables. Problem describe in : FB23264607

I have a function a implemented in a protocol extension that's called millions of times per second. It in turn calls a function b which is required by the protocol which does not have an implementation in the extension. According to the Time Profiler in Instruments, function a spends a lot of time in __swift_instantiateGenericMetadata. I get a big performance bump by moving a out of the extension and re-implementing it identically in each type that conforms to the protocol. Is there any way to get the compiler to do this itself? Do I need to write a macro to do it for me? There are screenshots from Instruments illustrating the issue below. Thanks! These traces are made a tiny bit more confusing because the real names of a and b are the same: read(at:). (They take different types as their parameters.) Here's the Time Profiler trace of the protocol extension implementation: And here's the trace for the duplicated-in-each-type version:

I find these sample projects quite valuable: https://developer.apple.com/documentation/widgetkit/emoji-rangers-supporting-live-activities-interactivity-and-animations https://developer.apple.com/documentation/coredata/sharing-core-data-objects-between-icloud-users . Both use Swift 5, and it is not trivial to adopt Swift 6 with them. Any plans to update them? What is best approach for adopting Swift 6 on such sample code?

In Swift 6.4 or later, a RegexBuilder pattern can hang when an unbounded quantifier repeats a body that can match the empty string, where that body begins with NegativeLookahead. I've opened a corresponding issue and PR to resolve the issue in swift-experimental-string-processing. See below for a reproduction and a workaround. The regression affects apps running on OS 27 built with Xcode 27, which includes Swift 6.4. Running apps built with Xcode 27 on OS 26 or earlier demonstrates the expected behavior. Links: Issue: https://github.com/swiftlang/swift-experimental-string-processing/issues/865 PR: https://github.com/swiftlang/swift-experimental-string-processing/pull/866 FB23419149 and FB23179771 https://forums.swift.org/t/regexbuilder-infinite-loop-when-nullable-capture-starts-with-negativelookahead/87713 Reproduction In the reducer below, matching "A" repeatedly invokes the capture transform with an empty substring without advancing through the input. import RegexBuilder let regex = Regex { ZeroOrMore { Capture { NegativeLookahead { "a" } ZeroOrMore(.digit) } transform: { String($0) } // invoked repeatedly with "" } } _ = "A".matches(of: regex) // never returns Reduced string form: _ = try! Regex(#"(?:(?!a)\d*)*"#).firstMatch(in: "A") // never returns The issue is in the same forward-progress class as PR #851, which skips a nullable quantification's child subtree. Lookaround groups need the same treatment. The regression first appears in Swift 6.4-dev toolchains. I observed the issue in code running on iOS 27 beta 1 (24A5355q), then traced the regression to PR #849 in swift-experimental-string-processing. Workaround In the meantime, wrap the capture contents in Optionally { }: import RegexBuilder let digits = Regex { NegativeLookahead { "a" } ZeroOrMore(.digit) } let regex = Regex { ZeroOrMore { Capture { Optionally { digits } } transform: { String($0) } } } _ = "A".matches(of: regex)

Could you tell me whether Embedded Swift is expected to remain available only as a 'Development Snapshot'? I'd also be grateful to know if there are any plans to bring it to Xcode down the line. Thanks in advance!

Repurposing my questions that weren't a good fit for the group lab to see how that goes :) I've been building a ScreenReader in Swift leveraging Structured Concurrency, actors, and recently distributed actors over XPC. https://codeberg.org/SpeakUp I have a number of questions I could ask (and would love to ask) but would start with asking for thoughts on my RunLoopExecutor project https://codeberg.org/SpeakUp/RunLoopExecutor/ All of the macOS Accessibility APIs are C/CoreFoundation/CFRunLoop based and I wanted to build something where actors would feel idiomatic for an experienced Swift developer but under the hood we're making sure that we're not contending with ourselves with all the IPC we're doing to get Accessibility data. I think so far it's been pretty successful as seen in the Controller types for the ScreenReader project: https://codeberg.org/SpeakUp/ScreenReader I'm currently using pretty naive pool implementations, one that is fixed width and one that is dynamic with a maximum width. Would love to hear different approaches to growing and shrinking the thread pool and handling things like marking a given executor as likely in a bad state (usually meaning the app it's talking to over AX API is blocking it's main thread) In the AccessibilityElement project https://codeberg.org/SpeakUp/AccessibilityElement for my HIServices Observer implementation I'm exposed to a race condition where axobserver doesn't flush it's notification queue on remove. I'm relying on pthread_specific currently to introduce thread local storage to work around this but it's quite clunky. In an ideal world the HIServices API would emit a done event to allow cleanup but so far that hasn't happened. I'll leave it there for now and do new posts with more requests for feedback if this one is well received.

Hi, Platforms state of the union shows the following code: defer { await? log.close } Note: I understand await but await? seems new. Questions Is await? (question mark seems new) a new concept? What does it mean? Or is the question mark a typo?

What resources can assist translating Objective-C to Swift? Perhaps best practices or patterns? Can a coding agent automate translating Objective-C to Swift?

I would like to learn Xcode programming on MacOS. I was wondering if anyone knows of a step by step method. Where I can learn one command at a time but also all the nuances and syntax and instances for that command (function). I see a lot of tutorials for iOS programming but I would rather start and end with MacOS, but anything helps. I would like immersive instruction like what you would find in a cad classroom.

Is std::move_only_function or std:execution planned for an upcoming Xcode/libc++ release? The C++ compiler support page indicates that it is not currently implemented (Apple developer forums won't let me share a link to this page). Is the planned support for Xcode/libc++ published anywhere? If not, is there any particular release that I should be watching out for?

I've created a Julia interface for Apple Accelerate's libSparse, via calling the library functions as if they were C (@ccall). I'm interested in using this in the context of power systems, where the sparse matrix is the Jacobian or the ABA matrix from a sparse grid network. However, I'm puzzled by the performance. I ran a sampling profiler on repeated in-place solves of Ax = b for a large sparse matrix A and random dense vectors b. (A is size 30k, positive definite so Cholesky factorization.) The 2 functions with the largest impact are _SparseConvertFromCoordinate_Double from libSparse.dylib, and BLASStateRelease from libBLAS.dylib. That strikes me as bizarre. This is an in-place solve: there should be minimal overheard from allocating/deallocating memory. Also, it seems strange that the library would repeatedly convert from coordinate form. Is this expected behavior? Thinking it might be an artifact of the Julia-C interface, I wrote up a similar program in C/Objective-C. I didn't profile it, but timing the same operation (repeated in-place solves of Ax = b for random vectors b, with the same matrix A as in the Julia) gave the same duration. I've attached the C/Objective-C below.profiling-comparison.m.txt If you're familiar with Julia, the following will give you the matrix I was working with: using PowerSystems, PowerNetworkMatrices sys = System("pglib_opf_case30000_goc.m") A = PowerNetworkMatrices.ABA_Matrix(sys).data where you can find the .m file here. (As a crude way to transfer A from Julia to C, I wrote the 3 arrays A.nzval, A.colptr, and A.rowval to .txt files as space-separated lists of numbers: the above C/objective-C reads in those files.) To duplicate my Julia profiling, do pkg> add AppleAccelerate#libSparse Profile--note the #libSparse part, these features aren't on the main branch--then run using AppleAccelerate, Profile # run previous code snippet to define A M, N = 10000, size(A)[1] bs = [rand(N) for _ in 1:M] aa_fact = AAFactorization(A) factor!(aa_fact) solve!(aa_fact, bs[1]) # pre-compile before we profile. Profile.init(n = 10^6, delay = 0.0003) @profile (for i in 1:M; solve!(aa_fact, bs[i]); end;) Profile.print(C = true, format = :flat, sortedby = :count)

Does anyone know if there will be a Swift 6 version of "The Swift Programming Language" book and if so, when it will be released for Apple Books?

Hello, I was wondering about the timeline for C23 library features being added to libSystem, specifically the %b printf format specifier for binary output. Currently, printf("%b\n", 42) on macOS just prints b rather than the expected binary representation. This and other C23 library additions would be great to have. Are there plans to include these in an upcoming release? Thank you.

I'm keeping most information in an actor and I would like to save also a closure in it that I get from func application( _ application: UIApplication, handleEventsForBackgroundURLSession identifier: String, completionHandler: @escaping () -> Void) Task.init{ await GeoreferenceQueue.shared.setBackgroundCompletionHandler(completionHandler) } } where GeoreferenceQueue is and actor, while the caller is a class. yet I receive error: Passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure and Sending task-isolated 'completionHandler' to actor-isolated instance method 'setBackgroundCompletionHandler' risks causing data races between actor-isolated and task-isolated uses

I have this simple piece of code that of course correctly ran in Swift 5: func geoRegion()-> CLRegion?{ guard let location=referenceLocation else{ return nil } return CLCircularRegion(center:location.coordinate, radius:50000, identifier:"georeferencing") } func placemarksForAddress(_ address: String) async throws -> [CLPlacemark]?{ if let placemark=placemarkCache[address]{ if placemark.location!.distance(from: referenceLocation!)<100000{ return [placemark] } } do{ guard let geoRegion=self.geoRegion() else { return nil } let placemarks = try await georeferenceQueue.geocodeAddressString( address, in: geoRegion) if placemarks.count>=0{ self.placemarkCache[address]=MKPlacemark(placemark: placemarks[0]) return placemarks } } catch { let placemarks=try await self.placemarkForLocation(referenceLocation) return placemarks } return nil } That now presents error: Sending task-isolated 'geoRegion' to actor-isolated instance method 'geocodeAddressString(_:in:)' risks causing data races between actor-isolated and task-isolated uses

I'm using that repeating timer for processing information repeatedly: actor RepeatingTimer { private var task: Task<Void, Never>? private var isPaused = false func start(duration: Double, onTick: @escaping () -> Void) { task?.cancel() // Cancel any existing timer isPaused = false task = Task { while !Task.isCancelled { // Check if paused if !isPaused { onTick() } // Sleep for the interval try? await Task.sleep(for: .seconds(duration)) } } } func pause() { isPaused = true } func resume() { isPaused = false } func stop() { task?.cancel() task = nil } }` Yet when I call it from another actor with: await timer.start(duration: interval, onTick:{ self.process() }) I get: Sending 'self'-isolated value of non-Sendable type '() -> ()' to actor-isolated instance method 'start(duration:onTick:)' risks causing races in between 'self'-isolated and actor-isolated uses Is there some more stable option for managing repeating timers, or how to solve this error?

During refactoring of an app I made a typo which leads to a misleading error message in Xcode 26.4. I could reproduce it with a small sample code in Swift Playground. Is it a bug which should be reported? Details: I have an array containing two strings. Using a ForEach loop is fine: ForEach(appData.dataArray, id: \.self) { value in Text("\(value.subject)\t\(value.room)") } but with a typo in the Text line I got an error on the ForEach line: ForEach(appData.dataArray, id: \.self) { value in --> Cannot convert value of type '[MyArray]' to expected argument type 'Binding' Text("\(value.subject)\t\(value.subject.room)") } Complete sample code from Swift Playground (macOS 26): import SwiftUI class MyArray : Hashable, Equatable, Identifiable, ObservableObject, Codable { let id = UUID() @Published var subject: String @Published var room : String private enum CodingKeys : String, CodingKey { case subject case room } init(subject : String, room : String) { self.subject = subject self.room = room } func encode(to encoder: Encoder) throws { var container = encoder.container(keyedBy: CodingKeys.self) try container.encode(subject, forKey: .subject) try container.encode(room, forKey: .room) } required init(from decoder: Decoder) throws { let container = try decoder.container(keyedBy: CodingKeys.self) subject = try container.decode(String.self, forKey: .subject) room = try container.decode(String.self, forKey: .room) } static func == (v1: MyArray, v2: MyArray) -> Bool { let result = v1.id == v2.id return result } func hash(into hasher: inout Hasher) { hasher.combine(id) } } public class AppData : ObservableObject { @Published var dataArray : [MyArray] = [] init() { dataArray.append(MyArray(subject: "Foo", room: "Bar")) dataArray.append(MyArray(subject: "Foo", room: "Batz")) } } struct ContentView: View { @EnvironmentObject var appData : AppData var body: some View { ForEach(appData.dataArray, id: \.self) { value in Text("\(value.subject)\t\(value.subject.room)") // to fix the error replace value.subject.room with value.room } } } @main struct MyApp: App { var appData = AppData() var body: some Scene { WindowGroup { ContentView() .environmentObject(appData) } } }