SwiftUI List performance

XcodeRead - Read files from the project XcodeWrite - Write files to the project XcodeUpdate - Edit files with str_replace-style patches XcodeGlob - Find files by pattern XcodeGrep - Search file contents XcodeLS - List directory contents XcodeMakeDir - Create directories XcodeRM - Remove files XcodeMV - Move/rename files BuildProject - Build the Xcode project GetBuildLog - Get build output RunAllTests - Run all tests RunSomeTests - Run specific tests GetTestList - List available tests XcodeListNavigatorIssues - Get Xcode issues/errors XcodeRefreshCodeIssuesInFile - Get live diagnostics ExecuteSnippet - Run code in a REPL-like environment RenderPreview - Render SwiftUI previews as images DocumentationSearch - Search Apple docs and WWDC videos XcodeListWindows - List open Xcode windows The above is a list of MCPTools exposed by Xcode. Im am interested in the DocumentationSearch Tool . Here Xcode is able to search only Apple Docs. Lets say i am using a custom .xcframew

Part 2... Does this indicate a specific alignment restriction, memory fragmentation, or a resource conflict on Apple Silicon? No, I don't think anything like that is going on. Synchronization for Memory Visibility: To ensure that the virtual address mapping established in UserMap... is globally visible across all CPU cores and execution contexts before the kernel issues the first Bundled Task, are there recommended synchronization primitives or Memory Barrier calls? No, I don't think any special synchronization is required. If you're tracking the buffer through a direct pointer, then the relative gap between UserMapBundledParallelTaskCommandAndResponseBuffers and the first possible call to BundledParallelTaskCompletion is so large that any kind of synchronization is unnecessary. This is also a fine reason to not bother holding/freeing the IOMemoryMap— if you never free your buffer pointer, then its values will only EVER be NULL (uninitialized) or its valid value (post initialized). The more I think about this

Part 1... However, a subsequent call to ivars->fResponseMap->GetAddress() returns NULL (0x0). Subsequent call when? The expectation (and what our driver does) is that you'd immediately call GetAddress() and then basically never look at the map again. In one of our drivers, that never is quite literal. The code is basically: IOMemoryMap *memoryMap = NULL; if ( parallelCommandIOMemoryDescriptor->CreateMapping(0, 0, 0, 0, 0, &memoryMap) == kIOReturnSuccess ) { ivars->fCommandAddress = memoryMap->GetAddress(); } ... if ( parallelResponseIOMemoryDescriptor->CreateMapping(0, 0, 0, 0, 0, &memoryMap) == kIOReturnSuccess ) { ivars->fParallelResponseAddress = memoryMap->GetAddress(); } ...and, yes, that code leaks two IOMemoryMap's. I don't know what the exact thinking was, but I suspect they realized that the only reason that mapping would ever become invalid/useless was because the driver was being torn down, so freeing doesn't really matter. I'll admit, there is a certain charm to tha

Thank you for your question. I recommend providing a focused sample project, such as the image Image(“playerJersey_red”), which we will all be missing. I will need to replace it with a different image. Regarding the dropDestination cellContent, I understand that you define it, but it would be beneficial to have a sample that can be executed quickly and shared with others for verification. I think it is possible to have a view enabled as a drop destination but disabled as a draggable source based on certain conditions. The issue you're encountering with the .disabled modifier affecting both dragging and dropping could be because it disables all user interactions for the view. Instead, you should conditionally apply the .draggable modifier only when there is a player available? Use content.player.map { $0 } to provide a value only when player is not nil. This makes the view draggable only if a player exists and should keep the .dropDestination modifier without any conditions since you want all cells to be valid

