SwiftUI Foundations: Build Great Apps with SwiftUI Q&A
Direct answers from Apple Engineers
Recently, Apple returned to the webinar format, where engineers answer developers’ questions directly while hosts cover different parts of a topic.
This time it was SwiftUI foundations: Build great apps with SwiftUI. If the previous session about “Coding Agents in Xcode” lasted 16 minutes and had only 3 questions, this one was completely different. It ran for more than 3 hours (!) and included over 100 questions.
But! The questions were not always tied strictly to the session topic. You’ll also find discussions about Concurrency and SwiftData.
Even formatting and gathering the session questions took hours for me, so this is truly unique content. Grammar and punctuation were slightly adjusted, but the authors’ formatting was kept as is.
And without further ado — here’s the session Q&A.
💾 SwiftData & Backend
Do you think it would be possible to write a ModelContainer targeting a backend other than iCloud, such as Firebase, and still be compatible with SwiftData framework annotations?
This is such an awesome question, the answer personally is I do not know, but would love to try to see if can be done, I think it is possible to write a ModelContainer targeting a backend other than SwiftData, however Firebase is a 3rd party framework so we can’t provide compatibility with SwiftData framework. SwiftData provides a way to abstract the backend and focus on defining models and relationships.
Start by defining your SwiftData models with the necessary annotations to specify relationships and attributes. Configure the ModelContainer to use your chosen backend.
It sounds like you can try to make it work In your application, configure the ModelContainer to use Firebase as the persistent store but then will not be store in SwiftData. You can now perform CRUD operations on your models using SwiftData, leveraging the backend of your choice, but I do not work if that can work. I would love to see that working, personally.
Implement synchronization and conflict resolution mechanisms between SwiftData and your backend sounds like a hard project. This may require additional configuration or logic tailored to your use case. While challenging, I believe the customization and migration could way too complex. Migration is the key word and being able to work in the future versions.
Does SwiftData support data virtualization for large row counts to avoid loading all items
SwiftData Query doesn’t currently support partial fetching. When rendering a large SwiftData dataset, consider using FetchDescriptor with appropriate predicates to paginate the data so you only load the data of the current page.
Can the sorting option in Swift Data queries take a user sort preference from @AppStorage?
Yes, SortDescriptor is codable, and so you can definitely persist a sort descriptor to AppStorage, or other kind of storage, and then retrieve it from the storage when needed, and use it with a SwiftData query.
What if I want to store the sort property per trip, so each different trip’s sort setting is preserved
In that case, If your trips grow unbounded you might want to consider persisting the sort options in your data model using SwiftData.
SwiftData and SwiftUI....I’ve found using @Model and @Query a reliable and easy to use approach for simple CRUD operations for a view. Is this the first go-to recommendation for implementing SwiftData in SwiftUI apps, when basics only are needed?
That’s correct. You can start with @Model and @Query. If you have questions when going deeper, consider asking in the Developer Forums.
🪟 SwiftUI Views & Layout
Is List backed by UICollectionView? What is the most “CollectionView”- like View for SwiftUI?
List is the most “CollectionView”-like View for SwiftUI.
Given a list of cards that are mixed media (list of text rows, images, charts). Should you use Collection, List, ScrollView, or something else?
It’s possible you would need all of them! for direct answers that are relevant to your project, I would make a post on the developer forums and link your code.
What happens with a ViewThatFits when no option actually fits? Does it render neither?
Are you talking about https://developer.apple.com/documentation/swiftui/viewthatfits ?
If a ViewThatFits option in SwiftUI does not find any view that fits within the specified size constraints, it typically renders nothing. This behavior is designed to conserve space by not displaying any content if no suitable view can be accommodated. The ViewThatFits view automatically adjusts its layout based on the available space, but when no view fits, it simply does not render. Check the link I sent you as the documentation is pretty good at how ViewThatFits works.
And check the sample code in the doc https://developer.apple.com/documentation/swiftui/viewthatfits
What might cause Text to sometimes be truncated? Using .fixedSize(horizontal: false, vertical: true) seems to always fix this issue. Is it due to ambiguous layout?
It might not have a frame large enough to contain the content until you give it one. You can share the code and project on the forums to get input from engineers around the world. See here https://developer.apple.com/forums/
Silly question, for adaptive views why cannot I use ZStack over .overlay() or .background()?
I don’t know what you mean, can you provide an example? Oh sorry use the forums to provide the example as will be a better answer if we can see what you are trying to accomplish as using ZStack over .overlay() or .background() for adaptive views isn’t necessary because both ZStack and these modifiers are part of SwiftUI’s declarative layout system and can work seamlessly together to manage stacking and overlaying of views.
Please provide your sample at the apple forums https://developer.apple.com/forums/
What is the best way to make a view inside a ScrollView at least the content size of the ScrollView itself and then it’s scrollable if larger than that. (Ex. I want to centre some empty/error state text).
To achieve this effect, you’ll want to ensure that the view inside the has a minimum height equal to the height of the itself and grows if the content exceeds this size. With GeometryReader once outside the to capture the device’s screen height available for scrolling, and once inside to measure the content height. This setup will ensure the text is centered and the view is scrollable if the content exceeds the default screen/scrollable area height.
I can’t write code in chat very well, but something like that?
GeometryReader { geometry in
ScrollView {
VStack {
Spacer() Text("test test.")
.multilineTextAlignment(.center).padding()
Spacer() }
}
}🔷 Observable & State Management
Question about project from webinar
Why is Trip and Activity a class? I would have made them structs and only decorate DataSource with @Observable.
You can only place @Observable with a class (not struct). This is because the @Observable macro is designed specifically for reference types (class) to enable observation of property changes. For value types like struct, you should use @State in your view to manage data changes, as structs are designed to be copied rather than shared.
To rephrase my question from earlier. I understand, that only classes can be annotated with @Observable. My question was more pointing towards why you chose class also for Trip and Activity in the sense of that DataSource is already observable, so all its properties are. Or am I getting it wrong?
For the sample code, this allowed to pass the objects to views as references instead of copies, so that they could be mutated in place (when editing a Trip, adding activities to a trip, or marking an activity as completed). This made it so we wouldn’t need to mutate the whole model when a change was made.
Will @StateObject be updated to work with @Observable class without needing to conform the class to Combine’s ObservableObject protocol? We can’t use @State because it leaks heap memory, i.e. it inits a new initial object on every View init. And using optional State that’s init .onAppear is a painful
If the object is created in View init and set to a @State property via State(initialValue:), the new object instance is expected to be immediately freed if the view’s identity didn’t change, so leaking heap memory is not expected, and the leak might have been caused by other reasons like retain cycles. If there are concerns to create the @Observable object many times, an alternative would be to create the object higher up and pass it down to this view via a parameter in the init or via the environment.
@Environment causes all views that contain it to update? So it is hard to make the views that use it stable? Any and every change causes all views to update ... Correct?
@Environment in SwiftUI causes views containing it to re-evaluate their state when the associated value changes.
If the environment value changes frequently or across the app, consider using or directly within the relevant view hierarchy to encapsulate logic and data handling. Use conditional rendering to avoid unnecessary re-renders.
Yes they cause to update but while provides a powerful mechanism for data sharing, manage its usage carefully to maintain UI stability and responsiveness. By leveraging SwiftUI’s declarative nature and state management capabilities, minimize unnecessary re-renders and ensure a smooth user experience.
Main benefit it to be used to share state objects accessed by multiple views.
Can you subclass an @Observable object so that parent and child would have the macro? Example:
@Observable
class Trip {}
@Observable class ExtendedTrip: Trip {}Are you talking about the sample or in general on SwiftUI? You can subclass an in Swift to create a custom observable object that can be used across the view hierarchy. This allows you to encapsulate your data and logic in a way that can be observed by any views that depend on it.
This pattern allows you to encapsulate your data and logic in a reusable observable object that can be shared across different views in your SwiftUI app. Like this?
@ObservedObject var observableObject: CustomObservableObjectIn SwiftUI lists, should item model be value types (struct) and rely on parent ViewModel updates, or reference types (Observable/ObservableObject) so each row can update independently? What’s the recommended trade-off for performance and architecture?
This question is being answered in the current session. Please tune into the live Data Flow session to learn more.
The answer is… it depends! Use structs when your data is of a value type, and use class when your data contains reference types. When using a class, you typically make it Observable, so a change on the data can update related SwiftUI views.
I want to ask a quite basic question. If we are creating a model we should always be using class instead of struct? And there is no such thing as “View Model” then?
You normally use struct when your data is of a value type, and use class when your data contains reference types. When using a class, you typically make it Observable so a change on the data can trigger relevant SwiftUI updates.
I have an ObservedObject with Published Properties associated with a View. This is extended into 3 ObservedObjects conforming to a common Protocol. But the properties of the protocol would actually be Published Properties, which is not possible? Can we define a Protocol with such properties?
Swift doesn’t allow adding a stored property to a protocol extension, so if you tend to add published properties to a protocol extension so the types conforming the protocol automatically gain the properties, you can’t do so. You might consider using an Observable class instead. For more information, see mentioned in the following doc.
Could you explain the difference and why using let and var inside Views. It looks like with let the whole View is redrawn when the value change in the caller View.
When developing SwiftUI views, understanding the differences between and is crucial for efficient view updates and correct behavior. Let: Creates a constant value that cannot be modified after initialization. Var: Allows properties to change over time, triggering view updates.
Use let for stable values that do not change during view updates, ensuring predictable view behavior. Dynamic data in SwiftUI can be managed using var with @State for interactive or changing data, enabling reactive UI updates.
Mastering let and var in SwiftUI views is crucial for efficient, responsive user interfaces. Use let for immutable data and var with @State for mutable state
I would recommend to post this question into the forums as the basics of let and var in the views is probably not enough for you.
Visit Apple Developer Forums here: https://developer.apple.com/forums/
🚏 Navigation
How did you migrate from UIKit to SwiftUI specifically in navigation? Did you have a coordinator patter?
It depends on what exactly you’re trying to achieve here. The coordinator patter works as one way to handle navigation but it’s not required. The best thing to note, is that if you’re in UIKit UINavigationController you will want to use the standard push/present calls and present a UIHostingController. And inside a SwiftUI context you will want to use SwiftUI presentation. Mixing the navigation stacks can have unintended consequences. If a coordinator patter helps manage that, that works perfectly but you can also just call the views directly depending on the complexity of the UI and what fits best.
Migrating from UIKit to SwiftUI has two major difficulties, and they are not on View, it’s navigation and database. Do you have a presentation or a study case for this? How to move from segue navigation to SwiftUI? How to move from Core Data context to Swift Data?
A great video for that and resource I like is: https://developer.apple.com/videos/play/wwdc2023/10189/
Migrating from UIKit’s segue-based navigation to SwiftUI’s navigation system involves understanding the differences between the two approaches and adapting your navigation logic accordingly.
To migrate to SwiftUI, you’ll need to create a SwiftUI view that represents the same flow. Instead of using a navigation controller, you’ll use SwiftUI’s navigation views.
Also this is my go to https://developer.apple.com/documentation/swiftui/building-a-document-based-app-using-swiftdata
Bring core data to swiftUI https://developer.apple.com/videos/play/wwdc2021/10017/
And remember to model your data https://developer.apple.com/videos/play/wwdc2023/10195/
I am not an expert in SwiftData so I would recommend to ask that question and be specific of what you want migrate in another question for our expert to pick up.
How can we best provide async navigation links? This seems to be a fundamental requirement. I built a custom built AsyncNavigationLink that overlays a button on a NavigationLink, triggers an async call, overlays a ProgressView(). The async call triggers the NavigationLink. Is this the best way?
NavigationLinks themselves can’t be responsible for asynchronous handling. The destination view can have a ProgressView and react to asynchronous changes to your model. But, since NavigationLink is a view itself, it needs to be processed on the main actor. If you want to present the ProgressView before moving to the new view, you can make a Button that triggers the asynchronous callback, and then update your navigation path (that you can set with NavigationStack(path: $path)) when it is finished. This will use the .navigationDestination(for:) modifiers to decide the views to move to. Not sure if this entirely answers your question (
Navigation in Swift is one of the topics I’ve struggled with for a while. Whether using NavigationDestination or building your own Router to navigate. What is your recommendation for doing such, especially when you have multiple views that you want to push? Any suggestions?
The developer website has tons of documentation on recommended navigation styles: See https://developer.apple.com/documentation/swiftui/bringing-robust-navigation-structure-to-your-swiftui-app and https://developer.apple.com/documentation/swiftui/navigation
🛠️ UIKit & SwiftUI Integration
HostingConfiguration or HostingController ? On TableView and CollectionView , what’s best way to wrap SwiftUI code in cells? Is there difference between hosting config and hosting controller?
For wrapping a SwiftUI hierarchy in UICollectionViewCell or UITableViewCell objects, UIHostingConfiguration is the intended class. Please see the documentation for details: https://developer.apple.com/documentation/swiftui/uihostingconfiguration/ UIHostingController is intended to be used more broadly for SwiftUI views in general.
What is the best way to integrate SwiftUI into an existing UIKit App, keeping the performance of SwiftUI Previews high? I can use Swift Package Manager to integrate packages that contain SwiftUI components into the project. Is this the best way or are there simpler paths to go for best speed?
To use SwiftUI views in your UIKit app. See UIKit integration https://developer.apple.com/documentation/swiftui/uikit-integration
I’d like to re-ask the question by Joshua Arnold about resizing with UIViewRepresentable, as the link provided does not give an answer as to how to animate the size change
The reference is at the bottom of the linked page, see Adding UIKit to SwiftUI View Hierarchies https://developer.apple.com/documentation/swiftui/uiviewrepresentable#Adding-UIKit-views-to-SwiftUI-view-hierarchies
You can also post your code, images and more on the forums to receive direct help https://developer.apple.com/forums/
When using UIViewRepresentable, is it possible for the UIView to internally resize itself, and have SwiftUI animate the change in size? If I call invalidateIntrinsicContentSize() on the view, SwiftUI resizes the view immediately without an animation.
You must communicate size changes back to SwiftUI state for animations to work. For info how see Adding UIKit views to SwiftUI view hierarchies https://developer.apple.com/documentation/swiftui/uiviewrepresentable
What is Apple’s recommended approach for detecting when a UIHostingConfiguration / ContentView changes size internally? If I update the a UIHostingConfiguration with a larger view, the view will just truncate / clip instead of bubbling up to UIKit to resize itself.
When working with a hybrid UIKit and SwiftUI environment, SwiftUI views may change size internally without automatically updating their containing UIKit views. This is because SwiftUI views are declarative and may not notify UIKit of size changes beyond their initial setup. To address this, you can use SwiftUI view modifiers and UIKit mechanisms to propagate size changes.
GeometryReader to read the current size of a SwiftUI view and communicate changes back to UIKit.
I would personally wrap a SwiftUI view in a UIViewRepresentable and use a coordinator to listen for size preference changes and update the UIKit view size accordingly.
in a UIKit view controller or view to adjust the layout so observe notifications if possible
Visit Apple Developer Forums here: https://developer.apple.com/forums/
🔷 ScrollView & Visibility
Is there any further documentation or reliable ways to know if something is actually visible on screen? Based our experiences, onAppear in VStack in ScrollView, List, and LazyVStack all have different onAppear behaviors for their elements.
Please check out the .onScrollVisibilityChange modifier.
Is there a suggested way to determine the difference between .onAppear being called in a ‘forward’ transition vs a ‘return’ transition? i.e. list displayed vs returning to list from details view.
Yes, it is possible to differentiate between when .onAppear is called during a forward transition versus a return transition in SwiftUI, though it requires some manual state management since SwiftUI itself does not provide built-in distinction for these cases directly within .onAppear. I got some sample code so you can provide a more detailed information about your question.:
.onAppear {
if appearedOnce {
print(”Main View reappeared (back navigation)”)
} else {
print(”Main View appeared (forward navigation)”)
appearedOnce = true
}
}If I have a database with 100k+ rows, how do I manage paging/infinite scroll in SwiftUIs “List”, to manage memory appropriately. Similar to UITableViews prefetch handler.
Similar the the VStack and HStack shown on stage, there is a LazyVStack and LazyHStack which automatically allocate and deallocates views as they are needed on screen. For more info see “Creating performant scrollable stacks“: https://developer.apple.com/documentation/swiftui/creating-performant-scrollable-stacks
🦋 Animation & Effects
For the symbolEffect(_:options:value:) method for SF symbols, the animation only runs when the value changes. Is there a way to implement this behavior (only run something once for each unique value) idiomatically in SwiftUI?
Depending on the use case, this might not require explicit treatment to run an animation (e.g. the animation(value:) modifier might be all you need). But if you do need to perform side effects based on value changes, onChange(of:...) might be right to reach for.
I’ve added an animation to a Button but when it’s placed inside a NavigationStack’s ToolbarItem, the animation doesn’t run. When the Button is used elsewhere, the animation works as expected. Can you share how to use this animating Button inside a .toolbar?
This is a good question for the forums. Given a Button inside a .toolbar { } modifier, we’d need to see a fuller code sample to know things like where the animation is declared.
How can I start an animation after another animation? (without using hard coded durations)
A KeyframeAnimator or PhaseAnimator can be used for more complex animations! In KeyframeAnimator, for example, you can have separate steps in a KeyframeTrack, and separate tracks in a KeyframeTimeline. Helpful docs: https://developer.apple.com/documentation/swiftui/controlling-the-timing-and-movements-of-your-animations https://developer.apple.com/documentation/swiftui/keyframetimeline
⛏️ Modifiers & Customization
Is it possible to write modifier functions that can configure a custom view property even if it is contained in other container views? This would be similar to how .font works, in that it can be applied to a view and any contained Text will be reconfigured?
One possible way to achieve this is to use a type such as Group that can create a collection of views, such that its modifiers apply to all of its member views: https://developer.apple.com/documentation/swiftui/group
UIKit is inheritance-driven, so it is possible to subclass an UIButton, for example. The same is not possible with SwiftUI. What is the recommended alternative for a similar approach (mainly to customize appearance)? Style, viewModifiers, custom view, something else?
Custom view modifiers are one way in which you can reuse multiple view modifiers across different views. You can even extend the View protocol with a function that applies your custom modifiers. Check out “Reducing view modifier maintenance” for how to do that.
https://developer.apple.com/documentation/swiftui/reducing-view-modifier-maintenance
Is it possible to add a view modifier for the text width and set it to expanded as well as making it italic? The following code does not work, and italic is only applied if the width is .standard:
.font(.caption2.width(.expanded).italic())
.fontWeight(.bold)
.frame(maxWidth: width, alignment: .leading)
.italic(italic)Something like that too: .font(.caption2)
it is possible to combine text width and italic styling in SwiftUI using a custom view modifier. The issue with your current code is that the modifier in SwiftUI does not support applying both and modifiers directly in a combined way like you’re attempting. Instead, you can create a custom view modifier to achieve this behavior
If I put it together should be something like:
content .font(.caption2) .fontWeight(.bold).frame(maxWidth: width, alignment: .leading) .italic(italic)Disclamer I didn’t test it, but I think is the idea.
Allows you to flexibly adjust the text’s width and apply italic styling independently within a single view modifier.
What’s the best approach to building modifiers in SwiftUI? I am specifically interested in how to handle the inert state. Is it better to apply the modifier conditionally depending whether it’s inert state or not. Or is it better to deal with the sate inside the modifier implementation.
Generally, try to avoid conditionally applying modifiers (specifically when the condition can change at runtime). It is better to handle an “inert” state from within the modifier. If you have a specific question about building a modifier that handles some state, feel free to send a question for that as well!
🔎 Performance & Debugging
I’m trying to debug a log about “Attribute Graph Cycle”. I’ve tried instruments, but it’s hard to identify the source. In my case, I think it has to do with frames/geometry negotiating sizes. I don’t notice a major slowdown - Is this even a problem?
Check if you have a custom layout or onGeometryChange that could be affecting your View’s sizing. Instruments can help show the catalyst of an update (through the Cause-and-Effect graph). Hitting a cycle may lead to unexpected behavior (aside from just performance issues/hangs), so it is still important to identify if you can. If you don’t see anything in your program that could be causing a loop, consider filing a bug report on Feedback Assistant!
Is there a way to see SwiftUI’s dependency graph for a view, so we can figure out whats causing excessive updates etc? Is instruments the best way to do this?
Instruments is the best way to figure out what is causing excessive updates and other issues with performance. Check out “Optimize SwiftUI performance with Instruments” for a lot of great information about SwiftUI and how to use Instruments to profile and optimize your app.
Can we see the view’s dependency graph in Xcode? Via debugging?
If you profile using SwiftUI template in Instruments, it shows you information such as long view body updates, cause-and-effect graph, update groups etc. please review the Understanding and improving SwiftUI performance article to learn how to use instruments to understand and debug your SwiftUI Views.
When is it better to extract a view into a separate ViewBuilder function/computed property versus creating a separate struct View? What are the performance implications of each approach?
Extracting your views into a separate view structs is a good way to, reduce dependencies to only those that matter to the view. This makes your code easier to read, and your dependencies become apparent at its use site. Ultimately you want to use your best judgement here because not every dependency deserves to be scoped to a separate view struct.
When views are scoped to separate view struct, try reducing view values to only the data they actually depend on. This could mean fewer updates and that implies better performance when data changes in your app.
During SwiftUI view reordering or layout updates, what typically causes temporary disappearance of views, and how can state consistency be preserved during rapid UI changes?
Having views temporarily disappear isn’t typical. Check out the tips in “Optimize SwiftUI performance with Instruments” to determine if there are some performance issues or tuning that you can do to improve the view. If that doesn’t help, please post your specific issue on the Developer Forums for more assistance.
One of the great things I find in working with SwiftUI is that you can build most of your app staying in Xcode with Preview. I loved the last section about using print in view, but it is only at runtime. Is there a library that let you use a debug overlay modifier to display debug data in a view?
You can output into a Label? And there are many views where output is allowed. But the NSLOG is a way to go to the console. You can add a GeometryReader within a view’s .overlay()
SwiftUI provides a convenient way to display debug data
There is a video that may help you: WWDC23: Debug with structured logging
I would recommend this doc as well https://developer.apple.com/library/archive/documentation/UserExperience/Conceptual/AutolayoutPG/DebuggingTricksandTips.html
Are there tools for diagnosing layout issues? On macOS, my app behaves very strangely, growing the window arbitrarily even though subviews’ sizes aren’t changing.
Hi, you might find the following guide helpful: “Diagnosing issues in the appearance of a running app”.
🏡 Dismissal & Environment
What would be the difference in using the @Enviroment(.dismiss) or making it a binding when dismissing a sheet? Is there performance benefit?
Both and make sheet dismissal in SwiftUI, but they differ in functionality and performance. It is a property wrapper that exposes the modifier applied to a view. It’s often used to dismiss views or sheets from outside their hierarchy, like from a parent view or navigation stack. It is efficient as it doesn’t create additional state or UI components. It simply exposes an existing closure in the view hierarchy, involves defining a closure for dismissal and wrapping it in a . This is useful for more control or integrating with custom views that require explicit dismissal but creating a binding has some overhead, but it’s usually negligible. The impact is minimal compared to other UI operations.
In summary, and are efficient is straightforward for dismissing views from outside their hierarchy, while binding provides more control and flexibility for custom dismissal logic. Performance differences are minimal I think, and the choice depends on your application’s requirements.
🏛️ Architecture & Patterns
Is MVVM organization recommended for a SwiftUI project?
Different apps need different architectures. An app with heavily server-driven content should make architectural decisions specific to that design. An app focused more on displaying data locally (and might not be updating its content as frequently) should use an architecture that makes that use case easier to build for. SwiftUI is architecture agnostic to allow deliberate architectures that work for your app.
When passing in an action into a view is it better to use closure or function/method reference? Example:
SomeView(saveAction: { viewModel.performSave() })
vs
SomeView(saveAction: viewModel.performSave)Great question and thanks for providing the code. What I think is whether to use a closure or a function/method reference when passing an action into a view depends on your specific use case and personal preference. Both approaches have their advantages, and the choice might be influenced by factors like readability, performance, and Swift features. You can capture specific variables from the surrounding context using a capture list if needed, providing more flexibility. It allows for quick inline modifications or additional logic without needing to create a new method elsewhere. Cleaner syntax, especially for simple method calls, improving readability. Potentially more performant since it directly references the function without additional closure overhead?
🐞 iOS Issues & Bug Reporting
Since iOS26, dismissing the keyboard stopped working as expected. If I have a TextField focused in a navigationDestination view or in the content view of a fullScreenCover, and then dismiss the view, the keyboard would sometimes leave a white bar at the bottom in the safeArea. Is this a known issue?
If you come across any visual issues while using SwiftUI, please feel free to file a bug report via Feedback Assistant. Thanks for letting us know about this! https://developer.apple.com/bug-reporting/
🎓 Learning Resources & Miscellaneous
What’s the best way to learn how to use Metal, particularly for visual effects rather than graphics?
This is just my approach, I like to take apart and study sample code. For Metal, there is an entire database of sample code here https://developer.apple.com/metal/sample-code/
Also, please check out the segment on Metal in this talk from WWDC24, “Create custom visual effects with SwiftUI”.
Love to learn more about SwiftUI and Metal - for video rendering would the performance be faster using a custom shader with [[stitchable]] and SwiftUI vs NSView or MkitView?
It depends on the purpose! [[stitchable]] Metal shaders can be used to apply an effect to an existing SwiftUI view via the colorEffect(_:isEnabled:), distortionEffect(_:,maxSampleOffset:isEnabled), and layerEffect(_:maxSampleOffset:isEnabled:) modifiers. If you’re looking for a more flexible view that displays Metal objects (i.e. drawing your own shapes with vertex and fragment shaders), you should probably lean on MTKView. MTKView is provided by MetalKit and can be placed in an NSViewRepresentable or UIViewRepresentable. One is not strictly faster than the other, and you should choose whichever method matches your vision! MTKView: https://developer.apple.com/documentation/metalkit/mtkview SwiftUI Shader: https://developer.apple.com/documentation/swiftui/shader
What do your designers (in Apple) use to design for passing on to developers? Whenever I’ve had designs from Figma, Sketch, Azure, Miro, whatever, they aren’t true to platform and don’t correctly confine the designer to use native components.
This is a good question! It can be hard for design tools to match the fidelity of the look and feel of Apple platforms. Apple provides design resources for Sketch and Figma at https://developer.apple.com/design/resources/ and the materials are adjusted to resemble iOS as closely as possible.
In your partnership with developers, check in with the engineers and ensure that the designs are well understood before they are implemented. It also helps when everyone communicates using the same language, so we recommend that both developers and designers (and even other members of the team) familiarize themselves with the Human Interface Guidelines for the platform your app supports. The Human Interface Guidelines are available at https://developer.apple.com/design/human-interface-guidelines/
I had some trouble finding the entry point of sessions like “Code-along: Start building with Swift and SwiftUI” on the developer website. Is there an entry point where I can navigate thru all the sessions like “code along” and today’s or previous sessions?
Thanks for the question. I recommend to start with this video: https://developer.apple.com/videos/play/wwdc2021/10062, then a code along is always good like: https://developer.apple.com/videos/play/meet-with-apple/237/ and do not forget the what’s new to avoid using the older API https://developer.apple.com/videos/play/wwdc2024/10136/
As an absolute beginner, what would be the first go-to step to go for training? or documentation? on Apple.
A great place to learn how to develop for Apple is through Pathways (https://developer.apple.com/pathways/?cid=ht-pathways), your first step to creating for Apple platforms! For documentation, here is the top-level page: https://developer.apple.com/documentation/
Do you have any advice for someone with Flutter/Dart experience starting SwiftUI?
Thanks for the question. I think we got something similar from someone else, but welcome to Swift coming from Flutter! To start I would recommend to start with this video: https://developer.apple.com/videos/play/wwdc2021/10062/ then a code along is always good like: https://developer.apple.com/videos/play/meet-with-apple/237/ and do not forget the what’s new to avoid using the older API https://developer.apple.com/videos/play/wwdc2024/10136/ But welcome to Xcode! You are going to love it.
Any recommendations for resources (books, WWDC sessions, sample repos, or articles) on doing test-driven development with Swift/SwiftUI—especially patterns for testing view models/presenters and keeping UI code thin?
There’s several WWDC sessions that may be beneficial to you, https://developer.apple.com/videos/play/wwdc2024/10195 and https://developer.apple.com/videos/play/wwdc2019/413
There are tons of modifiers, how we suppose to memorize all of them or even know that they are exists? 😊
The Developer Documentation is always a great place to start! https://developer.apple.com/documentation/swiftui You can also look into bundling your commonly-used modifiers into custom view modifiers- check out “Reducing view modifier maintenance”.
🔷 Wishlist App Specific (App from the webinar)
Where can I download the wishlist app xcode project?
Thank you for your question and attending the event. The sample code for “SwiftUI foundations: Build great apps with SwiftUI” will be made available on the Apple developer website sometime after the event concludes. Stay tuned!
Will the code for Wishlist app be made available?
Thank you for your question and attending the event. The sample code for “SwiftUI foundations: Build great apps with SwiftUI” will be made available on the Apple developer website sometime after the event concludes. Stay tuned!
Why cardsize is provided for TripCard in example of Wishlist struct presented in motion presentation ?
TripCard could either be represented in different sizes, either as a compact or expanded card with a larger width.
I noticed the Wishlist sample app has a customized font in the NavigationBar’s title. Curious how this was accomplished?
For a navigation bar title with styling, you can create a custom view containing a Text with styling modifiers, then wrap it in ToolbarItem(placement: .largeTitle) or ToolbarItem(placement: .title) on the .toolbar.
Is the Wishlist app MultiPlatform for iPhone, Watch, TV, Mac, etc?
Thanks for the question. The app is currently an iOS / iPadOS app. You can run it on macOS and visionOS in Designed for iPad mode.
💬 Text & Fonts
Any recommendations to have a more readable or idiomatic alternative to .frame(maxWidth: .infinity, alignment: .leading)?
Certainly! If you’re looking for a more readable or idiomatic alternative to , it depends on the context and the layout you’re working with. If you’re using Auto Layout, you can define constraints programmatically. This might be more readable if you’re comfortable with constraints, use that. If you have a container view that naturally supports full-width content, you might use a container view to manage the layout. If you need more control over the frame, you might define a custom frame Choose the method that best fits your design system and the constraints of your project. Auto Layout is often preferred for its flexibility and control, especially in UIKit. But I personally like adding a Spacer() into the view!.
I would like to follow up on the question on how to add a different font in the navigationTitle. While it is true, that you can add a styled text to the modifier. The result will will compile but not change its appearance and show an error: “Only unstyled text can be used with navigationTitle(_:)”.
You can create a ToolbarItem(placement: .title/.largeTitle) that is a Text styled with AttributedString.
📐 Geometry & Sizing
What if a subview prefers a bigger HxW than what is offered by the parent view? How are the conflicts handled?
I’d recommend testing this out, then adding other modifiers to build intuition for SwiftUI’s layout system!
struct BiggerChild: View {
var body: some View {
VStack {
Color.orange .frame(width: 200, height: 200) .opacity(0.3)
}
.frame(width: 100, height: 100).background(.purple)
}
}You’ll find that the parent won’t clip the child, and the child will extend beyond the parent. From there, check out the clipShape() modifier.
Is there a canonical way to set .frame sizes that are dynamic to device sizes? For example, .frame(height: oneThirdOfDeviceHeight)? UIScreen? Geometry reader? Is there a preferred approach?
To set dynamic frame sizes in Swift for different devices, you can calculate dimensions based on screen width and a predefined ratio to maintain aspect ratios. The GeometryReader approach is modern and powerful, defining views in terms of available space. For complex layouts, Auto Layout provides flexible constraints that adapt to device sizes. For simplicity and direct access, using or similar methods works well for basic dynamic sizing. For more complex layouts and better responsiveness, Auto Layout is more powerful. Constants and computed properties help keep code organized and maintainable.
I think I understand your question with the frames utilization but please feel free to ask the question again with more details.
I have the following:
LazyVGrid {
ForEach {
VStack {
Image()
Text()
}
}
}Now, because the text of each view differs (sometimes it takes 2 lines, sometimes 1 line and sometimes 3 lines) the views are no longer aligned on a base-line. How can I get the views aligned again at a common base-line.
It could be the way your LazyVStack is deallocating views. I think this would be a great question for the Developer Forums. I encourage you to post this question there so we can more easily share code and others with the same issue can find help for the same issue. Visit Apple Developer Forums here: https://developer.apple.com/forums/
If I have a view thats 50px x 50px, and I want to display many of them in a HStack, evenly spaced so they are edge to edge. Whats the most performant way to achieve this? I’ve been using a “Spacer()” inbetween each, but wondering if thats causing overhead
Best way to see the best perform control is to debug and use instruments to check your UI as has SwiftUI instruments as well. Using between views in an is a common approach, but if you’re concerned about performance due to a large number of views, you might consider a more direct calculation to distribute space evenly. Lately I have been a huge fan of GeometryReader as It is used to get the available width of the parent view. Calculate the total width occupied by the views and subtract it from the available width to get the total spacing needed. Divide this by the number of gaps (which is one less than the number of views).
But Space is really good, I would really recommend you to make Instruments your best friend.
Visit Apple Developer Forums here: https://developer.apple.com/forums/
Any performant alternatives to geometry reader? I have to put a vertically centered textfield, with a helper text below it, but also add pull to refresh, so I have added a scrollview.refreshable, one alternative is to create a manual drag gesture, but can we achieve this using scrollview?
This depends on what you’re trying to achieve. For example, if you’re trying to respond to scroll view changes you should checkout the onScrollGeometryChange, onScrollTargetVisibilityChange, onScrollVisibilityChange
and onScrollPhaseChange API.
📼 Images & Media
I’d like to have a zoomable and draggable image within a scrollview, like you would see in the photos app. Can this be done with SwiftUI?
We can provide information how Apple apps controls work, you can achieve a zoomable and draggable image within a in SwiftUI using the modifiers and the and views.
.gesture( DragGesture() .onChanged { value in
print(”Dragging at: (value.location)”)
}.onEnded { value in
print(”Drag ended at: (value.location)”)
})Other this are ScrollView, creates a horizontal ScrollView without showing the scroll indicator bar.
If I present a series of Image views in a LazyVStack -- Image views that need to be resized. How can I make sure all images get resized to the same width/hight (a common denominator) and don’t end-up looking different?
To ensure consistent sizing of views in a series, explicitly set modifiers on each view to define a specific width and height for all images. Decide if you want to maintain the aspect ratio by using modifiers to control how images fit within their frames. This makes images scalable, sets a fixed size for each image, and clips images that exceed frame bounds for neatness.
Great question for sure! Make sure when displaying a series of views in a and ensuring they all have the same dimensions so you do not need to set constraints.
Visit Apple Developer Forums here: https://developer.apple.com/forums/
🎨 Colors & Themes
How do create themes in a SwiftUI app. A theme that can hold typography, colors, spacing. How do we handle a case with multiple themes. And a case where the theme is fetched from the backend.
You can create a file with all your application constants, and use conditional logic in the View to select which constant you need on a view by view basis, or pick up on environments such as light mode, dark mode or orientations.
If you need help, make a post on the forums!
If you use a non-semantic color how do you make sure it works in dark mode?
I’d consider checking the colorScheme environment and using an appropriate color based on the current dark/light mode. See the following doc for more details.
For designing is there a best practice for example the title in the trip detail is white but what if the photo is having a white color where the text is going to render, or there is a way to make it adaptable depending on the background to create the right contrast
If the title sits on top of scrollable content, for example a toolbar or safe area bar, the color automatically adapts to the content beneath it.
Maho mentioned a neon color. Since it is not part of the system colors, how do we create it? Do we have to provide the light, dark and increased contrast versions?
How to add a color literal to an Xcode project is discussed here: After adding a color to your asset catalogs, you can set up the color variants, and also set the hex value of the color. The Wishlist sample will be made available on the Apple developer website sometime after the event concludes. You can download it and look into the details of the color.
What impact does use of Color have on battery life? How can we override dark mode?
Have you use the Instruments from Xcode3? I think like colors with higher saturation tend to require more brightness to be perceived clearly, which can drain a battery faster? But you can use the battery impact into the Instruments app to give you clear answers but using color and avoiding color. Remember that while overriding dark mode can help with visibility and comfort in bright environments, it may increase battery consumption but Instruments here are your best friend.
Visit Apple Developer Forums here: https://developer.apple.com/forums/
📊 Charts & Performance
Following up on my Chart question. The chart is showing live data showing over time. I tested with instruments and tracked it down to the chart that is causing it. My current plan is to use Canvas instead for better performance but wanted to confirm I’m not missing something with Swift Charts
If you have spotted out that Swift Charts is the performance bottleneck, yeah, drawing with Canvas with your own code may help, because that way you can only draw the content specific to your needs. But again, we will be interested in looking into more details about your use case. I suggest that you ask this question in our Developer Forums with your code snippets and analysis so SwiftUI folks can follow up from there. Thanks.
I have been trying to test Swift Charts with some sample tests. My use case requires updating the chart continually (at least a few times a second). For 200 data points I’m seeing around 40% CPU usage which is a lot for my use case where I might have multiple charts displaying at the same time.
For a performance issue, I’d typically start with using Instruments to profile the app and figure out the performance bottleneck, and then see how it can be improved. The following doc may be worth reading: - Understanding and improving SwiftUI performance In your case, you might also consider if “at least a few times a second” is really needed and brings a lot of value. Refreshing a chart that frequently does consume resources.
🚟 Platform Specific
I have a SwiftUI view which displays a List, with a few labels and an image. The list row height should be consistent for each item. When the list items grows large, the same code performs just fine on iOS, but starts lagging on macOS (26.2). What explains this?
It is difficult to say for a specific app what would cause the difference. In general, first use Instruments to profile the app and optimize its performance. Check out “Optimize SwiftUI performance with Instruments” for detailed information and tips. If you’re still having issues, please post on the Developer Forums for more assistance.
When building a native Mac app using SwiftUI how do I debug the title bar looking different on my machine (built via Xcode or exported) vs a testers machine even when on the same macOS version (26.2)? Ex: The title bar being transparent as expected in some places or just greyed at the top instead.
Hello, you can troubleshoot visual inconsistencies across different devices by making sure all of your Appearance settings are the same between them, e.g. Dark Mode, Liquid Glass, Accessibility display settings, etc. Also make sure that the content underneath the titlebar is consistent. If you are still experiencing issues despite this (or the appearance is not what you would expect), please file a bug report via Feedback Assistant: https://developer.apple.com/bug-reporting/
What is the best way to make an app that works for all the devices (iPhone, iPad, Mac, TV, Watch, Vision Pro)? Making a single “empty” project in Xcode then adding each platform target, or a separate Xcode project per platform?
Create a new Multiplatform app. Then in the target list in Xcode, add a new target; Add a Watch app that is a companion to the existing app target. In the Watch app target properties, check or uncheck the box for “Supports Running without iOS App Installation” depending on your app’s requirements.
In macOS, SwiftUI provides some default menus. How can I specify keyboard equivalents for default menu items without having to replace the implementation, specifically for Edit->Delete? Even if I provide an implementation, it seems I’m forced to replace all of the pasteboard commands, not just Delete.
You can find a full guide on configuring the Mac menu bar here: https://developer.apple.com/documentation/swiftui/building-and-customizing-the-menu-bar-with-swiftui
Is SwiftUI ideal for extensions?
Hello, if you’re interested in building app extensions with SwiftUI, it’s a snap when paired with WidgetKit!
https://developer.apple.com/documentation/swiftui/app-extensions
Can SwiftUI be used to develop a 2D game? If not what is the suitable apple framework to use? (SwiftUI or SpriteKit or ARKit or something else?)
SpriteKit is a framework you could use to add characters to your game. For setting up the game and its logic, I would start with GameKit! See this documentation to get started: https://developer.apple.com/documentation/GameKit/creating-real-time-games
And ARKit is if you want to make an immersive 3D app using the device camera.
Will the custom shape overlay MKMultiPolygon from UIKit MapKit be included in SwiftUI MapKit? It’s a major polygon type overlay for map engineering and developers currently have access to only Polygon,Circle,Polyline etc… any graceful suggestions in the mean time?
Depending on how you’re currently using MKMultiPolygon, you could use a ZStack with multiple Polygons in your Map, and apply your style modifiers to the ZStack to apply them to all of the Polygons in the ZStack.
🎹 TextField & Keyboard
Is there any way to present an editable TextField that never presents a keyboard or responds to a USB keyboard? I’m building a calculator app with its own keypad that appends to an expression. But I’d like to give the user the ability to select parts of the expression or place the insertion point.
SwiftUI doesn’t provide a way to replace the system-provided keyboard with an input view. I’d suggest that you file a feedback report for that. As a rescue, you can use UITextField + UIViewRepresentable (assuming iOS / iPadOS), and give the UITextField instance an inputView.
Textfield - inline formatting. Currently, Textfield format API doesn’t support inline formatting . What is recommended way to format inline forms on swift ui text fields?
I would start by looking at the prompt of a TextField, see: https://developer.apple.com/documentation/swiftui/textfield/init(_:value:format:prompt:)
🛡️ Security
Where is the best place to keep Access Token and Refresh token/s handling most secure session for Swift Apps?
Use the Keychain to store tokens and other secrets. See the API reference for Keychain items for more information.
🏎️ Concurrency
Say the code is already on Main queue, I used a check Thread.isMainThread and then dispatch on main if false, if true, execute as it is. I want to achieve similar behaviour using modern concurrency. Is it possible? Task {@MainActor} will always behave like main.async
You can await MainActor.run to execute a synchronous piece of code on the MainActor, which should avoid suspending execution if you are already on the MainActor. If you need to know specifically what actor you are on, you can use the #isolation function argument to introspect the current execution context (which returns a type of isolated (any Actor)?). When you are nonisolated, this will be nil. Conversely, when you are isolated--and on the MainActor--it will be .some(MainActor).
🖌️ Icons & App Design
Can I build an app icon from scratch in Icon Composer app or I’d need to first design the icon in Figma/Sketch first than import to Icon Composer to add liquid glass design?
Hi, have you checked out the guide Creating your app icon using Icon Composer? You can download an App Icon Template to create the layers in Figma and Sketch, before importing to Icon Composer. Template available here: https://developer.apple.com/design/resources/
I am having trouble getting the new app icon process to work. My icons in the assets catalog work fine, but icons that I create in IconMaker do not appear at runtime after I add them to my project, whether iOS or macOS.
Hi, you can review the Creating your app icon using Icon Composer article. It’s a great resource to learn about using Icon Composer and adding your Icon Composer file to your Xcode project.
🎬 Toolbar & Actions
Is there a heuristic for the number of toolbar actions to show before moving them into a “more” menu in the toolbar?
You can’t predict the number of toolbar actions that can be shown before they will be displayed in a “more” menu. This will be highly dependent on the size of the device, the size of the window or view, and the size of the toolbar items.
On iPad, DocumentGroup’s title/rename UI gets clipped when I fill .topBarLeading, .principal, and .topBarTrailing (trailing is an HStack). Any recommended toolbar structure to preserve the system rename affordance without dropping .principal or using a menu?
I think this would be a great question for the Developer Forums. I encourage you to post this question there so we can more easily share code and others with the same issue can find help for the same issue. Visit Apple Developer Forums here: https://developer.apple.com/forums/
Apple encourages us to use the navigation bar, but some Apple apps are starting to use more controls in the bottom of the screen, i.e. Safari. Should we focus on using the navigation bar or try to add buttons at the bottom. Thank you!
I would encourage you to find what it works for you, recommendations are one thing, but we do not know your requirements, if the navigation bar fulfills your requirement
Your custom buttons have their merits and can be effective depending on the context and design goals of your app.
The navigation bar is a traditional element in iOS apps and is widely recognized by users. Typically occupies less screen space at the top, providing more room for content than buttons.
Consider how users naturally interact with the device. I don’t think this what you wanted to hear but personal requirements are hard to fulfill in one quick answer. I would recommend the forums if you have examples of what you trying to accomplish.
🔷 Miscellaneous
Is swift UI good at managing memory within messages or keyboard extensions? Lots of bandwidth issues causing crashes when loading a lot of data. Host app is fine…anything helps!
Extensions typically have a hard memory limit. The system doesn’t allow extensions to consume more memory than the limit. Simply switching to SwiftUI doesn’t change the limit, and probably doesn’t help reduce the memory consumption either. Memory consumption is typically related to data management, and so focusing on loading and using data more effectively may better help. I’d suggest that you ask this question in our Developer Forums with more details of how your extensions consumes memory, and we can have a deeper discussion from there. Thanks.
How to best abstract the model for views? A custom view like SearchRow(tripName:, photoName:) is already its own view model. But SwiftUI components like Button don’t give us access to their model. The scene would be like ForEach(searchRows) and ForEach(buttons) or more generally ForEach(rows)
Trying to understand your question and hope I got exactly what you mean with the best abstract model for a view as is hard to answer, I would recommend you to go to the Apple forums as well to follow up. When designing the SwiftUI views with models, for lists with interactive components like buttons, clearly separate and manage state effectively, a clear data model representing the information you display and interact with, view model holding instances of your data model and necessary business logic or state. Define custom views presentation logic for each item with state in the view model or pass closures to handle actions as your main view to iteratee over your view model’s data, passing state and actions to child views. Ensure state changes in interactive elements reflect in the view model, which updates the view due to properties.
I want to add a half screen mostly transparent dialog over the main window of a UI photo editing app. Examples or suggestions?
I’d probably consider using ZStack to lay out a view above the main window and to the target position, make it almost transparent, and use it as the dialog.
In the example of let _ = print(), will that print get called every time the view updates or just on initial creation?
It depends on where you put the print. If you put it at the beginning of the body, every time the SwiftUI recalculates the view body, the print will be called.
I use SwiftData and the @Query annotation to display my data. Each Item is rendered in a subview. Is there a way to pass the Item to be modifiable using either an annotation or something else? Let’s say a pinned attribute is being flipped and updating my @Query without an explicit call to SwiftData
Not sure if I understand your question correctly, but if you intent is to pass a SwiftData model to a view and change the model in the subview, you can definitely do so, and @Query will automatically detect the changes on the model. If you are seeking a way to change an attribute of the model without calling the setter of the attribute, no, there is no way to do that.
Why are views discarded? The dependency tracking- is this feature’s efficiency directly dependent on the discarded views? The Apple Developer Library-the extent of the resources pulled from there?(Customizable?)
SwiftUI efficiently manages memory by discarding views that are no longer visible or needed. This process optimizes performance by keeping only visible or recalculated views in memory. SwiftUI uses a declarative syntax to define the UI state, and the framework automatically updates views when the state changes. Instead of manually updating each view, SwiftUI only updates the affected parts of the view hierarchy. Views are part of a hierarchy, and when their state changes, SwiftUI recalculates the entire affected hierarchy. If a view is no longer visible or necessary, it is removed from memory, reducing memory usage and improving rendering performance.
There are numerous examples and code snippets demonstrating how to implement various features in SwiftUI and related technologies.
Yes, the efficiency of SwiftUI’s dependency tracking and rendering can be dependent on how effectively views are discarded. SwiftUI keeps track of which views depend on which other views
I don’t know what you want exactly from the library.
Is there a way to only draw a portion of a view at a time? With AppKit I’d use -[NSView drawRect:] to only draw visible parts of the view. I have a View whose body is a large Path, and I’d like to reduce the amount of drawing I need to do at once by only drawing the section of the Path visible.
SwiftUI is a different approach, and the view body is updated as a whole based on changes to its data. You might be able to split this into multiple views that each represent part of the Path which can each be individually updated when the underlying data changes. The Developer Forums are a great resource to get more assistance with your specific use case.
🏆 Acknowledgments
A huge thank-you to everyone who joined in and shared thoughtful, insightful, and engaging questions throughout the session — your curiosity and input made the discussion truly rich and collaborative.
Special thanks to:
Aap, Aaron Brooks, Abdalla Mohammed, Alexis Schotte, Andrew Hall, Arpad Larrinaga Aviles, Ash, Ativ Patel, Brian Leighty, Cyril Fonrose, Dan Fabulich, Dan Stoian, Dan Zeitman, David Ko, David Mehedinti, David Veeneman, Dipl.-Ing. Wilfried Bergmann, Eleanor Spenceley, Elif Arifoglu, Elilan, Etkin, Evelyn, Farhana Mustafa, Fred Baker, Greg C, Ian Shimabukuro, James Clarke, Jan Armbrust, Jason Howlin, Jay Graham, Jesse Wesson, Jobie, John Ellenich, John Gethoefer, John Lawter, Jon Bailey, Jon Judelson, Jonas Helmer, Joshua Arnold, Julien, Kaan, Kaylee, Lloyd W Sykes, Lucy, Luis Rebollo, Maic Lopez Saenz, Maisomage, Malcolm Hall, Marin Joe Garcia, Markus, Matthew Brown, Michael Bachand, Michael K., mustii, Muthuveerappan Alagappan, Nathan Odendahl, Nicolas Dunning, Oliver Dieke, Omar zuñiga, Oshua Arnold, Pete Hoch, Rayan Khan, Ricardo Moreno Martinez, Rick Mann, Rupinder kaur, Sam Wu, Satish Muthali, Siddhartha Khanna, Simon McLoughlin, SRINIVASA Potnuru, Tom Brodhurst-Hill, Tula W, Ulien, Vijay Ram, Walid Mohamed Nadim, Will Loew-Blosser, Willian Zhang, Yafes Duygulutuna, Yassin El Mouden, Yuriy Chekan and Zulfi Shah.
Now that’s a list!
Finally, a heartfelt thank-you to the Apple team and moderators for leading session, sharing expert guidance, and offering such clear explanations of the apps optimization techniques. Your contributions made this session an outstanding learning experience for everyone involved.
I appreciate your work! Thanks!
As always with Apple, you never get a real answer to actually unknown questions.