Figured out the implementation! For anyone interested in implementing in IOS 26+ @Namespace private var namespace @State private var presentDialog: Bool = false and in the toolbar ToolbarItem(placement: .cancellationAction){ Button(role: .destructive) { presentDialog = true } label: { Text(Delete) } .confirmationDialog( Delete?, isPresented: $presentDialog, titleVisibility: .visible ) { Button(Delete, role: .destructive) { // perform delete } Button(Cancel, role: .cancel) { } } }

Hi Ziqiao, The important detail is step 3 - the user hasn't even opened Device B in weeks so that device is totally out of the loop. It's unaware of any deletions (or any changes at all) that have happened since step 1. Everything was synchronized initially, but then the user starts deleting items on Device A, which get synced up to iCloud. Meanwhile, back on device B, the app has been left unopened for weeks. When the user opens it up, they'll get .changeTokenExpired, and I'll fall back to the unify logic, the same behavior we use the first time this device syncs. I'm really confused about how deleted record ID's work. For my use case, it doesn't matter which device the record was created on - any device that has had a long delay between fetches such that it needs to do a full fetch will need a list of everything that was deleted on the server since the last fetch. For example, a user initially creates a record on Device A, syncs it to iCloud, Device B fetches. Later on, the user removes it on Devic

@DTS Engineer Thanks a lot for the detailed explanation — that makes sense. It seems that when migrating directly from ObservableObject to @Observable, extra care is needed around update ordering and intermediate states. In my case, this behavior leads to unexpected UI results, such as the scroll position ending up in an incorrect state (as shown in the screenshot above). I can consistently reproduce this on a real iPad Pro (M4) running iOS 26.2.1, where the UI visually jumps and then settles at an unintended position. I’ll need to adjust my approach to work around this behavior. I’d also be very interested to hear more from the SwiftUI team on the intended patterns or best practices for avoiding these intermediate states in UI code.

This is a very interesting question, and you've done a great job of isolating the behavior and providing comparative examples. I’m not an expert on SwiftUI, wish I knew better, but that technology was always being really good at what you're seeing this double update with @Observable and @State, especially in conjunction with GeometryReader. When @Published properties change, they emit events. Views that are observing these properties (via @StateObject or @EnvironmentObject) then get scheduled for re-evaluation. The update cycle is generally more straightforward: state change -> event -> view re-render. filteredAlbums id: [3878E7A7-CDAB-444F-8B8C-263763735770, 1, 2, 3, 4, 5, 6] filteredAlbums id: [1, 2, 3, 4, 5, 6] You've triggered two state changes almost simultaneously: albumStore.addAlbum(newAlbum): This is a change to a property managed by your @Observable AlbumStore. albumToAdd = newAlbum: This is a change to a @State property within your view. Your carousel() function reads from albumStore

Oh, and I forgot to mention a couple of random caveats for the old hardware model technique I explained in the previous post: By bringing up a new OS on an old hardware model VM, you miss out on various features. Indeed, that’s kinda the point, in that you want to ‘miss out’ on the new-style provisioning UDIDs. However, there are other features, like using iCloud, that you might actually miss. And it’s not hard to imagine that list growing in the future. And speaking of the future, there’s no guarantee that this technique will work forever. I can imagine a world where a macOS NN guest simply won’t run on older hardware model VMs. Or that a old hardware model might stop being supported by the macOS host. You can detect the latter with isSupported, but the former is likely to result in either the OS failing to install or the OS not booting once it is installed. So, your default path should be to create your VM in the standard way, as illustrated by the Running macOS in a virtual machine on Apple silico

Thank you for your reply! I understand now, and was able to fix our code. I’d read the documentation page too quickly and misunderstood what it was saying exactly. It's pretty interesting that you need to read the environment not from within the row view, but from a descendant of it. For anyone else reading this, here’s some additional tests that helped me understand exactly the required setup. The third row especially (ListItemThinWrapper) seems to suggest you should be thinking in terms of resolved views, or something like that. struct ProminentBackgroundInList: View { var body: some View { List(selection: .constant(Set([0, 1, 2, 3]))) { ListItem().tag(0) // doesn't work ZStack { ListItem() // works }.tag(1) ListItemThinWrapper().tag(2) // doesn't work ListItemStackWrapper().tag(3) // works } } struct ListItem: View { @Environment(.backgroundProminence) var backgroundProminence var body: some View { HStack { Image(systemName: person.fill) .foregroundStyle(backgroundProminence == .standard ? .orange