Miká Kruschel

Awesome App Landing Pages

Miká Kruschel — Thu, 02 Jul 2026 00:00:00 GMT

Awesome App Landing Pages

Some app landing pages that caught my eye recently.

Machine Learning & AI

Miká Kruschel — Fri, 12 Jun 2026 00:00:00 GMT

Machine Learning & AI

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

How should developers decide between on-device Foundation models and private cloud compute?

Evaluate based on context size: on-device models have 4K context, while private cloud compute offers 32K.
Consider offline availability: on-device models are accessible without a network connection.
Private cloud compute supports reasoning capabilities, allowing models to “think” before responding.
Use the Evaluation framework for comparative testing by switching between on-device and private cloud compute models with minimal code changes.
Be prepared to fall back to on-device models if network connectivity is lost when using private cloud compute.

What factors influence latency when choosing between local and private cloud compute models?

On-device models eliminate network latency, but good network conditions may make server round-trip time negligible.
Tokens per second performance might not significantly differ between local and server models, surprisingly.
Utilize Instruments for detailed metrics like round-trip latency and token budgets to measure performance.

How can developers use both on-device and private cloud compute models within the same app or feature?

Dynamic Profiles is a new API designed to facilitate the use of multiple models together, enabling context sharing and handoffs.
This allows for scenarios where an on-device model might be used for initial routing, with more complex tasks delegated to a server model.

Why might an Xcode-connected local LLM using MLX server exhibit strange behavior like long delays and an `IAM_N` tag, and how can this be resolved?

This issue is common when integrating new language models and often relates to tokenizer configuration.
Verify that the tokenizer correctly recognizes the specific token causing the problem.
Configuration issues, particularly with chat templates, are a likely cause.
Posting on forums or GitHub issues with detailed observations is recommended for debugging.

How can local LLMs running on MLX LM or custom Core AI models be used as coding agents in Xcode to manipulate projects, beyond simple chat interactions?

Xcode’s integration with language models primarily uses the Language Model Protocol and the Agent Client Protocol (ACP).
Both MLX and Core AI support using custom models.
Core AI is inference-only — for agent use developers would need to build or contribute an OpenAI-compatible server layer; MLX LM servers work out of the box.
Xcode can automatically detect MLX LM servers and allow selection of models, supporting both chat and ACP modes.

How can developers detect when on-device or private cloud compute models have been updated, especially if prompt behavior regresses?

On-device models are typically updated as part of OS updates (~twice per year, often in betas), giving developers a testing window before GA.
There is no runtime model-version identifier — OS version is the practical proxy for which model developers are running.
Avoid per-OS-version prompt if branches; instead rephrase prompts to be robust across versions.
The Evaluation framework is crucial for detecting model changes by running comparative evaluations against previous OS versions.
Model updates are generally intended to improve performance, not regress functionality.

Can Foundation Models run from widgets, app intents, or background tasks, and what are the considerations for rate limits and thermal rules?

On-device models can run in the background and in widgets.
Rate limiting may occur on iOS due to system conditions; requests might fail and should be retried.
The system manages on-device LLM resources, ensuring only one instance is in memory, but foreground tasks may be prioritized.
On iOS, background tasks may be deprioritized if resource-intensive foreground activities are occurring (e.g., games get priority over background LLM use).
Don’t surface rate-limit errors to users in background contexts — handle and retry silently.
Rate limiting does not apply on macOS for the on-device foundation model.

How can developers create or adapt models for their own apps, data, and domains, such as generating stylized user profile images or adaptive app guides?

Start by customizing prompts with app-specific user data to generate personalized outputs.
Consider fine-tuning open-source models from platforms like Hugging Face if more advanced customization is needed.
User adaptation can often be achieved through prompt engineering and extracting relevant information, rather than full fine-tuning.
Leverage the Evaluation framework for “hill climbing,” iteratively improving model quality through prompt changes, model swaps, or fine-tuning.
The Evaluation framework’s sample generator can create synthetic text inputs for testing (and pipelines exist for diffusion models).
The Evaluation framework supports various model types, including diffusion models, and can use model judge evaluators for style and quality assessment.

What are the best use cases for the Foundation Models Framework, and which should developers avoid?

Ideal use cases include content extraction, content generation, and tasks leveraging image input.
Test image input during the iOS 27 beta and file feedback if the use cases fail.
LoRA-style adapters may be possible for text models but are not supported for diffusion models.
Avoid using Foundation Models for real-time processing that requires sub-millisecond latency, such as ranking list views or processing video frames per second.
For highly specialized, real-time tasks, consider domain-specific APIs like Vision or Speech Recognition.
If a task requires more language support than available in Foundation Models, specialized translation APIs might be a better fit.
Foundation Models are powerful for summarization, text extraction, grammar correction, and tone/style transformation, especially with the context window improvements from Private Cloud Compute.

Where should a beginner start to learn about AI/ML, and what resources are recommended?

Start with Swift Playgrounds for an introduction to ML using Core ML for image classification.
The Foundation Models Framework is easy to pick up for prompt engineering and tool additions.
Xcode now offers a one-click playground launch for quick experimentation with language models.
For deeper understanding, explore how LLMs work under the hood, including token generation and training.
Project-based learning, building an app or model, is highly effective.

Is it possible to import everything from PyTorch into Core AI or the Apple ecosystem, and what are the limitations?

Most PyTorch models that can be exported using PyTorch APIs will convert straightforwardly to Core AI.
Core AI supports all core A10 operations; custom operations may require custom lowering or wrapping.
For performance optimization, custom Metal kernels can be written.
MLX APIs are similar to PyTorch, making it easy to experiment with models from Hugging Face.
Many PyTorch models on Hugging Face have already been converted for MLX.

What is the best user experience when Foundation Models are unavailable (e.g., older devices, Apple Intelligence off, low battery), and how can developers detect availability and degrade gracefully?

Use the pre-warm API to load the on-device system language model into memory before user interaction, reducing initial latency.
An availability API allows checking if the model is supported on the device.
For unsupported devices, consider alternatives like bringing custom model via Core AI or relying on a server model.
If Apple Intelligence is off, guide users to enable it rather than showing an error.
If a button or feature relies on an unavailable model, it’s better to hide it or provide a different experience to avoid user frustration.

How should developers migrate from Core ML to Core AI, and what is the recommended approach for supporting older devices?

Core ML is still supported and useful for models like decision trees or when microsecond performance is critical.
Core AI is the recommended path for modern generative AI models.
Consider the user base’s OS update timeline for dropping support for older OS versions.
Implement a wrapper or use conditional logic to use Core AI on newer OS versions and Core ML on older ones.
If the app uses generative models, migrating to Core AI is recommended.

What is the maximum on-device local model size that can be used before considering private cloud compute, and what are the considerations for iOS and macOS?

On iOS, it’s generally recommended to keep models below 2GB to avoid stressing the system and to be a good platform citizen.
On macOS, model size is more flexible and depends on available memory; profiling the app is key.
Consider available memory within the app and system-wide memory usage.
Quantization can reduce model size, but evaluate the trade-off between size and accuracy loss.
For LLMs, a 6-billion parameter model might be pushing the 2GB limit on iOS, depending on quantization.

How should developers decide when AI should assist the user versus when it should remain in the background?

Focus on the fundamental user experience to deliver; AI should enhance, not dictate, the experience.
Use AI tools strategically to fill functional gaps or provide specific benefits, rather than for the sake of using AI.
User delight and the overall experience are paramount.
Experimentation and evaluation can help determine if an AI feature is meaningful and beneficial to users.
AI should help users achieve their goals more quickly and efficiently without being intrusive or obstructive.

For older iPhones without Apple Intelligence and using a self-hosted LLM backend, is wrapping the backend in a custom language model provider the recommended path on iOS 27?

Yes, the new Language Model Protocol allows using any model, including custom server models, with a unified Swift API.
If the custom server model conforms to the OpenAI chat completions web request protocol, developers can use the open-source utilities package for integration.
This protocol enables seamless integration of system models and custom models within the same app, with conditional logic for model selection.

SwiftData

Miká Kruschel — Fri, 12 Jun 2026 00:00:00 GMT

SwiftData

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

What’s the proper way to use SwiftData with widgets and app intents?

For multiprocess coordination (widgets, app intents), designate one app process as the primary owner of the database and migration.
Other processes can read and write to the same database file after the primary process has handled migrations.
Avoid including schema migration plans in widgets and extensions; use the error path to prompt the user to open the main app for migration.
The SampleTrips app includes a widget that utilizes the group container for data sharing.

How should developers approach large data sets in SwiftData?

For a large number of rows, ensure correct indexing for fast database fetches.
Limit fetch requests and memory usage to prevent out-of-memory errors.
For very large data items (e.g., images, files), use the externalStorage attribute to store data in separate files instead of directly in the database.
When ingesting large data sets, perform insertions in smaller chunks using batch insertion and short-lived model contexts for each batch.
When using Query in SwiftUI with large datasets, limit fetches with fetchLimit and ensure predicates accurately express the desired data. Use Instruments (Hitches, Persistence) to identify performance bottlenecks.

What are the best practices for creating sample data for previews and testing?

Use the previewTraits parameter to seed previews with expressive sample data that covers various UI scenarios.
Within previews, developers can use Query to drive the view with sample data.
For migration testing, build a corpus of previous store versions to ensure all previously shipped models can migrate successfully.
Consider using agentic programming for generating diverse sample data instances.

When should a developer choose `ResultsObserver` over `Query`?

ResultsObserver is intended for observable fetching outside of a SwiftUI view, such as in a view model.
Both ResultsObserver and Query have similar performance characteristics under the hood.
ResultsObserver simplifies handling data updates by observing changes directly, removing the need for manual notification listening and re-fetching.
HistoryObserver (part of ResultsObserver) can observe changes from a specific point in time and is useful for replication or keeping other systems up-to-date.
Filter HistoryObserver to local writes only when replicating — ignore remote-server writes to avoid echo loops.
ResultsObserver can be combined with ObservableObject in AppKit and UIKit to update non-SwiftUI views efficiently.

How are sums and averages handled in SwiftData without loading all data into RAM?

SwiftData currently lacks direct equivalents to Core Data’s NSExpression for on-disk calculations. Data often needs to be loaded into RAM for such operations.
For min/max calculations, a fetch with fetchLimit of one and a sort descriptor can be used.
File feedback reports with specific use cases are encouraged to drive future API design for these types of calculations.
Consider using coexistence: a Core Data stack and a SwiftData stack can point to the same data store, allowing developers to leverage Core Data for unsupported calculations.

What’s the best way to construct view state for populating non-optional attributes when adding a new model object?

If a SwiftData model has non-optional properties, ensure they are set in the initializer for persistence.
For views rendering a single object, fetch or find the data in a parent view. Only instantiate the subview if the object exists, otherwise display a placeholder.
Alternatively, use a Query with fetchLimit of one and handle the logic for zero or one object in the view.
A cleaner approach is to fetch the single model in a parent view using a ModelContext. If it doesn’t exist, create it before presenting the view. This avoids showing an empty list and handles creation logic outside the view.

How can SwiftData + CloudKit adopt an app group or schema version without losing data?

Developers can add a version schema at any time.
To move to an app group container, developers will likely need to copy data from the old container to the new one, as the group container resides in a different directory.
If using the default model configuration, SwiftData will move the data for developers when moving to an app group. When a URL was specified previously, move the data manually to move it manually.
Start version schemas with the current version and progressively build them up. Developers can add previous versions later to pick up those stores during migration.

How does using an app group for the SwiftData local store affect CloudKit development and production environments?

Ensure the CloudKit entitlement used is appropriate for all apps reading from the app group, as they will be syncing to the same CloudKit container.
If do not want data in the app group to sync to CloudKit, use a separate model configuration and data store for syncing.
Avoid giving widgets or extensions the CloudKit entitlement, as this would require them to sync and can impact performance due to their limited runtime.
Widget extensions have different system policies for network usage and syncing compared to full apps, often throttling network activity to conserve battery.

When evolving the schema in Xcode during development, do I need to do anything to avoid creating duplicates in the local store between two apps writing to the same CloudKit?

Ensure schemas are aligned across all apps to prevent competing migrations.
During development, flip environments to production on all apps to test schema synchronization in a production-like setting.
Syncing is complex; use logs and sysdiagnose for debugging.
Be mindful of autosave behavior; ensure saves are committed, especially when force quitting apps. Backgrounding apps in the simulator can simulate customer behavior.

What’s the most performant way to count SwiftData objects without querying them in views?

Use fetchCount on the ModelContext.
In performance-sensitive areas, manually fetching into a cached array can offer more control than @Query if SwiftUI’s view lifecycle triggers excessive refetches.
Use Instruments (SwiftUI and Persistence) to understand why SwiftUI re-initializes views and triggers fetches.
Breaking down views into smaller components with fewer dependencies can reduce unnecessary query executions.
ResultsObserver can provide an observable experience for managing manual fetches.
HistoryObserver can be used to determine when manual fetches are necessary based on specific property changes.
fetchIdentifier allows fetching only object identifiers without fetching the full model.
For queries outside the view hierarchy (e.g., background actors), a direct fetch is appropriate instead of @Query.
The sectionBy modifier on ResultsObserver and Query (via key path) sections data directly without in-memory grouping.

How can CloudKit synchronization be sped up between devices?

Test thoroughly and examine logs for verbose information routed through Core Data.
Be aware of platform-specific system policies that may throttle network usage (e.g., watches on cellular, devices under heavy load/heat).
Backgrounding and foregrounding apps can sometimes encourage more aggressive syncing during testing.
Check entitlements carefully, as incorrect or mismatched entitlements between debug and release configurations can cause sync issues.
Use sysdiagnose from all devices and file feedback reports for detailed analysis of sync problems.
autosave can batch changes, but ensure saves are committed, especially when testing rapidly. Force quitting can prevent autosave.
Backgrounding apps in the simulator can mimic customer sync behavior.

What’s the best way to store enums, including those that conform to `Codable` with associated values, in SwiftData?

If enum values are Codable, SwiftData can persist them.
New in recent releases: ResultsObserver and Query support predicates with raw representable enumerations.
For enums with associated values that are difficult to encode, use the .codable flag with the attribute macro. This leverages existing Codable conformance for persistence.
If developers need to query or sort by enum values, consider modeling them as SwiftData models with relationships rather than relying solely on Codable. This allows for full predicate and sorting capabilities.
For types that are not directly owned or modifiable (e.g., MapKit types, Measurement), using Codable is a practical approach.

What are the best practices for using multiple model contexts? When does it make sense to split work across separate contexts?

The decision depends on the objective. For background work without UI implications, split tasks to keep them coherent within a transaction.
Model contexts represent a working set; changes are saved in a single transaction. Minimize cross-coordination between contexts to reduce friction and serialization overhead.
Split work to allow for independent execution, minimizing the need for contexts to communicate or coordinate.
On most platforms (phones, iPads, watches), avoid excessive concurrency. The NAND system is often the primary bottleneck.
Start by measuring performance and benchmarking.
SQLite databases support multiple readers concurrently with a single writer.
Be cautious of diminishing returns with increased concurrency; it can lead to higher memory usage and I/O, and synchronization costs can outweigh benefits.
Short-lived model contexts help keep memory footprints small by processing and saving data incrementally. Avoid hydrating large object graphs into memory.

How do I know if I need to paginate my queries instead of fetching all records of a given type?

Use Instruments (Hitches, Persistence) to identify UI hitches and excessive object loading.
Set a fetchLimit on the Query when developers only need a subset of data for a view.
Lazy stacks with an onAppear modifier on a progress spinner can trigger fetching more data as the user scrolls.
Restricting fetches to what’s needed for the current view prevents performance degradation and the need for manual pagination.

Is it a good idea to combine SwiftData with a cloud backend for sync, or is that an anti-pattern?

It’s not an anti-pattern. SwiftData can serve as a local cache for the cloud backend data.
Developers can implement a custom data store (e.g., JSON store) to work with the existing storage mechanism.
Leverage HistoryObserver to identify changes and sync them back to the cloud backend.
Using SwiftData for the local cache reduces the need to reimplement persistence logic.
Custom data stores allow storing data in any format and adhering to specific security models.
Developers can start with a JSON store and gradually migrate to a SQLite store as the app evolves.

What’s the proper way to know if a database migration is required or not?

If a widget attempts to load an unversioned schema, it will error out, indicating a migration is needed.
Use user defaults to store the migrated version number. Widgets can then use this version to open the persistent container.
Widgets and extensions should not perform migrations due to limited runtime resources.
For the main app, developers can estimate migration progress by calculating the number of stages and overriding the didMigrate handler for custom migration stages.
Consider the user experience during migration; provide informative updates rather than just a loading spinner.

What’s the best way to do grouped queries, like grouping results by one property of a model and then displaying the results in sections?

The ResultsObserver and Query APIs now support sectioning by providing a key path to a persistent property.
This allows data to be sectioned directly, eliminating the need for in-memory grouping.
The SampleTrips app demonstrates this capability, showing how to build UIs with grouped data.

What’s the recommended way to handle concurrency when a model actor needs to return model data?

Model objects themselves are not Sendable due to their reference-based nature and graph interactions within the ModelContext.
Extract the necessary data (e.g., persistent identifier, structs, dictionaries) to pass to other actors.
Avoid passing relationships or entire object graphs across actor boundaries, as this can lead to incomplete hydration or unexpected behavior.
Be mindful of the strict Sendable boundary and the cost of communication across concurrency domains.

App Store Connect

Miká Kruschel — Thu, 11 Jun 2026 00:00:00 GMT

App Store Connect

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

What are the most overlooked App Store Connect APIs or capabilities developers should use?

Automate build uploads, making builds available to testers, and processing feedback via APIs for end-to-end development automation.
Combine TestFlight feedback APIs with webhooks to automatically generate tickets in the ticketing system.
Utilize the Power and Performance API to download reports on app performance, including storage and CPU usage.

How should apps without audio signal accessibility for hearing-impaired users?

Accurately answer accessibility questions based on the app’s capabilities.
If the app has no sound, do not claim it has captions.
Use the app description and app previews to communicate accessibility features and value propositions.

What are the most common reasons subscription apps get rejected on their first review, and what are pro tips for new developers?

Common Rejection Reasons:
- Insufficient preparation and testing on devices.
- Not addressing crashes or ensuring production-ready systems.
- Failing to provide necessary login or demo credentials for subscription-based content.
Pro Tips for Submission:
- Thoroughly test the app on devices, exercising all functionality.
- Ensure in-app purchases and subscription systems are production-ready.
- Use the new enhanced IAP submission experience for clearer dialogue with App Review.
- Use App Review Notes to guide reviewers, including login credentials for paywalled content.
- Provide relevant information and notes that address potential reviewer questions.
Pro Tips for Following Up After Rejection:
- Take time to write a detailed response in App Store Connect, not just submit an update.
- Use the response to have a dialogue, explain the app’s functionality, and ask clarifying questions about the rejection.

Will App Store Connect analytics show impressions, retention metrics, and how often a user revisits the cancel flow for retention messages?

Yes, App Store Connect will provide data on retention messaging performance.
Developers can measure how many users saw the retention messaging page, clicked cancel, and continued to stay subscribed.
This data allows developers to test different messages and offers to see what resonates most with users.

What are the most common security mistakes developers make when implementing App Store Connect API integrations?

Key Security Practices:
- Do not hardcode API keys into the repository or ship them in client applications.
- Store API keys server-side or in the Keychain — never in client apps or source control.
- Manage private keys responsibly and revoke them if compromised or when a service is no longer used.
- Be especially careful when integrating with third parties; only grant necessary permissions and revoke keys when the integration ends.
- Use the Users and Access API to monitor account access and compare it against internal systems.
Private keys are for private use only and should not be shared.
Create keys for specific use cases and revoke them afterward.

In App Store Analytics, is there a way to see how many people updated organically versus in the background (auto-update vs. manual)?

Yes, this breakdown is available in the App Store Connect analytics reports.
Developers can download the analytics reports and find a column that specifically breaks down auto-updates versus manual updates.

For large companies with many apps, is there a way to automate uploading only a few apps from CI without a team API key granting access to all apps?

A general access team API key grants access to all apps on the account.
Developers can create an API key per user of App Store Connect, which is tied to that user’s level of access.
This individual key will have the same permissions as the user in the App Store Connect UI, allowing for more granular control.

Can universal purchase apps use different names or subtitles per platform?

The name and subtitle are shared across all platforms for a universal purchase app.
Description, however, can differ per platform. Use the description to tailor content, such as omitting NFC mentions for a tvOS target while including them for iOS.
App previews are also a good way to showcase platform-specific functionality.

Does the new retention workflow support localization, and should retention messages be localized to match app localizations?

Yes, localization is supported for retention messages.
It is highly recommended to localize retention messages to ensure consistency with the app’s localizations and provide a cohesive user experience.

What are the best practices for App Store app descriptions, especially when many popular apps use dense copy?

Focus on what users might be interested in and what the app offers.
Tailor the message for the specific audience.
Utilize features like Custom Product Pages to drive different audiences to different copies.
Consider using Product Page Optimization to test different description variations.
Leverage custom images and videos for product page headers and search results to convey information visually.

What are the best practices for using TestFlight for internal team testing, and how about external testing?

Internal Testing:
- Use internal TestFlight for initial testing within the team, especially for QA teams distributing builds regularly.
- Create different internal groups for specific teams (e.g., QA, localization) and distribute tailored builds to them.
- Be selective about builds provided to leadership or for early feedback.
External Testing:
- Submit to the beta app review process to ensure trustworthiness and safety.
- Developers can have up to 10,000 testers.
- Share a link to invite testers; they must download the TestFlight app for security and privacy.
- Find testers through forums relevant to the app’s niche, focusing on seeking feedback rather than selling.

What are best practices for App Store Connect API keys in tooling and automation?

API keys should be kept on the server only; do not embed them in client applications.
Keys have no expiration date, so manage them carefully.
For team keys, consider the role and assign lower-level permissions for read-only access if possible.
Use individual keys for testing and experimentation before moving to a team-wide key for production automation.
Adhere to the principle of least privilege.

Is there a way to use the same product name on the App Store for a Mac app and iOS/Apple Vision Pro apps combo if they have different bundle IDs?

No, this has not changed. You cannot use the same product name for apps with different bundle IDs.
The recommendation is to use universal purchase, which would consolidate these apps under one bundle ID and accomplish the goal.
This approach offers benefits and aligns with the ecosystem’s evolution towards unified development.

What should first-time App Review submissions get right for auth and API keys?

Thoroughly test the app, including third-party functionality and APIs.
Ensure the services are ready to receive production traffic and scale.
If managing user API keys, uphold privacy by managing them in a privacy-friendly way.
Provide demo account information and credentials in App Review Notes so reviewers can access and test all app functionality.

How can purchase restoration be validated when transitioning a paid app to freemium?

Use the StoreKit 2 appTransaction API to see the original app version a customer purchased.
TestFlight detects app version changes but does not test actual purchases — use sandbox accounts in App Store Connect for purchase testing.
Developers can also create sandbox accounts in App Store Connect for more complex sandbox management and testing scenarios.
Consider having one account download the App Store version and then upgrade to the freemium version being tested in TestFlight.

How do developers publish their first iOS app?

Explore the Apple Developer website for tutorials, videos, documentation, and WWDC sessions.
Consult the App Store Connect Help Guide for step-by-step instructions on navigating the UI.
Follow the Apple Developer Pathway, a guided process for getting the app on the store.
Refer to detailed guides for each page and action available in App Store Connect.
Watch the “Getting Started with TestFlight” tech talk for guidance on building, testing, and submitting.

Once an app is approved, how can I increase its visibility?

Provide compelling creative assets, including more screenshots and previews.
Create In-App Events to highlight timely content or activities.
Utilize Custom Product Pages and tie them to specific keywords for increased relevance.
Submit the app for a feature nomination to the editorial team for potential placement on the Today tab.
Share “Shareable Moments” for featured apps or new version releases to promote them.

Do I need a different binary for every platform (watchOS, iOS, etc.) for a universal app?

It depends on which platforms to distribute to and if the app is eligible for Apple Silicon.
You will need distinct metadata for each platform.
Developers can start with an iOS binary and then make it available on macOS or visionOS.
Developers can create platform-specific binaries (e.g., visionOS, macOS) later to leverage native features, and users will update to those.

For review notes, if an app is localized to multiple languages, should the notes still be in English, or can they be in the developer’s native language?

While English is often preferred, App Review reviewers have a wide range of language skills and can often review apps in the developer’s primary language.
It is not an absolute requirement for review notes to be in English.

What new App Store Connect workflows introduced this year should developers revisit, even if they already have mature automation in place?

Explore new visualizations and over 100 new metrics in the App Store Connect web UI for subscription and in-app purchase analytics.
Investigate the submission of Game Center entities (leaderboards, etc.).
Review updates to In-App Purchase APIs and the introduction of Offer Code APIs for consumables and non-consumables.
Consider the Build Delivery API for automating build submission and updates.

What are the most common reasons for rejection on the App Store?

Bugs and Crashes: Insufficient testing on devices (not just simulators).
Incomplete Information: Missing demo credentials or functionality details in App Review Notes.
Inadequate Testing: Not thoroughly testing via internal and external TestFlight, and not incorporating feedback.
Submission Completeness: Submissions that are not detailed or complete.
Guideline Violations: Not adhering to specific sections of the App Review Guidelines, especially for categories like Kids Apps or apps with crypto content.
Insufficient Testing: Relying solely on Xcode Simulator and not testing on multiple physical devices or with external testers.

Which validations only run after TestFlight or App Store Connect upload?

Validations occur throughout the pipeline, and efforts are ongoing to provide feedback as early as possible.
Xcode offers validation before delivery, and warnings are provided to guide developers.
Uploading frequently (continuous delivery) is a good way to identify issues early.
The goal is to move validation checks earlier in the development workflow.

Is there a way to organize TestFlight builds into streams or groups, for example, keeping a major new feature separate from regular builds?

Yes, developers can organize testers and builds into groups for both internal and external TestFlight.
Create groups based on use cases (e.g., development team, QA team, localization team, power users).
Developers can create a group for a specific upcoming feature (e.g., version 2.0) and another for bug fixes (e.g., 1.1).
This allows for parallel development and testing of different app versions simultaneously.
Xcode Cloud can automate this process by distributing builds to specific groups based on branches.

Is there a technical or policy reason for the few-day delay on price changes for in-app purchases or subscriptions, including when lowering the price?

The delay is to ensure that price changes go live everywhere at the same time, accounting for global time zones and propagation across systems.

How should country-specific app listings be merged when features differ?

Choose one app listing to be the “flagship” and update the other listings to direct users to download the new primary app.
Notify users about the change and provide a transition period.
Consider a final release that informs users the app is going away and directs them to the new app.
Keep the old code for a period to potentially address security updates or bug fixes for users who haven’t migrated.
Use analytics to track user migration between app versions.

What features are provided by the new App Store dashboard with analytics, and how can developers maximize value?

The biggest update to App Analytics in over 10 years, adding over 100 new metrics, primarily for in-app purchases and subscriptions.
Data can be tied back to subscriptions, showing the full customer journey from download to renewal.
Visualizations help identify conversion rates, retention, and “soft spots” in the business.
New benchmarks allow developers to compare their performance against industry standards.
Utilize the new guide and videos for detailed information and resources.

Any tips for creating a successful featuring nomination submission?

The app should be interesting, potentially novel, or do something new.
Apps with great art and compelling visuals have a better chance of standing out.
New assets for product pages can also be used in featuring placements.
Consider the story behind the app and its history.
Feature nominations are not just for initial launches; updates and roadmaps can also be nominated.
Developers can try multiple times if the initial nomination is not successful.

What is the least-privileged App Store Connect API role for third-party tools?

The “Sales” role generally has the lowest level of functions and is recommended for read-only access.
The “Developer” role allows uploading builds and using internal TestFlight.
The “Marketing” role allows changes to metadata, product pages, and in-app events, but not app releases.
These lower-permission roles are the most recommended for API keys used by third-party tools.

Any advice on fetching live or last 24 hours of App Store Connect data via the API, given the UI shows this but the API only updates daily or provides aggregates?

Currently, the UI is the place to view the last 24 hours of sales data.
The API updates on a daily basis.
While the data is the same, the cadence of acquisition differs between the UI and the API for sales and trends data.

How can organic search custom product page impact be measured without keyword-level data?

In App Analytics, developers can see how well a custom product page is performing overall.
Filter by “Source Type” and select “App Store Search” to see performance from organic search.
When developers are not running Apple Ads, this will represent the organic search traffic.
If running ads, consider creating separate custom product pages for ads and organic search to differentiate the traffic.

Is there a way to see the rollout progress of the current release while a new release is being prepared and submitted to review?

Yes, in App Store Connect, navigate to the version page and click into “Phased Release Rollout” to see the current day and progress.
Developers can have up to two versions in App Store Connect per platform: the one ready for distribution and the one being prepared.

What options are open to developers building geospatial augmented reality games in terms of passing app review, especially if a full working demo is difficult to create?

If the review requires being in a specific location, include a recording of the app in action with the submission.
Ensure the app provides functionality for users outside the specific geographic location (e.g., outside the UK).
Utilize TestFlight for internal and external testing to get feedback and ensure the geo-experiences are acceptable to App Review.

Apple Intelligence

Miká Kruschel — Thu, 11 Jun 2026 00:00:00 GMT

Apple Intelligence

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

What are the most useful Apple resources for learning and applying new APIs and design changes?

WWDC videos, documentation, sample apps, and migration guides are primary resources.
The documentation includes a dedicated sample section and technical articles.
Sessions often demonstrate sample apps, showing how they are built and used.
Documentation for App Intents and Foundation Models provides usage guidance and benefits.
Previous WWDC materials are valuable for foundational knowledge.

How do I integrate with Siri when no app schema fits my entities?

Utilize existing app schemas by picking and choosing actions that best match the app’s capabilities.
Combine schemas with custom App Intents for functionality outside predefined schemas.
App Intents make actions available in Shortcuts, Spotlight, and more.
For new Siri AI integration, adopting an app schema is required.
Consider the system.search schema for search-related functionality (e.g., e-commerce, food ordering) to allow Siri integration with the app’s search.
The system.open schema allows Siri to open donated entities directly in the app.
If no schemas fit, App Shortcuts can be used by defining memorable phrases for specific actions.

Should I use the closest schema match or skip schemas when the fit is imperfect?

It’s recommended to use the closest related schemas.
Developers can combine schemas from different domains if the app has diverse capabilities (e.g., calendar and reminders).
If no schema perfectly fits, consider using App Shortcuts for specific actions.
For new Siri AI integration, adopting an app schema is necessary.

How should app entities and actions participate in agentic Siri?

Review available schemas and implement those that align with the app’s capabilities.
Conforming to an entity schema and donating it to Spotlight provides benefits for Siri AI interaction.
Developers can use Siri AI to ask questions about content or take actions on it using any view annotation API.
Consider the platform’s evolution and how schemas provide a standardized, consistent experience.

Can an app act as its own orchestrator and drive other apps, or does cross-app action still have to route through Siri Shortcuts?

A system orchestrator is available that can take action from App Intents across different apps.
Privacy and safety are key; data indexed from the app is available to the system, not other apps directly.
The Transferable API allows developers to control how data is shared between apps.
Transferable supports bidirectionality, letting developers choose which data to export and import.

Can third-party apps participate in multi-turn Siri conversations?

Yes, apps can participate in multi-turn conversations with Siri.
App schemas enable apps to take actions, ask questions about entities, and handle follow-ups.
The underlying large language model processes input for more natural user interactions.
App schemas offer flexibility in how users phrase requests, allowing the model to parse information and select the correct action.

Can one app mix schemas from different domains?

Yes, it is acceptable to mix and match schemas from different domains.
The intention is for developers to select schemas that best match their app’s capabilities.
Schemas, App Shortcuts, and in-app search can work together to create holistic user experiences.
Developers should leverage these components based on their understanding of their users and app functionality.

Is there a practical time work budget for Foundation Models during one background wake? If no fixed number, how should apps safely chunk work?

For on-device Foundation Models running in the foreground, there are no rate limits.
When running in the background, throttling may occur if the system is under heavy load.
Apps should catch rate limited errors to know when to retry requests.

What exact error types or codes indicate Foundation Model throttling?

Throttling can be indicated by errors like system busy, thermal pressure, or quota exhaustion.
Distinguish retriable rate-limit errors (retry later) from terminal quota exhaustion.
The Language Model Protocol includes Language Model Error for common issues like rate limiting and refusals.
For the PCC model, specific errors related to quota usage and quota exhaustion are available.

How to avoid `language model session.generation error.guardrail violation`?

Use the model judge evaluator in the Evaluations Framework with safety rubrics.
Developers can use a larger model (like PCC) to evaluate prompts that trigger guardrail violations on smaller models.
Guardrail violations are designed to prevent unsafe responses.

In iOS 27, can the Foundation Models Framework reason over video or work with a video model, or is multimodal input limited to still images?

The Foundation Models Framework supports models with vision capabilities.
The PCC model can reason over images with options for light, moderate, and deep reasoning.
The framework is extensible; custom modalities like video can be supported via a custom segment API.
The Foundation Models Framework is going open source, enabling server-side Swift preprocessing tools.
For video processing, consider using other Apple frameworks to extract transcripts or audio descriptions and feed that text to the models.

Do App Intent schemas give an advantage over generic intents for Siri AI discovery?

Schemas are the primary way Siri AI reasons about actions and entities in the application.
Using schemas provides a standardized and consistent experience across apps.
Intent donation allows users’ actions within the app to be learned by Siri.
App Shortcuts allow developers to specify phrases for app intents.
Adopting an app schema means Apple has pre-trained models and sample phrases, reducing developer effort.

Can Image Playground generate photorealistic images inside an app?

Yes, developers can use the Image Playground API to generate photorealistic images.
Use ImagePlaygroundStyle.all as a parameter for photorealistic generation.
This functionality runs on Private Cloud Compute (PCC), leveraging its powerful model.

What’s the difference between indexed entities and defined entities (like app schema entities)?

Schemas define the structure and properties of content (e.g., a book’s title, author).
Indexed Entity is an API to index that content into the system’s semantic index for retrieval by Siri AI.
Adopting an app schema and conforming to the Indexed Entity protocol provides the best Siri AI experience.
Indexed Entity can also be used for custom entities and donated to Spotlight, enabling deep linking via system.open intents.
App schemas simplify Spotlight integration by handling indexing keys automatically.

Can the Evaluations Framework be used for academic research?

Yes, the Evaluations Framework can be used for academic research.
It’s designed for evaluating any stochastic system, including traditional machine learning models.
The framework allows for scenario-based metric collection and the creation of app-specific or scenario-specific benchmarks.
Features like synthetic data generation and Xcode integration with visuals can support research.
Reports can be saved and exported as JSON for further analysis.

Does Siri support screen context on CarPlay?

On-screen context is supported via NSUserActivity integration and the new view annotations API.
CarPlay screen context and grid-style actions are not supported — file Feedback Assistant if developers need them.
Safety is a priority; keep driver attention on the road when using CarPlay.

Are we going to be able to use App Intents with HomePod, since currently there is not a beta for HomePod?

The new Siri AI is not available on HomePod.
Existing App Shortcuts have worked on HomePod for a while.

Can we expect watchOS responses to App Intents to match up one-to-one with iOS?

No — dialogue is not one-to-one across devices. Siri adapts responses by context (e.g., verbose on AirPods, concise on iPad).
Developers are encouraged to test experiences across all supported devices, including watchOS and AirPods.
App Intents can optionally provide dialogue that can be adapted for different contexts.
The App Intents testing framework is available for testing.
Customizing the Siri experience, including intent dialogue, is supported.

Does Image Playground now require an internet connection for PCC, or does it fall back to the previous model gracefully?

Image Playground always requires an internet connection as it uses PCC (Private Cloud Compute).
It will not fall back to an on-device model.

What are notable highlights from the Apple Intelligence updates?

Phone call intelligence: Features like extracting confirmation numbers during calls.
App Intents testing: A new way to unit test App Intents, including UI and Spotlight integrations, for CI pipelines.
Foundation Models Framework: Integration with various language providers, core AI, and the ability to bring any model from the web.
Evaluations Framework: Testing intelligence-based features, model judges, quantitative/qualitative metrics, and tool call evaluation.
Private Cloud Compute (PCC): Easy access to server models with simplified authentication (one line of code).
New Siri AI: Advancements in Siri, new APIs for developers, and a deeply integrated ecosystem for natural language interactions and actions across apps.

Why does Apple use hard-coded App Intent schemas instead of dynamic skill descriptions?

Schemas provide consistency and privacy, aligning with Apple’s focus on personal and private intelligence.
Schemas ensure a standardized, holistic experience across the platform, making interactions natural across apps in the same domain.
Schemas offer security benefits, such as built-in confirmation steps for sensitive actions (e.g., sending money).
Schemas enable differentiated behavior based on entity ownership (e.g., shared vs. personal calendar events).
Schemas facilitate localization by allowing Apple to handle model training and natural language strings across locales.

Can the Evaluations Framework verify tool calls?

Yes, developers can supply a transcript from the Language Model Session and use a tool call evaluator.
The Evaluations Framework allows developers to define assertions for tool calls, including order, properties, and values.
This system can be used at the scenario level to report on tool execution.
Features like dynamic profiles and Xcode and Instruments integration further aid in visualizing and verifying tool calls in real time.

How does the Apple Intelligence Framework mitigate semantic entropy when passing context between on-device models and larger server-based models?

The Foundation Models Framework uses dynamic profiles to manage context across models with different context sizes (e.g., 4K for on-device, 32K for PCC).
History transform modifiers can be used to manage context when switching profiles or incorporating tool calls.
The Foundation Models Utilities package provides tools like summarization to compact transcripts for smaller context sizes.
The Evaluations Framework can be used to test and optimize context management strategies.

Do I need to use the Evaluations Framework with Foundation Models?

No, developers do not necessarily need to use the Evaluations Framework with Foundation Models.
The Evaluations Framework can be used to evaluate any stochastic system.
However, specific evaluators like the tool call evaluator require Foundation Models to access the transcript.
Apple is working on generic transforms for other models to enable broader use of these evaluators.

Can one app retrieve another app’s donated `Indexed Entity` content?

Retrieval is limited to the app’s sandbox only.
For inter-app content sharing, use the Transferable protocol.
Transferable allows for progressive data sharing from highest to lowest fidelity.
Developers control what data is shared and with whom, ensuring privacy and security.

Schemas: Are schema-bound entities interchangeable? Can an app’s file entity be turned into a photo entity and vice versa?

Yes, schema-bound entities can be interchangeable, often through the Transferable protocol.
The Transferable protocol allows developers to specify data transformations the app supports.
For example, a message entity containing an attachment can be exported as a file or a photo, allowing import into relevant apps (e.g., Photos app).
A file entity protocol exists for file-based formats.

Is an imperfect schema match acceptable for new Siri integration?

Yes, it is acceptable to use schemas that are a close match.
Developers can pick and choose functionality based on available app schemas.
For concepts that don’t fit a schema, use the generic system.search capability for integration with Apple Intelligence.
App Shortcuts can also be used for custom integrations, requiring developers to provide sample phrases.
Adopting schemas can let developers delete code — the platform handles more of the integration logic.
Adopting an app schema means Apple handles phrase training and provides a consistent experience.
Intent donation allows Siri to learn from user actions (e.g., “message Dan”) over time.

How do image inputs affect the Foundation Models 4,096 token budget?

For the on-device model, the context size is 4096 tokens. Image input typically consumes around 200 tokens.
Developers can use the full 4096 tokens for instructions and prompts.
With Private Cloud Compute (PCC), the context size is 32K tokens.
Token counting APIs are available to measure usage.
For optimal performance, especially with smaller models, tailor prompts, use synonyms, and include examples.

Coding Intelligence for Beginners

Miká Kruschel — Thu, 11 Jun 2026 00:00:00 GMT

Coding Intelligence for Beginners

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

How has app development changed with the introduction of agents?

Agents allow developers to articulate ideas and make them more tangible, creating a codified spec that can be iterated upon.
The agentic flow verifies and fixes errors, enabling faster realization of ideas and fostering creativity by reducing the cost of writing and deleting code.
Developers are more emboldened to explore different paths and try ambitious features for users.
Agents help make practices like testing and localization easier, though many developers had delayed these before agents existed.

Where can I learn about commands like `/plan` and other agent commands?

Xcode displays compatible commands when an agent provides a list or when typing /.
Developers can ask the agent directly for help; it is aware of most executable commands and their functions.
Experimenting with commands and asking the agent for help can reveal new workflows.

What unique advantages does Xcode’s built-in coding intelligence offer over external AI agents?

Xcode’s agent understands project layout and Apple platform development, leveraging tools that surface SDK and API information.
It includes documentation tools for exploring new APIs and validation tools for checking its own work, such as building and code execution validation.
Xcode offers access to app-specific data like crash data and localization best practices, with Apple-specific knowledge baked in.
Xcode’s preview system allows agents to visualize their work, and the overall experience is designed to be well-crafted and welcoming.
Xcode provides out-of-the-box guidance and a planning mode to help developers onboard effectively with agents.
Agents, onboarding flows, and tool integrations can be extended with plug-ins.

Does Xcode’s UI indicate the amount of agentic resources being consumed?

Yes, the agent provider will have a slash command to access this information.
There are typically two indicators: one for the primary context window’s fullness and another for the cost or usage so far.
This information is not directly in the UI; developers must ask the agent for it.
For specific UI surfacing requests or use cases, file feedback via feedbackassistant.apple.com.

How can the Xcode AI agent access implementations from other projects for cross-project references?

Xcode uses permission prompting by default to control agent access.
An experimental managed security mode allows gating agent actions at the file system level.
If a project is referenced within the Xcode workspace, the agent can access it.
For external files, developers can paste file paths or direct the agent to directories like “Documents” for exploration.
Xcode workspaces are recommended for combining multiple projects, allowing the agent to see all relevant pieces.
Agents always ask for permission before executing tools that might modify or delete files.

How can beginners understand code generated by coding intelligence if it doesn’t explain itself?

Ask the agent directly for explanations; it can provide them in various formats like HTML reports or Markdown.
Configure agents to always provide an explanation after a prompt, specifying the desired format.
Create parallel conversations in Xcode 27 to ask questions about generated code or new APIs while the agent is working.
Bake explanations into the initial prompt by asking the agent to state assumptions and implementation details.
Define the structure of code (e.g., structs, protocols) with comments and then have the agent fill in the gaps.
Use plan mode to understand the agent’s approach to a problem before code is implemented.
Ask the agent to host a “game show” with trivia questions about the code to aid understanding.
Create architecture documents or diagrams to visualize data flow and feature construction.

What are common mistakes made by coding assistants that beginners might miss?

Agents may misunderstand assumptions, leading to incorrect or unmaintainable code, or providing something completely different from what was asked.
Agents might “cheat” by not passing tests and justifying it with debug configurations, which should not be accepted.
Fallible tools like agents require vigilance, unlike compilers.
Validation tools in Xcode are crucial for catching issues early.
Developers’ surprising workflows can highlight areas for improvement; feedback is valuable.

Does Xcode Coding Intelligence have an undo button for agent changes?

Developers can ask the agent to revert its work, and it can usually do so effectively.
Xcode tracks states across turns with the agent, allowing developers to revert to a previous state using a history slider, provided a Git repository is initialized.
Git provides the broadest rollback capability.
Xcode’s history feature offers granular rollback for the last action.
Agents can reason about their own work and undo specific parts while preserving others, especially useful with parallel work.
Using Git is highly recommended for all developers, even solo ones, for reverting issues and releasing fixes quickly.
Commit messages are important for documenting assumptions and aiding future understanding.

How can experienced iOS developers with little AI assistant experience develop the skills needed for AI-assisted development?

Start simple by integrating agents into existing workflows for small changes or bug fixes.
Work on tasks developers already know how to do to quickly compare agent results with custom work and build confidence.
Iteratively expand to more complex capabilities as becoming more comfortable.
Leverage the existing industry experience; guide and direct the agent to shape code, architectures, and validation loops.
Use agents as a powerful find tool or planning aid when developers are uncomfortable surrendering control.
Review all changes and use plan mode to verify implementation details.
Consider sessions like “Xcode Agents and You” for workflow ideas.
Approach problems top-down (e.g., defining interfaces) or bottom-up (e.g., implementing function bodies).

What are the key differences between agent mode and chat mode in Xcode?

Agent mode offers significantly more capability than chat mode.
Predictive completion operates on a seconds horizon; chat mode handles ~30-second tasks; agent mode can work for 30 minutes to 1.5+ hours.
Chat mode provides a limited set of tools (10-15) for interacting with the codebase.
Agent mode allows agents to use an “infinite” number of tools, including command-line tools and nearly 60 tools within Xcode.
Agent wrappers provide superpowers like context management and spawning other agents.
A couple of bundled Xcode agent UI integrations are open source and configurable for local models via ACP.

What features are lost when using local models instead of cloud models in Xcode?

Developers can plug local agents into local models and utilize many agentic tools.
The primary difference is the potential lack of access to extremely large, powerful models hosted on specialized cloud infrastructure.
Local models may require more guardrails and robust validation steps to ensure accuracy.
ACP (Agent Client Protocol) allows Xcode’s toolset to be available to local agents.
The “super genius” capability of large cloud models might not be matched by local models, but significant work can still be accomplished.
It’s important to test local models and settings to find the right balance of speed, accuracy, and privacy for the project.
The “vibes” or how it feels to use the tool is a key factor in choosing models and agents.
Consider developing a scorecard to evaluate local models against the project’s specific needs.
Not all large models provide significantly better results; smaller models can be very effective.

Is it possible to connect Xcode coding intelligence to a local LLM like one hosted via MLX LM server, and use it in agent mode (not just chat mode)?

Yes, ACP support enables this.
Developers can use open-source tools and wrappers like OpenCode with local model support.
ACP allows integration of local agents and models within Xcode.

What are the privacy implications of using third-party LLMs in Xcode?

When enabling a coding agent with a partner, review their terms and conditions regarding code usage for training.
You are in control of whether the agent provider can use the code for training.
Settings within the account for model providers specify what they can and cannot do with the code.
Apple does not see the code or queries when using third-party LLMs; data is sent directly to the provider.
When developers submit a feedback report, Apple will see the context the provided.

What’s the best way to work with AI in Xcode while offline, without a high-end machine?

Use MLX to run larger, more interesting models on devices.
Implement strong guardrails and constraints, such as requiring agents to pass unit tests.
Use a larger model offline for planning and requirements, then use local agents to document assumptions.
When back online, use a larger model to double-check those assumptions.
Combine larger models with smaller, local models by having them critique each other’s work (e.g., via Markdown files).
Xcode allows configuring multiple agents and models to switch between online and offline versions.
The session “Run Local Agentic AI on Mac Using MLX” is recommended.

What does Xcode offer beyond terminal-based coding agents?

Xcode provides a powerful set of tools and a superior user experience compared to a linear terminal flow.
Xcode visualizes changes and evolution of code in a dedicated area next to the conversation.
It leverages Xcode’s full context, including open files, active schemes, and project settings.
Xcode is an ensemble of tools (Instruments, Preview, Device Hub) that agents can control, offering capabilities not available in a terminal.
The combination of prompts with Xcode’s project context (Git history, crash data) leads to more accurate initial solutions.
Xcode offers a visually rich experience with rendered Markdown and previews, providing a different way to see results.

Is it possible to use local AI models for coding intelligence with Xcode 27? What’s the suggestion to balance speed, accuracy, and privacy?

Yes, watch the “Run Local Agentic AI on Mac Using MLX” session for guidance.
Balance speed, accuracy, and privacy by using larger models for planning and smaller local models for tracking work or assumptions.
Experiment with different local models and their quantizations to find what works best for the project.
The “vibes” or user experience is a key factor in choosing models and agents.
Develop a scorecard to evaluate models against the project’s specific needs.
Not all large models are better; smaller models can be equally or more effective.
Dynamically change and swap models on the Mac depending on the task.

Can Xcode coding intelligence use on-device foundation models without third-party providers?

Yes, by running local agents with local models.
Refer to sessions like “Run Local Agentic AI on Mac Using MLX.”
Macs, especially with M-series chips, are powerful enough to run large models locally.

Is there a beginner’s guide or document that gives an overview of AI coding intelligence topics, rather than just hands-on tutorials?

The “Xcode Agents and You” session provides illustrative diagrams and breaks down what agents are doing, offering a powerful understanding.
Talking to other developers and exchanging best practices is a great way to learn.
Don’t overthink it; the onboarding process is designed to be seamless.
Use plan mode in Xcode to understand exactly what the agent is doing and ask questions about its approach.
Xcode’s integration allows trying agents with less risk compared to a full terminal overhaul.
Community resources and techniques from other IDEs are generally transferable to Xcode.
Reviewing documentation for agent providers and observing how others use them can be helpful.
There isn’t one “right” path; experiment and borrow from what others use.
Best practices evolve rapidly with new models, so continuous testing is key.

How can agents stay current with the latest APIs?

Xcode includes tools dedicated to searching new API documentation efficiently.
Downloading Xcode also includes the latest documentation, including versions optimized for models.
Agents can tap into this documentation to get the latest API information and add it to their context.
Xcode ships with specialist skills for new features (e.g., resizability in iOS 27).
Project-level agent configuration files (e.g., AGENTS.md) help steer agent behavior.
Developers can ask the agent to “search documentation” or inquire about new APIs in specific OS versions.
Xcode provides this documentation tool regardless of the agent provider (local, Claude, Gemini), ensuring agents have access to the latest APIs.
Documentation is updated as a separate asset and downloaded automatically into Xcode.

SwiftUI

Miká Kruschel — Thu, 11 Jun 2026 00:00:00 GMT

SwiftUI

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

How can very large reorderable SwiftUI lists be optimized?

SwiftUI is aware of performance issues with very large lists and is investigating.
File feedback with the specific use case, detailing why developers need to display that many items and the nature of the data structure.
This feedback helps the team ensure APIs support diverse use cases.

What is the `NavigationTransition` protocol, and are custom transitions supported?

The NavigationTransition protocol allows SwiftUI to expose types that conform to it for navigation transitions.
Currently, there are predefined transitions like crossfade, zoom, and automatic.
These transitions apply to sheets as well as navigation stacks.
Use AnyNavigationTransition to switch between transition styles (e.g., crossfade vs. zoom).
For custom transitions not tied to a navigation stack, developers can drive animations using modifiers and Animatable.
If developers need custom navigation transitions, file feedback with the use case to inform future API development.

How can coding intelligence help SwiftUI development with Liquid Glass?

Xcode’s new coding skills provide insights into new APIs and best practices.
Use Xcode’s preview rendering for iterating on designs like Liquid Glass.
Skills are usable with the model of choice, allowing for experimentation.
Skills can be exported for use with other agentic systems.

How should the glass effect be applied to buttons and other UI elements?

Buttons in navigation bars and top toolbars automatically adopt a glass appearance.
For custom glass effects on buttons, use the glass button style or glass prominent style.
Consider using buttonBorderShape for specific button shapes.
Avoid applying glass effects within the content area of a view unless there’s content to refract; often, simpler designs are better.
To hide the glass background on toolbar items (e.g., for profile photos), use sharedBackground(hidden: true).
New APIs allow removing content margins from toolbar buttons while keeping the glass rim aligned on push and pop transitions.

What is the best way to manage screen sizes and window resizing in SwiftUI apps?

Avoid hardcoding for specific window sizes; aim for layouts that adapt to any size.
Use ViewThatFits to pick the best layout variant for the available space.
Utilize size classes to define different user experiences (e.g., multi-column for regular, constrained for compact).
Ensure true flexibility beyond just size class transitions, as windows can occupy intermediate sizes.
Consider using system containers like TabView (which can adapt to sidebars) for built-in responsiveness.
Custom layouts and custom containers offer powerful ways to create flexible, reusable controls that adapt to various sizes.
Use AnyLayout to maintain structural view identity when switching between different layouts.

When should `GeometryReader` be used versus `onGeometryChange` for handling size changes?

onGeometryChange is generally preferred for reacting to size changes, especially for breakpoint-based layouts.
onGeometryChange has two closures: one for real-time geometry, and another to determine when an action should be called, allowing for threshold-based updates.
Using GeometryReader within subviews can be expensive; onGeometryChange is more efficient.
Avoid view invalidations on every frame; onGeometryChange helps limit updates to when thresholds are crossed.
For precise placement and complex layouts, combine onGeometryChange with custom layouts.
Alignment guides can also be used for efficient, single-pass layout solutions.

What are the best practices for learning data management and passing data between views in SwiftUI?

Focus on making views lightweight and mapping information to view data.
Build self-contained state machines and logical components.
When view code becomes messy, simplify the model or logic layer data.
SwiftUI is architecture-agnostic; build apps modeling different data types to discover appropriate patterns.
Build sample apps in domains developers are familiar with to stay motivated and focus on solving the problem.
Use Instruments’ SwiftUI timeline to understand data flow and how data updates affect view bodies.
Consider using dynamic properties to replace onChange for more efficient updates that occur before body renders.
Avoid using onChange to mutate view state; prefer a data model that vends new values as others change.
Critically evaluate the usage of APIs like AnyView and onChange to ensure they are justified and not used as a crutch.
For asynchronous loading (e.g., images), use dynamic properties to vend cached values before the body renders, avoiding unnecessary re-renders.
onAppear timing now aligns with Task due to Swift concurrency improvements in iOS 27 — no extra isolation hop between them.
Wrapping views in AnyView can block container-value and preference propagation; be aware when using type erasure in layout containers.

What is Apple’s recommendation for conditionally hiding elements, and what are the implications of using `if` statements?

For visual hiding, use modifiers like opacity with a conditional expression. This keeps the element in the view hierarchy.
If developers need to remove an element from the layout entirely, conditionalizing its presence is acceptable.
Avoid using if statements at the top level of views within lazy containers (List, LazyStack) as it can prevent views from being deallocated and lead to unexpected behavior.
Wrap conditional branches within lazy containers in a unary container (e.g., VStack, Group, AnyView) to ensure a single view is always resolved.
Conditionalizing view modifiers can be problematic if the modifier doesn’t have an “inert” state, potentially causing unnecessary relayouts or state resets.
Prefer passing inert values to modifiers or using conditional logic within the modifier’s arguments rather than an if statement.
Be cautious with if statements inside view modifier bodies, as they can lead to unexpected state resets due to view hierarchy changes.
Some SwiftUI modifiers are intentionally static for performance; switching these on the fly may require an if-else structure.

What are the concrete costs of type erasing with `AnyView`, and when is it a concern?

AnyView is useful when the type of a view is unknown at compile time.
The primary cost arises when the underlying type of AnyView changes, which tears down and rebuilds the view hierarchy.
Avoid changing the underlying type of AnyView frequently to maintain performance.
In lazy containers, AnyView can prevent the container from determining the number of resolved views, potentially requiring wrapping it in a unary container like VStack.

What are some tips for making SwiftUI layouts more adaptable, especially with resizable Xcode previews?

Design custom layouts to accept any size as an input parameter and handle it reasonably.
Use resizable previews and test the app on resizable devices (like iPad) to identify assumptions and layout breaks.
Observe how other apps and websites handle resizing for inspiration on creative space utilization.
Identify “magic numbers” in the layout code that cause breaks at different sizes and refactor them.

How can full-screen SwiftUI overlays appear above sheets?

Presenting a full-screen overlay on top of existing modals in SwiftUI can be challenging with current APIs.
Consider coordinating the navigation and data models to manage presentations effectively.
For complex layering needs, dropping down to UIKit and using a UIWindow or UIWindowScene might be necessary.
Developers can host SwiftUI views within a UIKit UIHostingController in a UIWindow.
Be mindful of the “last UI window wins” principle if multiple UI windows are created.
Evaluate if a full-screen cover is the most appropriate design; consider alternative flows like rewinding the navigation stack.
File feedback with the specific use case when developers encounter limitations with SwiftUI’s current presentation APIs.

How can a SwiftUI custom control expand over other elements?

Consider using existing UIKit or AppKit controls via framework interop if a suitable control already exists.
SwiftUI is compositional; developers can combine building blocks to create powerful custom controls.
To avoid impacting the layout of other elements, a child view can report a stable size to its parent while drawing larger using overlay.
Be aware that drawing outside reported bounds in a ScrollView might lead to views being removed from the hierarchy.
overlay provides isolation and prevents affecting surrounding layout.
Custom controls require careful consideration of edge cases, such as how they behave during scrolling or user interaction.
Consider using custom styles for existing controls before building a completely new custom control to leverage built-in accessibility and behaviors.
SwipeActions can now be applied to any container using the swipeActionsContainer() modifier (not just List), and the actions themselves can be any view.

How small should SwiftUI views be broken down for performance?

Breaking views into smaller pieces is about isolating data dependencies that trigger updates.
Split views when different parts of the UI can update independently to avoid unnecessary re-renders of the entire view.
If dependencies are shared across all parts of a view, splitting it won’t provide performance benefits.
The goal is to create boundaries where SwiftUI can determine if a view needs to update.
View builder computed properties do not offer the same isolation as separate struct views, as they are functionally part of the same view body.
Aim to group related dependencies. A view re-evaluates if any of its inputs (bindings, environment, etc.) change.
Move frequently changing dependencies and their associated UI logic into separate, smaller views to prevent larger, less frequently changing parts from re-rendering.
Use Observable objects to allow subviews to update independently without triggering updates in their parent views.
Don’t be afraid of creating many small views; struct views are value types and are inexpensive.

What are notable SwiftUI accomplishments from the framework’s evolution?

Custom Containers API: Distilled complex concepts into an essence that enables powerful user creations.
Semantic Pieces over Device-Specific Rendering: Rethinking UI systems in terms of data flow and semantic components (e.g., TabView behaving as standard tabs or a paginated scroll view).
Internal Adoption and Maturity: SwiftUI is now mature enough to be used for core UI components across Apple’s applications, even those not fully rebuilt in SwiftUI.
Team Collaboration and Culture: The strong team dynamic, shared humor, and collaborative problem-solving are as important as the framework itself.
API Evolution based on Usage: Identifying suboptimal patterns (like GeometryReader) and introducing new APIs (onGeometryChange, onScrollVisibilityChange) to address user needs.
Exposing Lower-Level Building Blocks: Providing tools that were previously internal, enabling developers to build more custom and innovative experiences.

watchOS

Miká Kruschel — Thu, 11 Jun 2026 00:00:00 GMT

watchOS

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

How do Foundation Models run on Apple Watch?

Foundation Models on watchOS do not run directly on the device. They require a network connection to a language model provider, such as Private Cloud Compute (PCC) or other conforming protocols.
FM on watch does not relay through the iPhone’s on-device model — it uses the network directly.
Official support for Claude and Gemini is expected soon.
Developers can conform to the LanguageModel protocol themselves.
Use cases include summarizing text for the watch display and making dense text more accessible.

What are the considerations for using Foundation Models on watchOS, especially regarding network connectivity?

Developers must check if Foundation Models are available before making calls.
Using PCC requires a specific entitlement.
Plan for fallback scenarios, such as reaching API quotas or token usage limits with language model providers.
Network latency is a factor, so carefully consider the timing and frequency of model calls.

What are the core architectural paradigms and pitfalls for iOS developers moving to watchOS, especially for heavy off-main thread work like CloudKit syncing?

Many familiar APIs like URLSession and CloudKit work on watchOS.
Swift Async can be used for off-main thread work.
The system enforces strict limits to preserve battery life and runtime, leading to watchdog timeouts.
Developers should be mindful of the watch’s lower core count and performance constraints compared to iOS.
Focus on designing experiences tailored for the wrist, prioritizing glanceability, conciseness, and immediate interaction.

What are unique opportunities for developers on watchOS, beyond building a full watch app?

Live Activities: These appear on the lock screen and can be customized for the Smart Stack without needing a separate watch app.
Controls: Developers can add controls to the watchOS Control Center, which can be automatically surfaced if they are present in the iOS app.
These system experiences offer a lightweight entry point to the platform and provide personal, immediate interactions.

What are the recommended modern ways to render 3D graphics on watchOS now that SceneKit is deprecated and RealityKit is not available?

While SceneKit is deprecated, it can still be used.
The recommended modern approach is to use SwiftUI Canvas.
SwiftUI Canvas is a well-featured graphics library suitable for the watch platform and runs on the GPU for performance.
Developers should consider transitioning away from SceneKit for watchOS development towards SwiftUI Canvas.

What are some underutilized capabilities of watchOS that developers might not know about, encouraging them to extend their apps to the device?

CoreMotion Sensor Data: Developers can track device motion for novel experiences, such as a tennis game using watch sensors as a peripheral for visionOS, or tracking hand steadiness for activities like pottery.
Proactive Experiences: Leverage system features like Live Activities and the Smart Stack to proactively deliver timely information and actions to users based on their real-world context (location, time, semantic locations like “at work”).
Widget Suggestions: Associate widgets with specific contexts to ensure they are relevant to the user’s current situation.
Be judicious about surfacing content to avoid users dismissing the app if it appears too often.

What are the key considerations for designing effective Live Activities and Smart Stack widgets on watchOS?

Relevance: Ensure content is highly relevant to the user’s real-world context (location, time, activity).
Timeliness: Surface information when it’s most useful and avoid occupying prime real estate for extended periods.
Alerting vs. Passive Updates: Differentiate between critical alerts (e.g., delivery arrived) and passive status updates.
Noise suggestion: Use softer reminders before full alerts when appropriate (e.g., a gentle nudge before a sports score alert).
Smart Stack Suggestions: Use suggestions for softer reminders or when an alert isn’t immediately necessary but the information is still valuable.
User Dismissal: Design experiences that users can easily dismiss once the information is no longer needed.

What’s new for Liquid Glass on watchOS in version 27?

Refinements include updated visuals with darker edges and speculars for better content separation and legibility.
Significant performance improvements have been made.
Interactive glass experiences, like dragging buttons, are now available and fun to use.
For many apps, especially those using the watchOS 10 design language, Liquid Glass updates are automatic.

Do developers need to do anything specific for watchOS 27 to use Liquid Glass effectively?

For most developers, especially those already using the watchOS 10 design language, no specific actions are required.
The new Liquid Glass designs and updates are automatically applied.

Are personal settings for Liquid Glass (like tint or clarity) synced from iOS to watchOS, or is there a separate watch-level preference?

There is no separate watch-level preference for Liquid Glass tint or clarity.
The design decision was made to preserve legibility on the primarily dark watch interfaces without needing a user-adjustable slider.
Accessibility features like “Reduced Transparency” and “Increased Contrast” are available on watchOS.

What are some “hidden gems” in watchOS 27?

Workout Zones API: This API, requested for years, provides flexible and easy-to-use workout zone boundaries for heart rate and cycling power. It includes rich time-in-zone data useful for both real-time tracking and post-workout analysis.
Reorderable API: New in SwiftUI and available on watchOS, this API allows developers to easily implement reorderable collections, used internally for Control Center.

General Guidance: No significant new guidance for watchOS 27, but good practices remain. Widgets on the watch face have higher priority than those in the Smart Stack.
Update Frequency: Expect widgets to update every 15-20 minutes if actively used. Smart Stack widgets update based on user engagement.
Update Mechanisms:
- Invalidation: Invalidate widgets from the app when new data is available.
- Timeline Reload Policy: Set an expiration for the widget’s timeline for more deterministic refreshes.
- APNS-based Refreshes: Available since watchOS 26 for server-pushed updates.
- Watch Connectivity-based Refreshes: New in watchOS 27, allowing phone-to-watch updates.
Widget Types:
- Timeline-based Widgets: Suitable for frequently updating data like weather or calendars.
- Relevant Configuration: Use when a widget is relevant at specific places or times.
- Live Activities: Ideal for session-based experiences (e.g., sports games, ride-sharing) with a defined start and end, offering more runtime for updates.
- Controls: For performing quick actions.
Documentation: Refer to “Keeping The Widget Up to Date” on the developer website and the Widget Kit Foundations video from WWDC26.
Feedback: Provide feedback on any unmet needs or friction points.

What are the best practices for optimizing heavy asset fetching on a standalone watchOS app’s first launch without relying on Watch Connectivity?

Bundle Essential Assets: Include critical assets needed for the initial launch directly within the app bundle.
Provide a Useful Initial Experience: Offer users something to interact with or see immediately, rather than just a spinner, while background downloads occur.
Prioritize Background Downloads: Utilize background URLSession for fetching non-essential assets after the initial launch.
Consider Offline Scenarios: Design for situations where the user may not have connectivity on first launch, ensuring a graceful experience.
Mask Complexity: Craft the user experience to hide the complexities of asset downloading and provide a delightful interaction.

How is physical watchOS debugging done in Xcode 27?

Xcode 27 improves install and symbol-sync reliability for physical watch debugging.
Device Hub supports direct Mac-to-Watch connection without routing through the iPhone.
Use 5 GHz Wi-Fi for best results; corporate networks may block peer-to-peer connections.
If issues persist, file feedback with logs from the failing session.

What are notable new watchOS 27 features?

Workout Buddy insights for training guidance.
Siri AI on Apple Watch — coming but not in beta 1.
Smart Stack holiday surprises and general widget performance/reliability improvements.

Xcode Tips and Tricks

Miká Kruschel — Thu, 11 Jun 2026 00:00:00 GMT

Xcode Tips and Tricks

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

What are the most useful Xcode tips and tricks that most people may miss out on?

Use the #Playground macro in any Swift file to run code snippets and see expression results, similar to a playground.
Cut text to move to a new file, focus on the file navigator, and paste to create a new file with the content. Xcode will guess the filename.
Use “Find Call Hierarchy” to quickly understand where a function is being called from, including nested calls.
Use Command-Shift-J to navigate to the current file’s location in the project navigator.
Use Open Quickly (Command-Shift-O) to search for functions or files to quickly navigate the project.
Combine Command+Shift+J (reveal in navigator) with Open Quickly: find a symbol, then reveal its file location.

Which recent Xcode features deserve more attention?

Convert Xcode groups to folders (blue folders in the navigator) to significantly reduce project file conflicts, especially on large teams.
Folders do not record the list of files, leading to fewer diffs in the project file when adding new files.
Edit schemes to set different user defaults for testing specific features.
Filter the console output to debug more effectively by focusing on specific components or categories.
Use the filtering feature in many Xcode menus (including the jump bar) by typing to filter the menu items.
Pass arguments to SwiftUI previews to render multiple variants (e.g., light/dark mode, dynamic type sizes) in a single preview.
Open memory graph debugger .memgraph files in Instruments to see allocation timelines, which can provide more detailed memory footprint information than the memory graph debugger alone.
Use conditional breakpoints with specific conditions or repetition counts to trigger them only when needed, avoiding constant pausing.

What are the most underrated Xcode features that even experienced developers don’t use enough?

Convert Xcode groups to folders to reduce project conflicts.
Different themes per workspace in Xcode 27 — set a distinct theme for each project to tell them apart at a glance.
Change the debug bar appearance to distinguish the debug Xcode from the daily-driver Xcode.
Pin tabs within the SwiftUI canvas to maintain previews while navigating other files.
Use Xcode Cloud for automated builds and deployments, simplifying workflows.
Leverage Xcode’s powerful search capabilities, including regular expressions and symbol searches.
Combine the search field with the filter field in the find navigator for boolean-style searches.
Press Delete in the Find navigator to remove individual results and narrow scope.
Command+click disclosure triangles to collapse sibling groups in the navigator.
Use the type hierarchy queries (up to root and down to leaves) to understand protocol conformance and subtypes.
Utilize Instruments’ profiling tools, especially flame graphs combined with top functions, for performance analysis.
Use the SwiftUI instrument template for specific SwiftUI performance debugging.
Save custom instrument templates for repeated profiling use cases.

What caveats should we be aware of when running Xcode 27 beta on the same machine with Xcode 26?

Running multiple versions of Xcode simultaneously on the same machine is supported.
Xcode 26 may not run on macOS Golden Gate — plan the xcode-select setup accordingly.
Xcode 27 offers an optional stricter project validation checkbox; be aware when opening projects across versions.
The primary visual difference might be theme customization, with one version appearing more colorful than the other.

What tips and tricks can minimize merge conflicts in `.xcodeproj` files without using third-party tools?

Convert Xcode groups to blue folders to significantly reduce project file size and conflicts.
Ensure blue folder targets align closely with the source code they contain to minimize project file entries.
When converting groups to folders, resolve any preflight errors first, commit those changes, and then complete the migration.
In the project inspector, check the “minimize cross-project references” option for projects created in the last several years to reduce project file size.
Manage build settings in .xcconfig files to keep them separate from the project file.
Use the help inspector in the build settings editor to find the exact name of build settings.
Copy build setting rows to easily get the key name for .xcconfig files.
.xcconfig files provide an audit trail, comments, and are easy to review in pull requests.

Are there any cool tricks with Markdown in Xcode, and are there any improvements on the source control side of things?

View Markdown files in rendered or source code form directly within Xcode.
Edit Markdown files seamlessly within the editor, including within agent transcripts or plans.
View rendered Markdown side-by-side with the source code using the canvas preview button.
Xcode’s source control navigator has been re-engineered for better performance, especially with repositories containing millions of tags.
Xcode now uses red and green for diff colors, which can be customized in themes.
Feedback on source control features, like multi-select for stashes, is actively encouraged.

When a Swift Package Manager package updates its macros, Xcode requires manual re-approval. Can macro trust be pinned to a package identity instead of requiring re-approval on every update?

This is a specific use case that warrants filing feedback with details about the package and the workflow.
The team is surprised that trust is invalidated on every update and wants to investigate further.

Is there a way to open the terminal on the project root folder in Xcode?

Not directly, but developers can open Terminal and drag a file reference from the navigator into it to change the directory.
The file inspector now lists the “working copy relative path,” which can be copied and pasted into the terminal.
Filing feedback for this functionality, similar to “Show in Finder,” is recommended.

What are the most useful Xcode keyboard shortcuts?

Command-Shift-J: Show the current file’s location in the project navigator.
Command-Shift-Y: Show and hide the debug area.
Control-Option-Command-G: Rerun the last test.
Command-Option-P: Refresh previews automatically.
Control-6: Open the rightmost element of the path control above the editor, allowing scoped “Open Quickly” within the current file.
Command-Option-Up/Down: Switch between implementation and header files in Objective-C.
Command-Shift-O: Open Quickly for navigating to symbols or files.
Command-Control-R: Launch without building.
Control-Backslash: Jump to the next diff in the current file.
Command-Backslash: Toggle comment for a line or selection.

What are the most common beginner mistakes in Xcode, and how do I avoid them?

Trying to learn all Xcode features at once; focus on essential tools like the source editor, inspectors, and navigators first.
For code signing, use automatic signing for most cases, as manual signing can be complex for beginners.
Customize the toolbar to simplify the setup and focus on frequently used controls.
Start with a new project and immediately see results on the right-hand side, or use playgrounds for quick experimentation.
Xcode 27 can create a blank project without the template modal for a faster start.
Use agents to help reorganize code, but review the results carefully.
Use source control (Git) from the start of any project, even for solo developers, as it’s the best undo system.
Avoid profiling on the simulator; always profile on an actual device for accurate data.
Do not profile debug builds; compiler optimizations can skew results.
Adopt modern frameworks like Swift concurrency and SwiftUI.
Consider rewriting small open-source projects to learn Xcode and general programming concepts.
Watch code-along sessions to see tools integrated into workflows while learning new concepts.
Organize the project structure from the beginning, even for small projects, using folders.
Experiment in small contexts like sandboxes or playgrounds before organizing larger projects.

What are the most efficient workflows for generating and maintaining DocC documentation alongside active development?

Write documentation comments in the source files; they will appear in the documentation preview assistant.
Host a DocC archive as a static website for pull request reviews.
Use the documentation preview assistant to view rendered documentation.
Consider using agents to add documentation comments, but review them to ensure they don’t reveal implementation details.
Write articles before releasing features to help internal developers learn them.
Images in documentation can be configured to automatically swap between light and dark mode.
DocC is open source; check its repository for implementation details.
Use the generative AI search feature on developer.apple.com to find resources on DocC.

Which settings or practices can improve build time significantly?

Use Command-Control-R (Run Without Building) when code changes are not needed for debugging.
Modularize the project into separate packages or frameworks to isolate changes and reduce rebuilds.
Use the build log’s assistant editor to analyze the build timeline and identify performance bottlenecks.
Opt into build settings that warn about slow Swift expression type-checking and break down complex expressions.
Be cautious with script phases; ensure they only run when necessary and declare their inputs and outputs.
Consider explicit modules and Swift’s private/internal import features to manage dependencies and reuse build products.
Consult Xcode forums for specific build performance use cases and problems.

How can Xcode previews load faster without waiting for simulator relaunches?

Ensure good overall build performance, as previews share build artifacts with the main build.
Once a preview is running, Xcode performs minimal work to reload the current source file and update the preview.
Modularizing the project can also improve preview load times by optimizing build performance.

For automatic code formatting, how can I integrate SwiftFormat into Xcode effectively?

Integrate SwiftFormat to run on build, on save, or as a pre-commit Git hook.
Running SwiftFormat as a pre-commit hook is less disruptive and ensures formatted code is committed.
Running SwiftFormat when a pull request is ready for review is also a good practice.
Filing feedback is recommended for specific workflow issues encountered when integrating SwiftFormat.

What are the most underutilized LLDB commands or breakpoint actions for isolating state changes without stopping execution?

Use breakpoint actions to “Play Sound” for audible feedback when a breakpoint is hit.
Use breakpoint actions to “Log Message” to print diagnostic information without pausing execution.
LLDB allows calling any LLDB command from breakpoint actions.
Conditional breakpoints can be set based on modifier keys (e.g., Shift key) to trigger at a precise moment without constant pausing.
Breakpoints can be configured to skip a certain number of hits before triggering.
The “Variables View” in LLDB is often more useful than the po command for inspecting scope values.
Use p/x in LLDB to print hexadecimal numbers, useful for debugging low-level code.
Intentionally pausing the program without a breakpoint can help identify where the program is stuck if logging is insufficient.
Breakpoint actions can be used to print debugging statements without committing them to the codebase.

Can Xcode show unused vars, properties, and functions?

Xcode shows warnings for unused variables because the compiler can reliably determine their lack of use within scope.
Public properties are not flagged as unused because their usage cannot be reliably determined due to their public accessibility.
Feedback is welcome for use cases where developers expect unused code to be flagged but Xcode does not.
“Find Call Hierarchy” can help identify callers of a function, but it’s not a comprehensive solution for all unused code.
Third-party tools may offer more extensive unused code detection.

When should derived data be deleted, and what else fixes haunted builds?

Deleting derived data is not a superstition; it can resolve issues caused by build system race conditions or outdated build artifacts.
Xcode 27 adds a Delete Derived Data menu item for easier cleanup.
Common reasons for deleting derived data include build order dependencies between targets, disk space issues, or working around build system bugs.
Xcode 27 has improved build system reliability, reducing the need to delete derived data.
When developers frequently need to delete derived data, file a bug report with reproducible steps so the build system can be improved.
Swift build is open source; developers can examine its source code to understand build system behavior.
Other options when a build is “haunted” include using “Clean Build Folder” or disabling parallelized builds to identify missing dependencies.
When developers still find yourself deleting derived data, please provide feedback to help improve the experience.

Can Xcode show when agent context compression occurs?

Filing feedback for a compression indicator and a pause before editing mode is recommended.
Consider using “Plan Mode” to write artifacts to disk, making context persistent and accessible to the model.
Creating artifacts that can be referenced helps maintain context across sessions or when switching between models.
Be mindful that CLAUDE.md files loaded into context increase context size. Feedback on workflow impediments is highly valued.

How can signing and provisioning profile mismatches be mitigated in Xcode?

Avoid using distribution certificates for release configurations when debugging or using tools like Instruments, as they require debuggable builds.
Do not disable the “Code Sign Injects Base Entitlements” setting to work around issues.
Use automatic signing for local development.
Xcode Cloud handles signing automatically, simplifying CI workflows.
For local development, use regular signing for debug and release configurations; distribution signing is only needed for App Store uploads.
When developers encounter specific code signing issues, consult developer.apple.com/forums for community and engineer support.

How can Xcode code folding suppress noise and surface high-value logic?

File feedback detailing the desired workflow and what constitutes “visual noise” for the use case.
Organize source code by splitting definitions across multiple extensions or files to contain less critical code.
Explore Xcode’s editor menu for code folding actions that might suit the workflow.

Camera and Photo Technologies

Miká Kruschel — Wed, 10 Jun 2026 00:00:00 GMT

Camera and Photo Technologies

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

Does iOS 27 tag AI-edited photos with metadata or content credentials?

Yes, the file’s metadata is modified with IPTC and EXIF metadata.
IPTC metadata is updated based on the specific AI modification performed (spatial, reframe, or cleanup).
In the Photos app, the info panel displays which edit was used after modification.

Will there be an API for third-party apps to use or edit keywords in Photos?

Keywords are a feature available in the Photos app on iOS and Mac, accessible via the info panel.
Keywords will be reflected in IPTC metadata when exporting images.
Currently, there is no PhotoKit-level API for fetching or querying based on these keywords.

What is the optimal way to load thumbnails in a lazy grid with matched geometry?

On the Core Graphics side, use openImage(withThumbnails:) which internally utilizes existing thumbnails or decodes and scales down the main image quickly.
On the Core Image side, request a scale factor when opening images to instruct Core Image to scale down the image as early as possible.

Can Deferred Start cause issues where the user may attempt to capture a photo before the capture photo output has attached to the session?

Yes, if only deferred start is used, developers may miss a shot.
Deferred Start was introduced in iOS 26.
To prevent this, set the isResponsiveCaptureEnabled property on the AVCapturePhotoOutput to true.
This enables system buffering, allowing quick launches and captures even if the output hasn’t fully initialized, ensuring the moment is not missed.

What is the best way to get the depth map and the image for a live viewfinder and for the taken image to create a nice 3D effect with both?

For the preview side, enable depthDataOutputEnabled on the preview stream and use AVCaptureSynchronizer to synchronize with the RGB stream.
For the still capture side, set depthDataDeliveryEnabled on AVCapturePhotoSettings to get depth with the still capture.
Alternatively, for a live depth effect in preview, enable cinematicVideoCaptureEnabled on the device input for a simplified solution.
To access actual depth samples for custom processing, use AVCaptureVideoDataOutput and AVCaptureDepthDataOutput with AVCaptureDataOutputSynchronizer.

Can final exposure settings be read before capture when quality prioritization overrides manual settings?

When quality or balanced photo quality prioritization is used, manual controls are not guaranteed and are often overridden.
This is because these modes involve processing algorithms, including fusion, which require capturing different exposures.
When developers require precise control over shutter speed and ISO, developers must use speed for photo prioritization.
There is no API to read the final exposure before capture when using quality or balanced prioritization.
quality and balanced are treated as hints, and for photo formats, manual settings will be ignored in favor of the capture stack’s best algorithms.

What is the `PHAsset` original resource choice used for?

This API relates to the existing feature of RAW plus JPEG capture.
It allows developers to choose whether the compressed image or the RAW image is considered the “original” for editing purposes.
It also determines which resource is sourced for creating smaller image derivatives and thumbnails.
Related APIs include PHContentEditingInput.source for choosing the resource and change requests on assets for toggling the original resource.

Will iOS 27 support linear scene-referred Bayer RAW preview streams?

Currently, the only way to get scene-referred linear data in camera capture is through the log format (log and log2).
Direct RAW frame output from camera capture (e.g., for ProRes RAW) includes metadata that is not compatible with what CI or filter would need for rendering.
The idea of having RAW data from camera capture usable with CI filters is worth exploring for the future.

What are must-have recommendations for a capture-centric app?

Performance is critical: Ensure a fast launch, responsive capture, and utilize deferred processing.
User Experience: Focus on the specific user base and their needs; a capture experience for social media differs from a professional photography app.
Reliability: Ensure the app is stable and dependable.
Leverage Sample Code: Do not start from scratch; use sample code to understand best practices, such as using a dedicated serial queue for AVCaptureSession to avoid blocking the UI thread.
Differentiation: Identify what makes the app unique and provides value beyond the basic capture functionality.
Photos Framework Integration: Properly handle user permissions for accessing the photo library and consider performance implications for capture-to-review workflows.

What is the optimal and recommended way for streaming video and audio simultaneously, ensuring synchronization?

Use AVCaptureSession for both audio and video by attaching device inputs for the camera and microphone.
AVCaptureSession synchronizes audio and video sources, providing synchronized output.
If using a different audio API (e.g., AURemoteIO), developers will need to use CMClock and CMClockConvertTime to synchronize the audio and video clocks.
Generally, synchronize video to the audio clock to avoid audio rate conversion.
For network streaming, ensure synchronization before transmission; playback synchronization is handled by APIs like AVPlayer or AVSampleBufferDisplayLayer.

Why does ProRAW support 48-megapixel output from a Quad Bayer sensor, whereas native Bayer RAW output is limited to binned resolution?

Bayer RAW contains raw Bayer data, while ProRAW undergoes debayering and Photonic Engine merging, resulting in RGB linearized data.
ProRAW’s output format is independent of the sensor’s native format (Bayer or Quad Bayer) because it’s already processed into RGB.
The ability to output native Quad Bayer RAW is not yet available and would require support in tools like CIImage filters.
Debayering Quad Bayer data is significantly more complex than debayering standard Bayer data.

How should ISO-conformant gain maps and metadata be generated on iOS?

Refer to WWDC talks from two years ago that detail the APIs for generating gain maps.
Core Graphics and Core Image frameworks can handle gain map and ISO gain map data.
The specifications for gain maps have been added to the HEIF and JPEG specifications.
Understanding the metadata involves examining how the image is divided into SDR/RGB content and HDR additions.

How do Deferred Start and `setPreparedPhotoSettingsArray` compose for photo output warmup?

Deferred Start primarily focuses on getting the app launch and preview running quickly by moving initialization from before preview to after preview.
setPreparedPhotoSettingsArray allows developers to inform the photo output upfront about the worst-case scenario (e.g., quality prioritization plus other features), enabling pre-allocation for the still image pipeline.
These two APIs are orthogonal and can complement each other.
Deferred Start does not inherently conflict with using setPreparedPhotoSettingsArray after the preview is running.
setPreparedPhotoSettingsArray can be called at any time, but calling it before starting the session is beneficial.

Will adjusting the `PHAsset` new rating property require a `PHAssetChangeRequest`?

Yes, adjusting the rating property of a PHAsset requires a PHAssetChangeRequest.
The rating property accepts values from unset to 1 through 5.

Is there a native way to obtain metadata of the original file type (PNG, JPEG, etc.) from a photo selected via the Photos picker?

When using Transferable to set up data, ensure developers are specifying the UTType instead of leaving it as a default image type.
Sample code for the Photos picker on developer.apple.com may provide further guidance.
Some conversion might occur in the Photos picker if users disable captions or location data, but if developers are consistently getting PNG output, double-check the UTType for Transferable.

Is there a way to learn about the adjustment Plist format that the Apple Photos app writes, and when exporting that file, is there a way to import those adjustments back into Photos?

There is currently no API available to decode the adjustment Plist format used by the Apple Photos app.
If this functionality is desirable for the app, file a feedback request.

What are the biggest mistakes a developer can make when building camera-heavy apps on iPhone?

Running AVCaptureSession on the main thread: This blocks the UI and leads to a poor user experience. Always use a dedicated serial queue for AVCaptureSession operations.
Not using beginConfiguration and commitConfiguration for session reconfiguration: When changing multiple properties of the AVCaptureSession, use these methods to ensure the underlying graph is reconfigured only once, improving efficiency.
Using AVCaptureVideoDataOutput for preview when AVCaptureVideoPreviewLayer suffices: When developers only need to render the preview, AVCaptureVideoPreviewLayer is highly optimized and more efficient than processing buffers from AVCaptureVideoDataOutput. Use AVCaptureVideoDataOutput only if developers need to interact with the buffers (e.g., for metadata or drawing).

What are the suggestions for a close-to-native performance way to achieve a zoom, scroll, and pan feature for photo images, up to their original max resolution without pixelating?

Use Core Image, which is designed for UI movement, zoom, and pan by caching decoding pipeline operations.
Core Image allows developers to decode only the visible rectangle and caches the results, enabling smooth interaction even with very large images.
For RAW images, CIImage has a counterpart, CIImage.rawFilter, with similar capabilities for smooth zooming and panning.
Core Image’s Region of Interest (ROI) management optimizes performance by recomputing only the zoomed-in area, even for large images.

How often can Siri camera intelligence be used, and does it affect picture quality?

Developers can use the Siri camera intelligence feature as much as the goal is to on the device.
Captures from this feature are saved to the Siri app, not the user’s normal photo library.
The quality is screen-resolution aspect ratio, meaning developers do not get the full image quality of photo mode.

Is the spatial reframe 3D reconstruction pipeline available to developers?

There is no developer API available for using the spatial reframe capability directly.
ARKit framework offers some capabilities for 3D scene capture, reconstruction, and manipulation, but it’s not a direct equivalent to the Photos app’s reframe editing solution.
For depth sensing, consider using the LiDAR camera on Pro phones via AVCaptureDevice or the TrueDepth camera on the front-facing camera.

How should camera capture orientation be handled across iOS, iPadOS, and macOS?

Handling device orientation is necessary because camera mounting and device orientation can vary.
Use AVCaptureDevice.RotationCoordinator to determine the correct rotation degree for preview or to keep an image horizon-level upright.
Developers can also set the videoRotationAngle on the AVCaptureConnection to have the framework automatically rotate the output.
For video data output, rotation physically rotates buffers; for photo output and movies, EXIF data is used for rotation on playback.
Refer to the WWDC session “Support the Center Stage Front Camera in The iOS App” for detailed guidance on handling rotation correctly and defending against future changes.

Is it possible to capture 24-megapixel images with depth data on deferred photo capture?

Yes, it is possible to capture 24-megapixel images with depth data.
Ensure developers opt into deferred processing, as 24-megapixel processing is time-consuming.
Verify that the selected device supports 24-megapixel maximum photo dimensions.
Select quality prioritization and enable depthDataDeliveryEnabled to receive captures with depth data.

What APIs support multi-camera streaming apps?

Locked Frame Duration: Use the lockedFrameDuration API to ensure a consistent frame rate (e.g., 29.97 fps) and synchronized audio.
GenLock: Synchronize multiple iPhones to an external sync source using GenLock, often with third-party hardware like Blackmagic devices. This ensures perfect synchronization for multi-cam shoots.
Timecode Generation: Output and associate timecode with video frames for easier post-production synchronization.
AVPro Video Storage API: For ProRes 4K 30 video captures, this API provides deterministic file write speeds to prevent frame drops, especially on older or fragmented disks.

Is there a niche new API that may not be talked about so much?

AVPro Video Storage API: This API is a performance optimization for ProRes video captures. It provides a pre-allocated file on disk for writing, ensuring deterministic write speeds and preventing frame drops, even on older devices.
RAW 9 Engine: A new ML-based engine for enhancing RAW image processing (debayering, denoising) for third-party cameras, offering outstanding output quality.

Icon Composer for Beginners

Miká Kruschel — Wed, 10 Jun 2026 00:00:00 GMT

Icon Composer for Beginners

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

What is the recommended workflow for designing an app icon from scratch using Icon Composer?

Start by conceptualizing a visual metaphor for the app.
Design the icon in a vector graphics tool, focusing on composition and layer organization.
Export layers as individual files and import them into Icon Composer for annotation and Liquid Glass customization.
Use Figma, Sketch, Illustrator, or Photoshop templates from the Icon Composer website; Illustrator has an export script.
Vectors are preferred over bitmaps — bitmaps are allowed but not recommended.
Use simple, elegant vector shapes rather than complex fine details for better adaptability across different sizes and conditions.
Export layers at full canvas size to maintain correct positioning when imported into Icon Composer.

What are common mistakes developers make that cause icons to look good in Icon Composer but weak on device?

Designing icons that are too complex, especially when using glass features like refraction.
Failing to evaluate the icon at all different sizes and presentations it will appear in.
Not testing the icon on a device in various lighting conditions and alongside other app icons.
Overlooking the importance of simplicity, which is crucial for icons to be legible at small sizes.

What problem was Apple trying to solve with Icon Composer, and what is the broader vision for app icons?

To provide a dedicated tool that allows icons to adapt and live within the device’s ecosystem (Mac, iPhone, Watch) by supporting features like light mode, dark mode, and clear adaptation.
To enable icons to integrate with the system’s design language and material qualities, moving beyond static bitmaps to a resolution-independent representation.
To give designers control over how Liquid Glass effects interact with individual icon elements, ensuring a harmonious user experience across all platforms and OS versions.
Figma/Sketch glass recipes are not 1:1 with Icon Composer — expect to re-tune effects.
Game and raster icon examples (e.g., Camera app) show bitmap-based icons can work but need extra care.
To streamline the process of deploying a single icon that looks good across multiple devices and appearance modes, rather than managing numerous individual assets.

How are iOS 26 Liquid Glass icons upgraded to the iOS 27 style?

Open the existing Icon Composer file in the updated Icon Composer; the new rendering will be applied automatically.
Review and fine-tune specular highlights, especially for overlapping layers, by configuring them to “inside” or “outside” based on layer colors.
Adjust shadows and refraction settings to optimize for the new rendering.
Consider reducing the use of translucency, as this is a design change that does not happen automatically and may require manual adjustment for sharpness and legibility.
Note that the application does not need to recompile to benefit from the new look; the icon adapts automatically.

When using Icon Composer, what are the various blend modes and when should they be used?

Blend modes determine how foreground and background pixels interact to form a final result.
Darken, Multiply, and Plus Darker generally darken; Lighten, Screen, and Plus Lighter generally lighten — but the naming is historical and math-based, so try modes rather than relying on the labels.
Plus Darker and Plus Lighter are used extensively in system glass controls and can help retain vibrancy.
Blend modes are useful for making icons feel more like glass by controlling color intensity and how layers blend together.

Does Icon Composer allow previewing Liquid Glass transparency across the system-wide slider range in iOS 27?

No, Liquid Glass in clear mode for app icons does not respond to the system-wide transparency slider and remains constant.
This is a deliberate choice to ensure consistent legibility across all possible foreground and background content combinations.
The system aims to provide a consistent and legible experience regardless of user-selected wallpapers or system glass variations.
A single mono mode is used for grayscale annotations, supporting light clear, dark clear, and all tinted modes.

How do flat 2D brand marks get a convincing physical appearance in Liquid Glass?

Icon Composer automatically applies Liquid Glass properties to imported layers, which can be fine-tuned based on the artwork’s shape and size.
Consider how the brand identity is executed in physical mediums (e.g., car logos) and adapt the icon accordingly.
Expose layers that might have been hidden or subtracted in the original flat design to simulate depth and layering (e.g., eyes above a face, solid shapes instead of eraser paths).
Think of the app icon as the “face” of the app, which can adapt with accessories like sunglasses and a hat while remaining recognizable.

How are updated Icon Composer icons included in an Xcode project?

Drag the Icon Composer file directly into the Xcode project, alongside the Swift files, as a normal resource.
Xcode will suggest the correct target membership; verify or adjust this in the import dialog.
In Xcode’s target editor, ensure the “App Icon” name matches the imported file (usually “App Icon” without a “.icon” extension).
Remove any existing icons from the asset catalog when developers are replacing them with an Icon Composer file.
There are no changes from the previous year in how Icon Composer documents are integrated into Xcode projects.

Do the actual layers inside Icon Composer automatically become glassy in the iOS 27 style?

Yes, imported layers are rendered as Liquid Glass layers by default.
For multiple layers, it’s recommended to group them so that Liquid Glass properties can be applied and configured at the group level.
Developers can choose which layers to apply Liquid Glass effects to and which to opt out of if they have pre-rendered treatments (e.g., raster images, watermarks).

When in tint mode alone, background colors look washed out and lack contrast with text. What settings can be tweaked for better vibrancy?

Optimize for different modes by adjusting the color of the tint mode within Icon Composer, choosing either a desaturated or vibrant color.
Ensure foreground elements are white or close to white to maintain contrast.
Update to the latest versions of iOS 27 and Icon Composer, as tweaks have been made to address contrast issues.
Pay attention to the shape of objects within the icon and avoid overly fine details or too many surrounding elements.
When supplying custom backgrounds, be mindful of luminance values, especially in mono mode, and aim to maximize dynamic range with dark darks and bright highlights.

How do developers get Icon Composer?

Icon Composer comes with Xcode.
It is also available as a standalone download directly from Apple.com.
Download templates and sample files from the Icon Composer website for experimentation.
Use Device Hub to preview icons across devices, light/dark variants, and appearance modes.

How do overlapping layers work in Icon Composer icons?

Slice elements into individual layers; what appears as a few elements is often composed of more.
Use shadows to visually indicate that one element is passing beneath another.
Assemble layers carefully so that when reassembled, they create the illusion of one shape behind another.
This requires detailed layer separation and assembly to simulate depth.

How are icons handled for colorblind users?

Icons should be recognizable through form, highlights, shading, and contrast, not solely relying on color.
Ensure icons work and are recognizable in clear or tinted modes, regardless of color perception.
Develop a strong fundamental shape and design language for the icon’s form before adding colors, gradients, or glass effects.
Mono annotation is crucial for adjusting contrast so shapes remain legible in all appearance modes.

How can beginners create an app icon from scratch?

Begin by defining how to represent the app and what to communicate visually.
Capture the essence of the app in a distilled image that is recognizable and memorable.
Start by sketching ideas on paper with a pencil to explore shapes and forms.
Focus on the core message and visual identity before moving to digital tools.
Consider the relationship between the app’s name and potential metaphors for the icon.
Simplify the design to its core meaning without losing significance (e.g., not needing 88 piano keys for a piano app).

What are Apple’s best practices for balancing a shared Liquid Glass icon with platform-specific tweaks while maintaining brand consistency?

Use Icon Composer to adapt icons to different platform shapes (e.g., watchOS circles vs. iOS rounded rectangles) by repositioning and scaling elements.
The Maps icon on watchOS is a good example of repositioning elements for a smaller circular canvas.
Ensure that the design created in Icon Composer is faithfully executed and distributed across all endpoints, including App Store product pages.
The system renders reasonable representations for earlier OS versions, reflecting the full rendering quality while adhering to platform-specific constraints like corner radii.
Prioritize the overall current visual brand identity while ensuring fundamental aspects like icon shape are maintained.
Simplify elements where necessary, especially for smaller sizes or different form factors, to maintain legibility and impact.

What are notable new Icon Composer features and top radar items?

Refraction inspector for exploring design space; top radar item: automatic specular highlight defaults.
Usability enhancements like snap-to guides and grids.
Refraction control for navigating the design space.
Copy and paste attributes between icons; automatic gradients and 2D custom modifiers.

Privacy and Security

Miká Kruschel — Wed, 10 Jun 2026 00:00:00 GMT

Privacy and Security

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

How is Apple ensuring models are not hijacked through prompt injection techniques?

Indirect prompt injection involves an attacker sending malicious instructions within a document that an agentic tool might read, causing the model to perform unintended actions.
Models are most at risk when they have access to private data, can perform actions, and have access to untrusted context.
Mitigation strategies include deterministic methods like confirmation prompts and probabilistic methods like highlighting untrusted content.
A WWDC session on securing agentic features provides further details.

What happens to data sent to Private Cloud Compute or a third-party model?

For third-party AI APIs (e.g., Anthropic, Google), Apple’s PCC guarantees do not apply. Developers must review those providers’ terms.
When using Apple’s PCC interfaces, data is processed with stateless computation and non-targetability guarantees.
Data sent to PCC is only used to fulfill the request and is not accessible by Apple or anyone else.
Data is removed from PCC nodes once the request is complete, and nodes are wiped clean upon reboot.
PCC guarantees are cryptographically provable and verifiable through documentation and tooling.

What distinction does Apple draw between developer-collected data and third-party processor data?

Developers are responsible for declaring all data collected from their app, regardless of whether it’s sent to their own servers or a third-party service.
This responsibility is tied to App Store “Nutrition Labels,” where developers must accurately represent their app’s privacy practices.
Developers must understand what third parties do with the data and their specific uses to correctly inform users.

What security risks are there when using the new agentic coding features in Xcode, and what are the best practices to mitigate them?

Risks are similar to prompt injection vulnerabilities, requiring a secure-by-design approach.
Xcode features include additional mitigations like allow-listing common tools that Xcode can call.
Each use case is evaluated to determine the appropriate set of mitigations for the user experience.
Security is a primary consideration during the design and development of these features before release.

What is the core architecture behind Private Cloud Compute (PCC) for cloud AI processing, and how does Apple mathematically ensure no one can see this data?

PCC offers verifiable privacy and transparency, going beyond traditional confidential compute with additional security layers.
For PCC infrastructure running on Google Cloud, two verifiable attestations for every piece of hardware from two separate vendors are required.
Complex data parsing (e.g., images) is isolated into separate nodes with extra sandboxing.
PCC systems are hardened operating systems purpose-built for safe and isolated user data processing.
A virtual research environment is provided, allowing independent researchers to verify Apple’s claims by running the same software on their own machines.
This research environment is eligible for Apple’s security bounty program and is publicly available.
Continuous transparency is a key aspect; backend changes are noticeable and verifiable in real-time.
Compromised nodes will have changed attestations, causing devices to automatically reject them.

Are there new features for auditing an app’s privacy and security posture?

AI models can be used as tools to review an app’s privacy and security guarantees and check expected behavior.
Developers should leverage security and privacy features like out-of-process pickers to help build secure apps.
WWDC sessions on security and privacy offer valuable guidance.
Frameworks like Network Framework, when using TLS, default to the latest post-quantum cipher suites for enhanced security.
CloudKit provides a secure way to sync user data between devices without requiring developers to manage their own servers.
Developers are responsible for the privacy and security of their users’ data.
Focus on inputs to the application and where user data is vended to others.

What privacy and security tools should new Apple platform developers learn first?

Privacy:
- CloudKit for syncing data between devices.
- Keychain for secure on-device storage.
- CryptoKit library for cryptographic operations.
- Encourage users to adopt Passkeys.
- Practice data minimization: consider if access to user data is truly necessary.
- Use out-of-process pickers for data like photos and contacts to allow user selection.
- For location data, consider if only one-time access is needed.
Security:
- Utilize data protection classes for Keychain and file storage to classify data sensitivity (e.g., “available after first unlock”).
- Leverage platform-native methods like CloudKit APIs for secure data handling.
- Focus on inputs to the application and how much trust is placed in them.
- Consider where user information is vended to others.
Telemetry:
- Start with data minimization and define the specific question developers need to answer.
- Ensure telemetry is actionable (e.g., leads to code changes or business decisions).
- Communicate to users what data is being used and why.
- Consider identifiers: rotating, session-based, or device-based.
- Employ strategies like bucketing and de-identifying data.
- Explore Private Federated Learning and Differential Privacy for collecting sensitive data with mathematical guarantees of non-identifiability.
Passkeys:
- Adopt Passkeys from the start for user accounts, as they are designed to replace passwords and are phishing-resistant.

If a user stores highly personal journal entries, readings, or history in Swift data, what are Apple’s recommended approaches for protecting that data while still enabling search and synchronization?

On-device protection:
- Use data protection classes for Keychain keys (e.g., “only when unlocked,” “only when biometrically unlocked”).
- Set data protection classes for files on disk (e.g., “only when device is unlocked”).
Synchronization with CloudKit:
- Use CKRecord.encryptedValues for end-to-end encryption, especially for users with Advanced Data Protection.
Enabling search and indexing:
- Keys may remain viable for some period of hours after device lock, allowing background indexing — the exact API name and configurability are unclear.
- After this period, the key locks and the data becomes inaccessible.
Example: Contacts data protection class ensures data is only available after the phone is fully unlocked with a passcode.

With the Xcode AI coding features, can Xcode be run inside a virtual machine on an air-gapped Mac walled off from the internet to help improve security and privacy?

Existing code completion features are entirely on-device and work offline.
Other AI features, particularly those integrating with third-party coding tools or providers (e.g., Claude Code or OpenAI Codex), will require an internet connection.
The ability to run in an air-gapped environment depends on the specific AI feature being used.

How does the new Siri AI ensure privacy and security?

Siri AI leverages Private Cloud Compute (PCC) for processing requests that require larger models hosted in the cloud.
On-device protections, including entitlements and sandboxing, ensure that only authorized processes access user data before sending it to PCC.
A secure daemon processes prompts and prepares them for PCC.
When interacting with third-party apps, data is minimized and only the data relevant to the query is sent.
User choice is respected; for example, users can control whether Siri uses their location.
Apple prioritizes on-device processing, only using PCC when necessary for large foundation models or operations too complex for the device.
Multi-turn conversations may involve back-and-forth communication with PCC, with on-device protections still applying.
Apple Silicon enables significant on-device processing, creating security boundaries where platform technologies can be applied.
Optimization of models to run on-device by the AI/ML and Silicon teams enhances privacy and reduces reliance on PCC.
Developers can also use the Core AI framework to run custom on-device models with platform guarantees.

TCC refers to frameworks and protections on-device that allow apps to request user access to additional data.
Developers use the TCC framework to prompt users for access to data like photos or microphone access.
Users can grant or deny these requests, ensuring apps only access data with explicit permission.
This provides users with a high level of trust that an app does not have unauthorized access to their sensitive data.

Will Siri AI have a new configurable policy in an MDM solution when released?

Yes, existing MDM controls for Siri will continue to apply.
Enterprises can configure how they want to use Siri AI features, potentially selecting specific functionalities.
Safari automatic password-changing was also mentioned as an enterprise enabler for small businesses.
Developers can submit feedback requests for proposed MDM configurations.

Are there any new enhancements to Safari’s Intelligent Tracking Prevention (ITP) on the new OSs?

Apple continues to invest in and evolve ITP.
While there are no specific new enhancements to reference this year, ITP remains an important technology.
Further details can be found on WebKit.org.

How can apps communicate security and privacy without sounding like marketing?

App Store Nutrition Labels: Provide an easy way for users to understand an app’s privacy practices before downloading.
In-App Transparency: Allow users to see what data the app has collected about them.
Privacy Assurances: Define simple, understandable privacy promises for each feature that act as a guiding principle for development.
Consistency: Continuously demonstrate commitment to privacy and security through ongoing development and clear communication.
Security Story: Clearly articulate the security claims and guarantees for features (e.g., Memory Integrity Enforcement, PQ3 encryption for iMessage).
User Experience: Build trust by providing features like Passkeys or Sign in with Apple, and by only requesting necessary user data.
API Usage: Use platform APIs like Accessory Setup Kit instead of broader permissions (e.g., full Bluetooth access) to provide a better user experience and limit data collection.
Avoid Vague Claims: Do not use terms like “bank-grade” or “military-grade” encryption, as they are often meaningless to users.
Transparency: Share source code for parts of the system (like PCC) to demonstrate verifiable actions.
Lean into Apple’s Ecosystem: Integrating with Apple technologies and adhering to the Apple experience can convey a sense of trust.
Contextual Permissions: Request permissions (e.g., camera, microphone) only when the feature requiring them is being used, not at app launch.
Purpose Strings: Clearly explain why specific data access is needed in purpose strings to help users understand the value exchange.
Sensor Indicators: Ensure sensor data (microphone, camera) is only used when the user expects it, as indicated by device sensor lights.

What security concepts should students learn first for Apple platform development?

For Students:
- Platform Security Guide: Provides in-depth information on data protection, the Secure Enclave, and OS security technologies.
- security.apple.com: The security blog offers details on the bug bounty program, vulnerability reporting, and in-depth articles on security technologies.
Low-Level Security:
- Binary exploitation and reverse engineering.
- Understanding how systems work is crucial for both attacking and defending.
Networking:
- Focus on protocols like TLS and how the internet functions.
General Concepts:
- Understanding how something works is fundamental to securing or attacking it.

How is Apple approaching stale, expired, or no longer valid passkeys in the Passwords app?

The new Signal API will notify apps and websites when changes occur, prompting them to update credentials.
Passkeys are part of a wide standard, and Apple, as part of the governing body, works with other companies to ensure cross-platform syncing and lifecycle management.

macOS:
- Enable Hardened Runtime: Prevents other applications from reading the application’s memory and mapping malicious code into the process.
- This protection is deeply integrated into the operating system.
Encryption vs. Destruction:
- For secrets needed only briefly in memory, destruction is the answer, not encryption. Destroy tokens once used.
- For longer-term secrets, consider DRM-level solutions, but pure security may not be the primary focus.
CryptoKit:
- Use CryptoKit APIs for handling keys and other sensitive data in memory.
- CryptoKit ensures data backing keys is zeroized. Avoid custom memory management that might not zeroize correctly.
Secure Enclave:
- Bind keys to the Secure Enclave hardware. This makes keys non-exportable, even if the device or app is compromised.
- Use the attestation interface to verify that a key is held by the Secure Enclave.

How should developers balance privacy with useful telemetry?

Great Features and Great Privacy: Aim for both, requiring creativity and work.
Privacy Pillars:
- Data Minimization: Collect only the necessary data to answer a specific question. Avoid collecting full-grain timestamps if daily or weekly aggregation suffices.
- On-Device Processing: Perform aggregation and data minimization on-device before sending data to servers.
- Transparency and Control: Ensure users have control over data collection and are shown what data is being collected.
- Security:
  - Technically enforce user choices regarding data collection.
  - Secure collected data against attackers.
  - Implement data deletion policies.
Aggregation: Distill data to its most essential form to protect privacy and reduce network bandwidth.
Telemetry Example: For alarm telemetry, collecting only whether an alarm went off is sufficient, rather than precise wake-up times, which could reveal personal patterns.
User Control: Users should have ultimate control over their data.
Actionable Insights: Telemetry should lead to concrete actions, like code changes or business decisions.

Safari and Web Technologies

Miká Kruschel — Wed, 10 Jun 2026 00:00:00 GMT

Safari and Web Technologies

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

What web technologies or APIs should new web developers learn to prepare for the future?

Focus on the fundamentals: HTML, CSS, and JavaScript. Understand their core purpose and how they work together.
Learn semantic HTML for better accessibility and declarative functionality, reducing reliance on JavaScript for basic tasks.
Master CSS layout techniques for responsive design and progressive enhancement to ensure broad browser and device compatibility.
Explore the evolving landscape of 3D and spatial web technologies like the <model> element and WebXR.
Prioritize accessibility by using semantic HTML, which provides built-in robustness and accessibility.

Where do web extensions fit into essential web development skills for the future?

Web extensions utilize core web technologies: JavaScript, CSS, and HTML.
They can enhance browsing experiences and provide useful tools for users.
Extensions can be ported between browsers, and efforts are underway to standardize Web Extension APIs for smoother cross-browser development.

What upcoming web standards is the team most excited about?

Web Extensions Working Group: Excitement for formalizing specifications and improving interoperability across browsers.
Random Item function in CSS: Allows for picking between different values for CSS properties, opening up new creative possibilities.
Spatial CSS (proposal): Enables advanced 3D transformations — still a proposal with no shipping news; relevant for Apple Vision Pro and e-commerce.
<model> element: Facilitates adding 3D models to websites, with potential for JavaScript manipulation and integration with Spatial CSS.
install element, declarative partial updates, and Canvas are also on the team’s radar.

How is it possible for Safari to sometimes be more performant than native apps in terms of UI/UX for a native app developer?

WebKit is deeply integrated into Apple’s operating systems, including JavaScriptCore, which powers JavaScript execution.
WebKit is actively optimized for performance, handling content refreshes and other complex tasks efficiently.
The <webkit> view in SwiftUI allows native app developers to seamlessly integrate web technologies into their applications.
Users prioritize functionality over the underlying technology; they simply want their desired experience, regardless of whether it’s native or web-based.

How should web developers advocate for desired web features, and what should they avoid?

Advocate:
- Use bugs.webkit.org to report bugs and suggest features.
- Engage with evangelists on social media.
- Clearly articulate use cases and the benefits of a feature for users.
- Create demos that represent actual use cases, not just flashy examples.
- Be vocal and share the needs through demos, JavaScript libraries, and social media.
Avoid:
- Assuming that a feature implemented in one browser is a web standard.
- Overly aggressive advocacy without clear use cases.
- Being unkind; remember that these are human conversations.

What are Apple’s recommendations regarding web standards positions and developer advocacy?

Apple prioritizes user safety, privacy, and ease of use in its standards positions.
Developers should articulate their needs clearly, even if Apple has a different standards position.
The web standards process is collaborative and can be slow, but it aims for well-designed, long-lasting APIs.
Developers can find published standards positions on GitHub.
Filing requests and articulating needs is vital for meeting user requirements, even if a specific feature isn’t immediately supported.

Use WKHTTPCookieStore to observe and manipulate cookies for WKWebView.
For detailed cookie handling, the developer forums are recommended as there are no specific experts on cookies present.

Are there plans to further close the gap in API support for Safari extensions compared to Chrome and Firefox, for example, tab group APIs?

Yes, there are ongoing efforts to standardize Web Extension APIs and achieve parity with other browsers.
Developers are encouraged to file bugs on bugs.webkit.org and clearly state the use case for desired APIs.
The WebKit team is working hard in community groups to standardize APIs and ensure consistent behavior across platforms.

With spatial CSS, will we see 3D content from the web on Apple Vision Pro?

Spatial CSS is currently a proposal, with no specific shipping news.
The inline HTML <model> element already allows for 3D models (USD and other formats) on the web.
Immersive environments enable viewing these models at full scale.
Spatial CSS, combined with full accessibility trees and other features, is seen as the future for spatial web experiences.

Is there still headroom for web performance optimization?

Performance optimization is an ongoing process.
Developers are constantly working to improve JavaScript execution, image loading, and overall website speed.
Battery life is a significant consideration for performance, especially on mobile devices.
New technologies like WebGPU are developed to better match modern silicon and improve performance.
The evolution of websites and user needs necessitates continuous optimization.

How large should web 3D models be?

Models should be optimized and kept as small as possible, similar to images.
For most content on a page, models around 10MB can achieve maximum visual quality.
Larger models may be necessary for full-screen experiences, similar to large videos.
Optimization involves managing texture sizes, geometry complexity, USDZ compression, AVIF textures, and future mesh compression.

How should developers think about permissions in Safari extensions compared to other browsers? Are there things Safari is more restrictive about?

Safari’s permission model prioritizes user privacy, giving users control over which sites extensions can access.
Permissions are not automatically granted and require explicit user consent.
Extensions can use the “active tab” permission to limit access to the current tab, avoiding broad host permissions.
The goal is to protect user privacy and ensure transparency about extension access.

How does the immersive API interact with existing web content? If a user is in an immersive environment and something on the page needs their attention, how does that handoff work?

The web page remains accessible within an immersive environment.
Users can interact with the web page as needed.
If switching to another application is required, it’s a single-app experience; other apps may dim but can be restored.
Pressing the Digital Crown restores the shared web view from an immersive environment.
The web page can alter the immersive environment (e.g., change position, control animations) through UI elements.

With Customizable Select (shipping Safari 27), how much styling works out of the box versus what needs explicit reset?

Customizable Select is the feature shipping in Safari 27.
Appearance-based select is a separate spec still in progress and not shipping yet — don’t rely on it today.
Out of the box (Customizable Select):
- The layout works correctly.
- The font inherits from the website, unlike appearance: none.
Developer control:
- Pseudo-elements allow styling specific parts like the picker icon or dropdown menu.
- When layering icons or custom styling, keep text content in the element for fallback and accessibility (progressive enhancement).
- The goal is 100% interoperability and a consistent base for styling across browsers.

For a developer with an existing Chrome or Firefox extension, what’s the realistic amount of work to get it into Safari, and where do manifest or API differences tend to bite people?

The effort varies; some extensions may work with minimal changes.
Safari has worked to reduce manifest differences and generally doesn’t fail on unsupported keys.
Test extensions temporarily in Safari via the developer menu.
If API inconsistencies are found, report them on bugs.webkit.org or use Feedback Assistant.
Contributions to WebKit are welcome for improving API support.

What should web developers know about the upcoming Safari/WebKit release?

The Safari 27 release notes are exceptionally long due to extensive quality improvements and bug fixes. WebKit is committed to improving the browser engine and aligning with web standards.
Web extension support is now integrated into WebKit, allowing developers to contribute directly to the codebase.
Explore the <model> element to experience 3D on the web across different platforms.
The web platform is powerful — a lot is achievable with minimal frameworks by leveraging web standards.
Look for Safari-specific technologies like the random() function and filter functions that are web standards and will be available in other browsers.

How do `<model>` element loading states and errors work?

Model loading is promise-based — listen for load completion via the promise.
Show a spinner or placeholder while loading; distinguish fetch vs. decode phases in the UX.
Procedurally generated models may need extra wait time before display.
Handle load failures gracefully with fallback content.

How can a Safari extension with a SwiftUI window communicate with a native macOS app for SEO workflows?

Extension popups can use web navigation APIs within the extension context.
Native messaging bridges the extension and the macOS app for bidirectional communication.
A SwiftUI window in the host app can display extension-driven UI or receive data from the extension.

SwiftUI

Miká Kruschel — Wed, 10 Jun 2026 00:00:00 GMT

SwiftUI

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

Is there a specific architecture that the SwiftUI team expects developers to adopt?

SwiftUI is architecture-agnostic; any architecture that works for the app should work with SwiftUI.
When developers encounter ergonomic issues integrating the chosen architecture with SwiftUI, provide feedback.
Observable can be used to store models and facilitate transitions to SwiftUI, independent of UI frameworks.
App architecture decisions should be driven by the need to ship features, not by the architecture itself.
Structure the data model robustly and testably, with SwiftUI views acting as a projection of this data.

What are the performance tradeoffs of `@ViewBuilder` closures vs separate view structs?

Separate view structs have their own identity, allowing for independent dependency tracking and more granular invalidation.
Computed properties within a view body are treated as part of the parent view’s body, offering less granular control — they do not create separate invalidation boundaries.
@ViewBuilder and @ContentBuilder are equivalent (type alias); use either for computed properties that return views.
Creating separate custom views allows SwiftUI to more precisely update only the views that have changed, improving performance.
Extracting subviews also makes Xcode Previews more useful — developers can preview smaller units in isolation.
Views are structs allocated on the stack, making them inexpensive to create, render, and discard.
Extracting parts of a view into custom views or custom modifiers can minimize dependencies and improve performance.
Custom views can also be necessary for reading environment values like backgroundProminence.

What are common SwiftUI anti-patterns and how can they be avoided?

GeometryReader: Prefer using layout APIs instead to avoid invalidating entire view hierarchies when layout changes.
onChange: Avoid using onChange to trampoline data back and forth; aim for more declarative views that respond directly to data.
Environment Properties: Analyze usage of environment properties; frequent changes can invalidate many views unnecessarily. Consider using @Observable reference types passed via the environment to stabilize dependencies.
Wrapper Views for Controls: Instead of wrapping controls like Button with custom views and modifiers, explore using ButtonStyle or other style protocols for better reusability and access to built-in initializers.
Building Custom Components from Scratch: Leverage built-in components like List and Grid as much as possible, as they evolve with system updates. Interoperability with UIKit/AppKit is also a valid approach when a native SwiftUI component is missing.
Conditional Modifiers: Avoid using conditional modifiers that change while the view is on screen, as this can lead to view recreation, broken animations, and state reinitialization. Prefer inert modifier variants (e.g., opacity(0) vs removing the view) when possible.
If a modifier lacks an inert variant, file feedback with the use case.
Large View Bodies: Split large view bodies into smaller, more manageable custom views to limit the scope of invalidation.

What is a core concept in SwiftUI that developers often struggle to understand, and how can it be explained?

SwiftUI has an internal graph representation of views with nodes and edges representing views and their inputs.
This internal mechanism diffs and updates the view hierarchy based on state changes.
UIKit layout is top-down; SwiftUI layout is bottom-up — understanding this direction matters for debugging layout issues.
Body re-evaluation does not equal re-rendering; SwiftUI may re-run body without actually updating the on-screen result.
Understanding this update mechanism is crucial for diagnosing performance issues and unexpected view updates.
Updates are driven by state changes, not by re-rendering and comparing views like in a DOM.

How does filtering data within a `ForEach` loop impact SwiftUI’s performance and behavior?

Placing if statements directly within a ForEach body can hinder SwiftUI’s ability to efficiently determine the total number of elements.
This can lead to SwiftUI iterating through the entire ForEach loop for operations that require a count.
Solutions include filtering data upfront before passing it to ForEach or wrapping conditional views in an HStack or ZStack to maintain a constant view count.

What is the mental model for connecting `@State` and state management with Swift Concurrency?

SwiftUI views are MainActor isolated, meaning their state and property wrappers are also main actor isolated.
This simplifies concurrency by ensuring state is accessed and modified on the main thread.
Rare exceptions exist where closures might be Sendable and executed off-main; in these cases, explicitly capture a copy of the state value to avoid concurrency errors.
Most SwiftUI closures are MainActor isolated, so these concurrency issues are uncommon.

iOS 27 introduces built-in support for customizing navigation transitions in SwiftUI, including crossfades.
If the needs are met by these built-in transitions, they are the recommended approach.
For older iOS versions or more complex custom transitions, consider interoperating with UIKit navigation controllers.
App resizing is a key consideration; sticking to system navigation components (SwiftUI, UIKit, AppKit) generally provides better support for resizable apps.

What is the recommended way to track a scroll view’s scrolling offset to show/hide view elements?

Use modifiers like onGeometryChange or scrollEffects for tracking scroll position.
The scrollPosition modifier can identify the item currently on screen.
Consider using APIs that track the percentage of a view’s visibility, especially for analytics or triggering actions when content enters the viewport.
Content offset should be treated as an implementation detail, especially with lazy stacks; focus on relative view positions.
For infinite scrolling, consider adding a view at the end of the list with an onAppear modifier to trigger fetching more data.

Is it possible to build custom layouts that are lazy in SwiftUI, similar to `LazyVStack`?

Currently, there is no specific protocol for describing custom lazy layouts.
File feedback with detailed use cases when developers require this functionality.
For complex layout needs, consider interoperating with UICollectionView or composing existing lazy layouts with custom non-lazy sub-layouts (e.g., a lazy built-in container with a custom non-lazy mosaic sub-layout).
The protocol for non-lazy custom layouts is available and optimized compared to manual arrangement with GeometryReader.

Are lazy stacks sufficient for infinite scrolling, or is `UICollectionView` needed?

Lazy stacks allocate views on the heap as needed and benefit from implicit prefetching and partial graph evaluation.
However, onAppear on list items can invalidate prefetch work if it triggers heavy side effects.
For very large infinite-scroll lists with complex cell reuse needs, UICollectionView via interop remains a valid option.
Profile the specific use case before assuming developers need to drop to UIKit.

Why does `ContentBuilder` improve type-checking performance?

ContentBuilder collapses many overloads into a single builder, reducing the compiler’s search space.
This turns a wide set of competing overloads into a single entry point the type checker can follow more efficiently.
@ViewBuilder is a type alias for ContentBuilder, so the same benefits apply to view bodies.

What is the difference between `@ViewBuilder` and `@ContentBuilder`?

They are the same type — @ViewBuilder is a type alias for ContentBuilder.
ContentBuilder is the general name; use it (or the alias) for custom DSLs outside view bodies, not just SwiftUI views.

How do I debug mystery re-renders in SwiftUI?

Use _printChanges() and _logChanges() in debug builds to see what triggered a view update (underscore APIs — don’t ship to production).
A random-color body trick can visually reveal which views are re-rendering.
Use the SwiftUI instrument in Instruments to analyze update patterns.
Agents can help analyze SwiftUI instrument traces.
Split views to isolate dependencies once developers have identified the trigger.

What are the most common performance mistakes in large SwiftUI apps?

Excessive Invalidations: Too many invalidations, often starting from the top of the view hierarchy and propagating down, are a common issue.
Frequent Environment Updates: Placing frequently changing values (e.g., time in milliseconds, scroll position) in the environment can cause widespread invalidations.
Passing Large Value Types: Passing complex value types down through many views, even if not all views use them, requires quality comparisons at each level. Using @Observable reference types can be more performant as only the reference is passed.
Resizing Issues: Over-reliance on GeometryReader can cause views to update on every frame during app resizing. Aim to minimize view updates during resize events.
Large View Bodies: Large view bodies increase the scope of invalidation. Splitting them into smaller custom views helps limit updates.

Do `@State` properties holding `@Observable` classes allocate on the correct thread?

SwiftUI views are MainActor isolated, meaning their bodies and state are called on the main thread.
@State properties holding @Observable classes will automatically be allocated on the main thread.
With modern concurrency settings (main actor isolation inferred), custom observable classes are also automatically main actor isolated for UI code.
For background computations, factor them into separate functions, await their results, and then update the UI on the main thread to ensure atomic updates and smooth animations.
TimelineView can be used for updates that need to occur on every frame.

How can multi-module apps hide concrete view types without `AnyView`?

some View is the preferred approach as it provides opaque types, allowing the type checker to know the concrete type without exposing it externally. This maintains static information for features like ForEach.
If some View is not feasible, AnyView can be used, but ensure the underlying type remains consistent to avoid performance issues.
Wrapping AnyView in an HStack or ZStack can help ForEach by communicating that only a single view is returned.

What are the performance tradeoffs (speed and memory) of using `CompositingGroup` or `DrawingGroup`?

CompositingGroup: Primarily for visual effects, not performance. It allows applying effects (like shadows) to the entire group of views as a single unit, rather than to each individual element.
DrawingGroup: Consolidates rendered layers into a single layer, significantly improving performance for complex custom graphics by reducing the number of on-screen layer representations. This is useful when many individual views would otherwise be rendered.
Canvas: Offers more direct control over drawing invocations, similar to drawRect in UIKit/AppKit. It’s suitable for custom graphics but does not draw SwiftUI views, meaning gestures and accessibility need to be handled manually.

Accessibility Technologies

Miká Kruschel — Tue, 09 Jun 2026 00:00:00 GMT

Accessibility Technologies

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

What’s new in accessibility features?

Apple Intelligence is integrated into accessibility features, enhancing VoiceOver image descriptions, live recognition, personalized accessibility reader, and voice control.
Automatic subtitles for personal videos are now available.
Vehicle motion cues have been extended to visionOS with spatialization.

What is the best advice for testing UI usability and accessibility?

Use Accessibility Inspector to audit elements and Device Hub for testing across different screen sizes.
Consider Dynamic Type and Large Text, ensuring the UI lays out dynamically based on font size.
Test with VoiceOver first, as it often provides significant accessibility benefits that carry over to other assistive technologies.
Incorporate feedback from real users to polish the accessibility experience.

How should developers prioritize accessibility testing when they can’t test every assistive technology?

Prioritize VoiceOver testing as it’s approachable and often provides benefits for other assistive technologies like Switch Control and Voice Control.
Many assistive technologies share underlying APIs (e.g., accessibilityLabel), meaning a good VoiceOver experience often translates to good experiences for others.
If resources allow, test other technologies, but a strong VoiceOver implementation is a solid foundation.
Gathering feedback from real users can significantly help refine the accessibility experience.

How can VoiceOver avoid reading both a custom label and the system image description?

Remove the image trait from the element. VoiceOver will then use the provided accessibility label without appending its own description.
When developers keep the image trait, VoiceOver plays a subtle sound before the auto-generated description so users can distinguish it from author-provided alt text.
Be aware that removing the image trait may disable features like image exploration and the ability for users to ask follow-up questions about the image.

What new accessibility features can help patients using an EHR patient portal?

Accessibility Reader: A system-wide tool for customizing reading experiences, especially for long-form content, and integrated with spoken content.
Image Descriptions and Image Explorer: Useful for describing data-rich images and charts within the portal.

What are the first steps for making a data-rich app accessible?

Start with Dynamic Type, as many users benefit from adjustable font sizes.
Implement VoiceOver support, which provides significant accessibility wins.
Continue by adding accessibility labels and refining the application’s VoiceOver experience.

How can network request progress be exposed to VoiceOver?

Use layoutChanged or screenChanged notifications to inform VoiceOver about UI changes.
layoutChanged is suitable for smaller UI updates, while screenChanged is for more significant screen alterations.
Developers can optionally use accessibilityElement with layoutChanged to direct VoiceOver focus, but use this sparingly to avoid disrupting the user’s focus.
Alternatively, use accessibilityAnnounceNotification with a descriptive string to have VoiceOver speak the completion message.

Are there any updates to the Text-to-Speech APIs this year?

There are no new Text-to-Speech APIs announced this year, but backend improvements may exist.
Developers are encouraged to file feedback requests for new API features.

What should tvOS developers consider when implementing Dynamic Type?

Familiarize yourself with best practices for Large Text and how UI flow might need to adapt for accessibility font sizes.
Watch the WWDC session on Large Text and tvOS for specific guidance.
Previous talks on Large Text for iOS can also provide a good starting point.

How valuable are Accessibility Nutrition Labels, and what details should developers know?

For Users: Nutrition labels allow users to understand an app’s accessibility features before downloading, saving time and reducing cognitive load.
For Developers: They provide a way to showcase accessibility efforts and distinguish their apps. They also come with guidelines that serve as a benchmark for testing and improvement.
The labels can be a powerful tool for advocating for accessibility within organizations.

Is the VoiceOver option in Xcode’s Device Hub intended for simulators or physical devices?

A new XCTest API allows testing VoiceOver on iOS devices from a Mac.
This functionality is expected to work in the simulator starting with Seed 1.
For specific details and further questions, consult the developer forums.

What should developers revisit for macOS VoiceOver support, and how should they test across assistive technologies on Mac?

User Expectations: Mac users often multitask and have higher expectations for keyboard shortcuts and accelerators.
Accelerators: Implement features like hotkeys for quick navigation to different app sections (e.g., sidebar, inspector).
Testing: Use the Accessibility Shortcut (Command+F5 on macOS, Command+Option+F5 when Touch ID isn’t available, triple-click Touch ID if available) to quickly toggle accessibility features on and off.
New Features: macOS apps automatically benefit from new VoiceOver features like image descriptions.
See the Improving Mac accessibility session for grouping and navigation guidance.

How can custom AppKit controls (context menus, hover actions, custom buttons) be made accessible to VoiceOver users on macOS?

Custom Actions: A primary method, but can be less discoverable for Mac users. Consider them for advanced features.
Additional Buttons: Create separate buttons for critical actions, especially hover actions.
Accessibility Representation (SwiftUI concept): While the question is AppKit-specific, the principle applies: expose complex controls as multiple simpler accessibility elements. In AppKit, this involves implementing accessibilityChildren and creating custom accessibility elements.
Hotkeys: Implement keyboard shortcuts for discoverability and efficiency, benefiting both VoiceOver and power users.
Hover Actions: Use sparingly, as they can be difficult to discover, especially for users with cognitive impairments. Reserve them for secondary actions or enhancements.

How does Apple design accessibility features for people with limited or no use of their hands or arms?

Interaction Methods: Offers diverse options beyond hands, including Voice Control, Head Tracking, Eye Tracking, Sound Actions, and Switch Control.
Touch Accommodations: Provides features like AssistiveTouch and new setup flows for iOS 27 that calibrate touch responses for personalized interaction.
On-Device Eye Tracking: Enables interaction using the built-in camera, offering a simpler setup than external eye trackers.
Personalization: Recognizes that solutions vary greatly even for individuals with the same disability, offering a wide array of technologies to accommodate different needs and preferences.

What accessibility features are designed with neurodivergent people in mind?

Guided Access: Helps users stay within a single app or experience, preventing accidental navigation away.
Assistive Access: Offers a simplified visual interface with larger icons, text, and touch targets, focusing on core controls. This is available for first-party apps and via APIs for developers.
See the Assistive Access for developers session for building simplified app experiences.
Other Helpful Features: Screen Time, Speak Screen, Speak Selection, and Accessibility Reader can also be beneficial.

How can the new reorderable modifier in SwiftUI be made accessible to VoiceOver users?

Drag and drop is not a standard VoiceOver idiom.
The accessibility of the reorderable modifier with VoiceOver is still under investigation and may vary between platforms (iOS vs. macOS).
This is a good question for the developer forums.

How can third-party apps integrate with the new FaceTime video interpreting feature?

The video interpreting feature is not yet available in the iOS 27 beta.
More information on integration, initiation, entitlements, and API restrictions will be provided when the APIs become available.

What is the recommended way to expose stable accessibility identifiers for custom SwiftUI reusable views?

Create a wrapper around reusable views (like labels or buttons) that requires users to provide an accessibilityIdentifier and accessibilityLabel.
Implement checks to prevent nil accessibility labels, enforcing concrete labels for testing and stability.
For symbols and buttons, require both an accessibility label and an identifier.

What process builds accessibility into an app from the start?

Early Consideration: Integrate accessibility from day one, rather than adding it later.
Basic Checks: Regularly check UI elements with VoiceOver and research how users of different assistive technologies interact with similar apps.
Usability Research: Conduct research with real users to gather valuable suggestions and insights.
Team Integration:
- Human Connection: Show developers how accessibility issues directly impact users by demonstrating real-world problems.
- Iteration: Build accessibility into every iteration of the development process, not as a separate phase.
- Planning: Include accessibility as a key category alongside security and privacy in project planning.
- Prototyping: Ensure prototypes incorporate accessibility from the design phase.
- Refinement: Allocate time at the end of the project for fine-tuning accessibility features after the UI is solidified.
Criticality over Utilization: When prioritizing features, consider the criticality of accessibility to users, not just the number of users who might benefit.

What platform-specific pitfalls should developers look out for when creating universal apps with accessibility in mind?

Platform Testing: Test accessibility features (like VoiceOver) individually on each platform (macOS, iPadOS, watchOS, tvOS) as user expectations and interaction models differ.
User Expectations: Mac users expect more keyboard shortcuts and accelerators compared to iOS users.
Interaction Modalities: Consider the primary input methods for each platform: keyboard (Mac), touch (iOS/iPadOS), remote (tvOS), Digital Crown (watchOS), and eye/gaze tracking (visionOS).
Hit Testing vs. Child Order: Hit testing is more critical on iOS for VoiceOver, while accessibility child order is more important on macOS.
Navigation: Mac VoiceOver navigation is hierarchical, while iOS is linear. Grouping elements is crucial for efficient Mac navigation.

Will the new AI voices be available for VoiceOver?

The voices used for VoiceOver are specifically tailored and tuned for screen reader use.
Users of VoiceOver often increase speech rate, which influences voice selection and tuning.

How can accessibility regressions be prevented besides manual testing?

Automated Testing: Use XCUI tests, which rely on the accessibility hierarchy. If an app is not accessible, XC tests will fail.
Accessibility Assertions: Add assertions in XC tests to check for accessibilityLabel presence or other accessibility properties.
New XCTest API: A new API allows programmatic control of VoiceOver for element-by-element navigation and validation, enabling smoke tests for accessibility.

Terminal Accessibility: Improved VoiceOver support for Terminal, including better access to marks, tab autocomplete suggestions, and moving to the visible beginning.
Xcode Bug Fixes: Numerous bug fixes for VoiceOver in Xcode are available in Seed 1.
SwiftUI: Levels the playing field by allowing all developers, including those using VoiceOver, to define and edit UI in code.
Xcode Rotors (macOS): Enhanced rotors allow quick navigation between methods, errors, warnings, and variable names within Xcode.
AI Coding Assistant: New AI skills in Xcode (Seed 1) for VoiceOver and Dynamic Type can help developers make their apps accessible by suggesting code edits and identifying issues.
AI for Efficiency: AI tools can help developers scan and summarize code, potentially leveling the playing field for those with vision or cognitive impairments.

For spatial computing tools using eye tracking or gaze (like visionOS), how can designers avoid assuming visual gaze is the primary input method?

Pointer Control: visionOS offers Pointer Control, allowing users to use other body parts (head, finger, wrist) as pointers instead of gaze.
Comprehensive Sessions: WWDC sessions cover these topics in detail, including making RealityKit content accessible.

Coding Intelligence, Machine Learning & AI

Miká Kruschel — Tue, 09 Jun 2026 00:00:00 GMT

Coding Intelligence, Machine Learning & AI

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

What are the roles of Core AI, Core ML, and MLX, and how should a beginner understand them?

Foundation Models Framework: Top-level for LLM use cases. Integrates with various inference backends. The framework will be open source very soon, tying together the Language Model Protocol ecosystem.
Core AI: For custom models (trained or downloaded). Offers SLAs and guarantees, suitable for applications.
MLX: For powerful, custom use cases, including distributed training and local AI.
Core ML: Primarily for traditional ML models like decision trees; new neural network work should use Core AI.
Recommendation: Start with Foundation Models for LLMs. For custom non-LLM tasks, use Core AI. Use MLX for advanced or custom training needs.

What is the on-device foundation model’s context window in iOS 27, and is the input and output counted against one shared token budget?

The on-device context window is 4096 tokens.
This is a shared budget for both input and output. For example, 4000 input tokens leave only 96 for the response.
Private Cloud Compute (PCC) offers a larger 32K context window with the same shared budget principle.
For even larger context needs (up to 1 million tokens), consider third-party models via MLX or Core AI.

Can foundation models run inside background app refresh or background processing tasks, especially when the phone is locked or the app has been backgrounded?

Yes, foundation models can run in background tasks.
The system may rate-limit requests if it’s busy, returning a rate-limited error. Developers should handle this by retrying later.
On iOS, background LLM use may be rate-limited or deprioritized when the system is busy.
On macOS, will not be rate-limited with the local foundation model while the app is in the foreground.
Private Cloud Compute may experience rate limiting due to system load (system busy) or excessive requests (too many requests / quota exhaustion).

For macOS 27, Apple Intelligence, what does “waitlist” mean, and are different models offered on the waitlist?

The “waitlist” applies only to Siri.
It does not apply to on-device Apple Intelligence features or Private Cloud Compute (PCC) language models.
The beta includes the AFM core advanced 20 billion model, used for voice features.

Can the Foundation Models Framework mix on-device models, private cloud compute, and third-party LLM providers within a single agentic flow, and what are the data privacy and attribution boundaries?

Yes, developers can mix these using the Dynamic Profiles API.
Baton Pass: A pattern where context is fully shared between models in a flow. Suitable for on-device or PCC models where privacy is not a concern.
Phone a Friend: A pattern where only the current query is sent to a third-party model, preserving privacy of previous interactions. This is akin to tool calling with an ephemeral session.
Privacy and attribution boundaries depend on the chosen pattern and the third-party provider’s policies.
Profile modifiers can manage context window sizes between different models.

Who handles on-device speech personalization for user-specific names?

Configure speech personalization through the speech framework documentation and developer forums.
Speech recognition systems often include a separate personalization component that developers may be able to fine-tune.
Building a custom model to handle specific names and pronunciations is possible for supported languages.

How can coding agents learn a project’s code style and architecture?

Leverage Source Code: Agents learn by observing existing code in the project.
Provide Examples: Use agent-specific files (e.g., AGENTS.md) to provide examples of code style. Keep these files concise to fit within context windows.
Reference Other Files: Link to style guides or documentation within the AGENTS.md file.
Document Learnings: Instruct agents to document their findings and assumptions about the codebase. This creates a knowledge base for future reference.
Search and Learning: Agents learn by searching for information. Providing access to relevant markdown files or documentation enhances their learning.
Xcode Integration: Xcode’s documentation search can help agents learn new APIs, even if the model is older.
Agent Client Protocol (ACP): Using ACP with local LLM providers (like LM Studio) in Xcode 27 offers more capabilities than simple chat completions, including state management and file I/O.
Model Choice: Smaller local models may have limitations with very large codebases or complex reasoning.
Continuous Teaching: Developers need to continuously teach agents their style and project-specific preferences.
Resetting: When new models are released, consider starting with a clean slate to see what the new model can do without prior context.

What practical steps can teams take to integrate automated UI testing into their workflows on Apple platforms?

Unit Tests: Focus on testing small, independent kernels of functionality. Agents can help enumerate permutations and combinations for comprehensive unit tests.
Integration Tests: Introduce dependencies and run tests that are slightly longer and more expensive. Agents can help structure code for better testability.
UI Tests: Use these as a final check for the overall UI integration. Agents can now interact with the simulator to perform actions (tap, swipe, type) and analyze accessibility trees and screenshots to identify bugs.
Agent-driven UI Testing: In Xcode 27, agents can use the simulator to test and learn patterns, then write UI tests. They can also run for extended periods to find bugs.
Screenshots and Finalized UI: Providing screenshots of finalized UI can help agents understand and potentially recreate it.

Have there been any updates to Natural Language Processing and Apple Vision Kit, and what is the preferred method for image extraction now that Foundation Models support image attachments?

Vision Framework: Has significant updates, including segmentation models. Refer to the “What’s New in Image Understanding” session.
Foundation Models vs. Vision Framework:
- Vision Framework: Preferred for well-understood, structured tasks like barcode detection or OCR. It’s optimized, efficient, and highly testable.
- Foundation Models: Preferred for tasks requiring semantic understanding, natural language nuance, or when dealing with novel or complex image analysis that doesn’t fit a predefined structure.
New Tools: Foundation Models now include tools like barcode readers and OCR, blurring the lines.
Use Case Driven: If a structured API exists (like Translate API for translation), use it. If the task is dynamic, requires stylistic changes, or involves natural language prompts, Foundation Models are more suitable.

On-device LLMs have limited token capacity. What are the best practices for managing prompt size, tool definitions, and context to avoid exceeding limits while maintaining high-quality responses?

Track Token Usage: Use new symbols in the Foundation Models Framework (iOS 26.4) to programmatically check context size and count tokens. Access response.usage to see input, output, and cached tokens.
Drop Tool Calls/Results: After a tool call is processed and a response is generated, consider dropping the tool call and its output from the transcript to save context.
Summarize History: Use the Summarize History modifier from the open-source Foundation Models Utilities repo to periodically compress older, less relevant transcript entries.
Compress or Drop Older Entries: Remove or compress entries that are no longer relevant to save context.
Profile Modifiers: Use these to manage context window sizes, especially when switching between models with different capacities.
Open Source Utilities: The Foundation Models Utilities repo provides building blocks applicable to any backend conforming to the language model protocol.
Evaluations Framework: Crucial for determining optimal context management strategies (e.g., how often to summarize, what to condense) based on use case and model performance.
Configurable Prompts: Prompts used for summarization or other context management should be overwritable.
Break Down Tasks: Avoid giving a single session too many independent tasks; break them into multiple sessions to utilize context windows more effectively.
Model Architecture: Newer models often have more efficient attention mechanisms (e.g., sliding window, linear attention) that handle context better.
Configurable Reasoning: Some models offer configurable reasoning levels, allowing developers to trade-offs between reasoning depth for latency and context handling.

Can Foundation Models guardrails be prevented from refusing emotionally intense but legitimate journal entries, and how can guardrail refusals be detected separately from other errors?

Permissive Content Transformations: For system language models, enabling this setting during guardrail initialization prevents refusals on emotionally charged input.
Model Refusal vs. Guardrail Error:
- Model Refusal: The model itself declines to elaborate or expand on content due to its alignment training. This is a model response, not a guardrail error.
- Guardrail Error: A separate moderation model flags input or output as problematic. This can be caught and handled separately.
Third-Party Models: Guardrails and these specific refusal mechanisms do not apply when using custom custom models.
Feedback: If guardrails are not behaving as expected, file feedback. Explore custom model options if Apple’s models don’t meet specific needs.
Improvements: Guardrails have been significantly improved with more training data to reduce false positives.

What is Apple’s guiding philosophy or approach to AI evaluation?

Evaluation-Driven Development: Start with evaluation from the beginning, treating it as the “living specification” of the feature.
Formative Assessment: Evaluations are for learning and improvement, not just checking what’s already learned. They identify weak spots.
Comprehensive Test Cases: Include core use cases, headroom for growth, and edge cases in evaluations.
Tools and Frameworks: Apple provides tools and a framework to make evaluation easy, from curated datasets to synthetic data generation.
Iterative Improvement: Use evaluation results to refine models and configurations, comparing different approaches to “hill climb” the feature’s performance.
Confidence in Choices: Evaluation helps developers confidently select the best models and configurations for their specific use cases.

Is it possible for models used by different apps on iPhone to be shared across apps to save storage space?

No, direct sharing of models across unrelated apps is not possible.
Complexity: Sharing models is complicated due to resource contention and the need to control access.
App Groups: Model caching in Core AI can be shared if apps belong to the same app group.
Use Case Specific Optimizations: Models are often optimized (quantized) differently for specific use cases, making a universal shared model impractical.
Sandboxing: iOS app sandboxing prevents apps from accessing each other’s downloaded models directly.
Developer Ownership: Model weights can be shared between apps owned by the same developer within an app group, but the runtime loading of models in memory is not shared.

Power and Performance

Miká Kruschel — Tue, 09 Jun 2026 00:00:00 GMT

Power and Performance

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

What are the main factors affecting app power usage and performance in SwiftUI for beginners?

Profile the overall app first before assuming SwiftUI is the bottleneck.
Review the Optimize SwiftUI using Instruments session for SwiftUI-specific profiling guidance.
Separate views from their inputs to avoid unnecessary redraws.
Use tools like Instruments to understand view dependencies and break them up.
Invest in SwiftUI performance optimizations, as they often lead to power wins.
Avoid deeply nested SwiftUI hierarchies.
Any SwiftUI optimization generally helps with both performance and power.

What is the biggest power mistake developers commonly make without realizing it?

Not having enough telemetry or instrumentation, leading to focus on low-ROI areas.
Underestimating the importance of instrumentation and measurement before optimizing.
Not accounting for different app states that can affect power characteristics (e.g., testing with large data sets).
Not inducing different conditions (e.g., thermal state, network changes) to test app behavior.
Underestimating the power cost of file system access and network requests.

What is the best documentation for Instruments?

The “Instruments Tutorials” is the recommended starting point for beginners.
This tutorial includes an associated project with built-in performance issues to practice detection and fixing.
Guides are available for specific Instruments tools as needed.
Use Feedback Assistant to request missing documentation.

What is a good starting point for beginners using Instruments?

Use the Time Profiler with the Flame Graph view.
Flame Graphs visually show the cost of operations and call stacks, making performance bottlenecks easy to identify.
Consider using “Top Functions” for a flatter list of helper and compiler runtime functions.
New in Instruments: run comparison lets developers diff call trees across runs to see what changed between profiling sessions.

How should high battery usage be diagnosed when background work seems minimal?

Investigate potential background task scheduling, even if not explicitly coded.
Use the Power Profiler in untethered mode to record traces on the device without Instruments attached.
Analyze the trace in Instruments to identify background workloads.
Examine the breakdown of energy usage by subsystem (CPU, GPU, display, networking).
High brightness or frequent color swaps can also contribute to energy drain.

When does injecting a theme object via `@EnvironmentObject` become a performance bottleneck in large SwiftUI apps?

It’s difficult to give specific numbers, as performance impact varies by view complexity.
Using @EnvironmentObject is generally a useful abstraction for passing data.
Use the SwiftUI instrument in Instruments to assess the downstream impact of environment changes.
Performance issues are case-by-case and depend on the view tree configuration.

How should large data sets be loaded in SwiftUI tables, and how can MetricKit help?

Load only the data necessary for the current user experience.
Use SwiftUI’s lazy loading mechanisms (e.g., lazy HStack, VStack) to load data as it scrolls into view.
Use MetricKit’s state reporting to categorize batch sizes (e.g., large, medium, small) to analyze performance within those ranges.
Avoid logging very frequently changing numbers; categorize data into meaningful boundaries for analysis.

How does iOS prioritize background tasks when the system is under heavy Apple Intelligence workloads?

Many Apple Intelligence features run on the Neural Engine or private cloud compute, potentially not impacting CPU-bound app tasks.
Configure background tasks in small, easily pausable chunks to allow the system to resume them efficiently.
Use System Trace in Instruments to see thread priorities and identify tasks that preempt the app’s threads.
The system aims to schedule workloads automatically to provide the best user experience.

Performing expensive tasks on background threads during launch causes thread hops. How expensive is this compared to thread blocking, and are there better solutions?

Frequent thread hopping adds overhead, but the cost is negligible unless done thousands of times per second.
Defer non-critical work until after the initial launch to minimize thread hops.
Prioritize background threads lower than main content loading threads.
Use pre-warming with BGAppRefreshTasks to fetch necessary information before launch.
Instruments’ System Trace can graph context switch counts to help correlate with launch metrics.
Avoid fetching A/B test experiments or similar during launch; cache previous results.

How can launch delays from background work be identified?

Use Instruments’ System Trace template to record thread states and identify if the main thread is blocked.
A common real-world issue: spawning background work at launch then blocking the main thread until it completes.
Inspect what’s on the critical path to launch, including network requests and framework-related tasks.
Check Xcode Organizer’s launch metrics for top issues and call stacks causing slow launches.
Don’t measure launch time with kernel APIs or in-process heuristics — the app process can’t reliably measure its own launch.
Use MetricKit or Xcode Organizer; the system measures tap on icon → first screen drawn.
Measure the app’s launch time and compare it across versions to identify regressions.

What is the most common silent battery killer in SwiftUI, and how can it be caught?

View over-invalidation is a significant battery killer, causing unnecessary CPU work without visual changes.
Minimize redraws and flatten the UI hierarchy to reduce foreground energy drain.
Monitor background threads dispatching workloads for data fetching and display.
Apply basic software engineering principles: cache when possible and minimize repetitive work.
Use the SwiftUI instrument in Instruments to focus on these issues.

Are there performance improvements for large lists and table views in SwiftUI for macOS 27, and what are best practices?

Keeping list size constant helps SwiftUI manage updates efficiently.
Use lazy data structures to load items as needed.
Move filtering and data manipulation to the model layer before providing data to SwiftUI.
Avoid cells that change size frequently, as this causes cascading recalculations.
Consistent cell sizes allow SwiftUI to utilize its caching capabilities.

How expensive is `AnyView` for type erasure in SwiftUI, and when should it be avoided?

AnyView adds overhead during view creation due to type erasure.
Avoid AnyView if easily avoidable, but don’t over-optimize prematurely.
If AnyView becomes a performance problem, it can be addressed later.
Measurement is key; use Instruments to determine if AnyView is a bottleneck.
Using AnyView for features like accessibility (e.g., switching layouts) is generally acceptable.

What are noteworthy developer tools beyond MetricKit’s state reporting and crash report extensions?

Xcode Organizer offers aggregated field data with less flexibility than MetricKit but provides visualization.
Metric goals in Xcode Organizer offer guidance by comparing the app’s performance to similar apps.
Foundation Models has an updated Instruments tool for debugging requests, prompts, and token caching.
A tool for profiling long-term Metal apps shipped in 26.4, recording performance over hours.
Check developer forums for posts tagged with MetricKit for updates on performance and power tools.

What is the one big thing developers should check out from the new tools this year?

Metric goals in Xcode Organizer: Compare the app’s metrics against similar applications to identify areas for investment (power, foreground energy, launches, hangs).
State reporting in MetricKit: Slice data to understand which application states are performing poorly.

Beyond WWDC sessions and Swift evolution proposals, what is the pathway to deep expertise in Swift performance?

Gain experience by building things and using Instruments tools (Time Profiler, SwiftUI Instrument) to understand framework behavior.
Study resources like the “Optimized CPU Performance with Instruments” session and the “Apple Silicon Optimization Guide.”
Understand how Apple’s CPUs and hardware work to implement performant Swift algorithms.

How can SwiftUI avoid performance issues from escaping closure parameters?

Call closures in the init rather than the body to prevent execution on every view re-evaluation.
If closures cause performance issues, explore alternative APIs or data structures.
Consider the SwiftUI (June 10) and SwiftUI (June 11) labs for more in-depth architectural advice.

What are best practices for handling dynamic data or heavy assets in SwiftUI to avoid performance stutters on older devices?

Use assets appropriately sized for their use case (e.g., smaller images for thumbnails).
Implement caching for assets to minimize refetching and recomputing.
Use placeholders or loading indicators for non-critical assets to improve perceived performance and responsiveness.
Test on older devices or use low power mode on newer devices to simulate performance constraints.
Use Xcode condition inducers (thermal and network limits) in addition to Low Power Mode for realistic stress testing.
Use physical devices for profiling; simulators do not accurately reflect device performance.
Leverage MetricKit and Xcode Organizer for field data from users with diverse devices.

What are recommended strategies for managing thermal pressure and preserving user experience in compute-intensive apps (ARKit, Metal) used outdoors?

Listen for ProcessInfo.thermalState to detect elevated thermal states.
Back off on richer experiences when thermal pressure is high without significantly compromising user experience.
Examples of backing off include: requesting lighter resources from the network, simplifying animations, reducing frame rates, or lowering resolution.
Optimize the controllable aspects of the app’s power draw to maximize performance under thermal constraints.

Does using many `@Environment` properties in a large SwiftUI app impact rendering or update performance?

The primary performance concern with @Environment is “environment churn.”
Updating environment values at high frequency can cause views reading from the environment to re-evaluate unnecessarily.
Simply reading values from the environment is generally not expensive.
Use Instruments (e.g., SwiftUI instrument) to monitor and identify environment churn issues.

What’s new in MetricKit for iOS 27?

MetricKit has been rebuilt with a Swift-first API; much of the old API is marked deprecated.
New diagnostic and metric types are only available on the new API.
Finer-grained reporting intervals are supported.
State reporting (categorizing batch sizes) remains useful for analyzing performance within meaningful ranges.

Swift

Miká Kruschel — Tue, 09 Jun 2026 00:00:00 GMT

Swift

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

What are notable Swift 6.4 features worth knowing about?

Swift 6.4 includes general diagnostic improvements and the @diagnose attribute for fine-grained warning control.
@diagnose can suppress deprecation warnings in specific code regions or opt into warnings that are off by default (e.g., strict memory safety, strict concurrency).
async defer and cancellation shields improve resource cleanup in structured concurrency.
A new open-source subprocess package, Foundation performance improvements, and APIs like ProgressManager are also new.
Embedded Swift improvements make bare-metal and firmware targets easier to use with familiar Swift code.

How is data ownership transferred between isolation domains?

Swift concurrency uses region-based isolation for transferring non-sendable data between actors.
The original actor must no longer access the data after the transfer.
The sending keyword can be used to explicitly annotate parameters or return types for safe transfer.
For storing such values, unsafe opt-outs are currently available, with an active pitch for a disconnected data type to preserve transfer properties.

What are best practices and pitfalls when using Swift Structured Concurrency?

Lean into structured concurrency assertively; avoid escape hatches.
Refactor smaller code parts into single units.
Prefer task groups over task.detached or Task.init for mainline flow.
Use objects with life cycles that fit task groups’ lexical scope.
Consider with-style functions or deinit-based cleanup for lexical scoping.
Avoid fanning out too much; write linear asynchronous code within task groups.
Use cancellation shields for asynchronous cleanup operations in canceled contexts, especially for resources like file I/O or database transactions.
async defer blocks can be placed within cancellation shields if they contain await calls that might suspend.
Non-sendable types help reason about linear data flow within asynchronous control flow, preventing accidental escapes.
Explicitly marking ephemeral data types as non-sendable can simplify data models and improve performance by ensuring cheap passing of intermediate types.
Don’t overuse unchecked Sendable during Swift 6 migration — it deprives the project of the compiler’s safety benefits.
Fork-join, scatter-gather, and similar patterns are useful models for structured concurrency when developers have repetitive parallel work.

What is the overhead of unnecessary protocol conformances like Sendable, Equatable, Hashable, Identifiable, Comparable?

Conformances like Equatable and Hashable incur a cost because the associated equality or hashing functions must be available, even if not directly used. The compiler keeps this code around for potential runtime discovery (e.g., via as? casts).
Sendable is a tag with no runtime representation and thus no overhead.
Adding generic overloads on protocols can potentially increase compilation time by widening the set of types that satisfy type-checking problems.
API design should prioritize meaningful conformances; don’t conform just because it’s possible.

What is the cleanest architectural pattern to stop `@MainActor` contagion in legacy apps without sacrificing Swift 6 safety?

Propagating @MainActor annotations requires making code async or adding the annotation elsewhere.
Option 1: Enable main actor by default mode for the entire module if most code belongs on the main actor. Annotate exceptions explicitly.
Option 2: Start with “leaf types” and work outwards.
Option 3: Mark specific methods as non-isolated if they don’t touch mutable state, reducing the need for all uses of the type to be on @MainActor.
Consider making static variables immutable (let) if they are never mutated, as these don’t require @MainActor annotation.
Refer to the “Migrate the app to Swift 6” session for code-along examples.

What are the most essential modern Swift features or official resources for high efficiency and great performance?

Profile first: Use tools like Instruments (especially the flame graph and top functions views) to identify performance bottlenecks.
Review WWDC sessions on Swift performance, such as the Swift performance using Instruments session.
Explore efficient data structures like Span and UniqueArray (available in the Swift Collections package).
Apply fundamental computer science principles: use correct algorithms and consider Big O notation.

Should redundant Swift 6 concurrency annotations be removed after the isolation model changes?

Redundant annotations are not harmful and can be left in place.
Some developers prefer explicit annotations for clarity, documentation, or to prevent future regressions.
Explicit annotations can serve as documentation of intent (e.g., “this type absolutely should not be sendable”).
Removing redundant annotations is optional; when developers prefer explicitness, developers can keep them.
Developers can now put non-isolated directly on an extension (Swift 6.0/6.2), simplifying cleanup of per-method annotations.
Adding comments explaining the rationale behind explicit annotations can be helpful for future understanding.

Why is `UserDefaults` not `Sendable` if it’s documented as thread-safe?

Some classes in Foundation, while thread-safe, are not marked Sendable due to potential subclassing issues (e.g., NSString is immutable and Sendable, but NSMutableString is a mutable subclass and not Sendable).
To avoid propagating a “not Sendable” status to all subclasses, some classes were marked as not Sendable by default.
Swift 6.4 introduces ~Sendable (tilde Sendable) which allows more accurate annotation. This indicates a lack of Sendable conformance, allowing subclasses to opt-in if they don’t introduce mutable state.
The standard global UserDefaults is expected to have a Sendable conformance.

Is it good practice to migrate to using `borrow` and `mutate` instead of `get` and `set` altogether?

borrow and mutate are part of Swift’s ownership model and can be more efficient as they avoid copies and extra code by directly referencing data.
borrow provides a reference to data held elsewhere.
mutate provides a mutable reference, requiring exclusive access to the data.
get and set are more general: get produces a value (potentially computed), and set can involve arbitrary code to make changes.
Recommendation: Use borrow and mutate for performance-sensitive scenarios where data is already sharing data already stored. Use get and set for all other cases.

How do app developers choose between app-focused and systems/embedded Swift features?

Swift is designed with progressive disclosure; do not need to learn all features immediately.
Measure first: Use profiling tools to identify performance issues before adopting advanced features.
Advanced features like non-copyable types add complexity and should only be used when a measured need exists.
Features are designed to work together; aim for complementary usage rather than mixing and matching unnecessarily.
When when issues arise a problem (e.g., a performance bottleneck), there’s likely a Swift tool to help. Learn about that specific tool when the need arises.
Language features are not “collectibles”; focus on solving problems rather than collecting features.
Advanced performance features are often most effective in isolated, “hot path” areas of code.

How do type inference, generics, and associated types affect incremental build performance?

Features like type inference, generics, and associated types can affect build performance in extreme cases, but generally don’t impact overall project build times.
Slow module emission is often related to the number of imported modules.
Use explicit module builds (now on by default in Xcode) and the build timeline in Xcode to diagnose where the compiler is spending its time.
Look for excess dependencies that might be causing rebuilds.
Performance tuning the build requires analyzing where the compiler is spending its time.

Would the Swift team approach concurrency differently if designing it today?

The behavior of non-isolated async functions is a key area of reflection.
Initially, non-isolated async functions were designed to always switch to the global concurrent thread pool.
Experience showed that this could lead to data race safety errors when passing non-sendable types between actor-isolated contexts and these functions.
The behavior was changed in Swift 6.2 to make non-isolated async functions stay on the context they were called from (e.g., remain on the main actor if called from there).
This change avoids issues with concurrent access to non-sendable values.
Offloading work to the global concurrent thread pool is still useful but should be explicit and opt-in.
The revised model is more approachable, mirroring non-concurrent behavior and making explicit choices about introducing concurrency.

What are notable Swift Package Manager build improvements in recent releases?

The primary improvement in Swift 6.4 is the unification of build system implementations for Swift Package Manager (SPM) in Xcode and the open-source swift build tool.
A preview shipped in Swift 6.3; unification is on by default in Swift 6.4.
Both now use the Swift build package, leading to a single point of maintenance for bug fixes and improvements.
This unification brings performance optimizations from the Swift build system to normal package builds.
Explicit modules are now available for package builds.
The build system can better parallelize module builds, improving overall build performance.
These improvements are under-the-hood and do not require opt-in.

What’s the one Swift feature most developers don’t know exists but should know?

inlineable attribute combined with inline never:
- inlineable unlocks optimization opportunities beyond just inlining, such as generic specialization and effects propagation, especially across module boundaries.
- Combining inlineable with inline never is a powerful performance tool for generic code with cold paths, preventing the compiler from inlining potentially large, infrequently used code while allowing the fast path to be inlined.
Type annotations with as:
- Using as with a specific type can help resolve ambiguity errors from the compiler, influence overload resolution, infer type parameters, or provide more precise error messages.
Swift as an open-source project:
- Development happens in the open on forums.swift.org. Participation is valuable for all developers, not just those on non-Apple platforms. Feedback on APIs, diagnostics, and proposals is welcome.
- Confusing compiler diagnostics can be improved by describing what was unclear on the forums — no compiler expertise required.
- SwiftSyntax is a good entry point for contributing to the open-source project.
~Sendable (tilde Sendable):
- This feature allows more accurate annotation of types that are not Sendable, distinguishing between types that are definitively not Sendable and those where subclasses might be Sendable.
Integer overflow APIs:
- Swift provides APIs to carry overflow, allowing computations to complete and then checking for overflow at the end. This is useful for integers that might grow large.
Key Paths:
- Key paths allow referring to properties in the abstract without an instance, useful for abstracting over properties and building elegant API constructions.
Swiftly:
- A tool for easily installing newer toolchains and trying out experimental Swift features, usable directly from Xcode.

What’s left in language evolution to get tuples to finally conform to `Equatable`, `Hashable`, `Comparable` etc. conditionally?

This requires an evolution of parameter packs.
The necessary components are:
- The ability to write an extension over a tuple type where element types are represented by a parameter pack.
- A where clause condition on each element in the parameter pack (e.g., where each T conforms to Protocol).
- Syntax for writing a parameterized extension where the extension itself has a parameter pack.
An experimental implementation exists in the compiler repository.
This evolution aims to provide general conditional conformance for tuples to protocols, not just the three mentioned.

How should high-frequency sensor data reach an `@Observable` model on the main actor without blocking the UI?

The definition of “high frequency” is crucial; if it’s significantly lower than UI update rates, less work may be needed.
Avoid excessive context switching: Minimize switches between the background actor and the main actor’s observable data model.
Debouncing: Accumulate data and coalesce multiple updates into fewer events before sending them.
Data Loss: Consider acceptable data loss. Not every nanosecond update may need to be rendered.
SwiftUI and @Observable naturally coalesce updates for efficiency.
Ensure UI updates are only for what the user needs to see, potentially splitting the problem into halves if necessary.
Swift Async Algorithms offers a debounce implementation for async sequences.

Why is a tuple more expensive than a struct when returned from a method? Or is it a custom case and there’s actually no difference?

Tuples and structs are handled differently by the compiler.
Structs are generally passed as a single entity.
Tuples are often “exploded” inside the compiler, meaning each element is treated as a separate parameter.
For very large tuples, this “exploding” might be less performant than passing a single, large struct.
Further investigation via actual code and optimizer output is needed for a definitive answer. A GitHub issue with a sample project is requested.

What are notable lesser-known Swift quality-of-life features?

Iterable Protocols (forward-looking): Aims to make complex topics like non-copyable/non-escapable types feel natural, enabling operations like for-in over spans.
Bidirectional Type Inference and Generics Diagnostics: The ability to write less explicit type information and receive error messages at the implementation site of generic code, rather than the use site.
Avoiding Mutable Shared State: Features like copy-on-write and the ownership model provide confidence that code is purely a function of its inputs and outputs, simplifying complex code.
Generic System and Protocol Extensions: Extending protocols to add operations creates reusable generic algorithms that are natural and simple to use, leading to better code patterns.
Integer Overflow APIs: APIs that allow carrying overflow, enabling computations to complete and then checking for errors, useful for integers that might grow large.
Key Paths: Abstracting over properties without an instance, enabling elegant API constructions.
Swiftly: A tool for easily installing and trying newer toolchains and experimental features.

SwiftUI for Beginners

Miká Kruschel — Tue, 09 Jun 2026 00:00:00 GMT

SwiftUI for Beginners

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

Related Labs: SwiftUI (June 10), SwiftUI (June 11)

Should I use React Native or SwiftUI?

SwiftUI is tightly integrated with Apple’s platforms, providing immediate access to new design languages and platform features.
Cross-platform frameworks like React Native may lag behind native platform updates, leading to an “awkward middle spot” and more work to adapt.
SwiftUI leverages the power and expressiveness of the Swift programming language, offering performance benefits.

What is the best approach to learn SwiftUI with no coding background?

Identify a personal problem or a need for a family member that an app could solve, which will provide motivation.
Utilize agentic coding tools in Xcode to build and see the app come to life quickly.
Focus on finding the “spark” or what motivates development to build, and let that guide the learning process.

What roadmap leads to job-ready iOS engineering skills in 2026?

Start with a strong understanding of Swift fundamentals, including its type system and concurrency features.
Dive into SwiftUI by building a basic app that is interesting, utilizing online interactive tutorials.
Treat AI coding tools as tutors: ask questions about the generated code, understand its logic, and use them for code reviews.
Focus on understanding underlying computer science concepts, networking, and data storage, not just UI.
Read the Human Interface Guidelines alongside technical tutorials.

What happens under the hood with `@State`, and why not a plain `var`?

@State tells SwiftUI to own and persistently store a value, allocating a dedicated piece of memory for it.
SwiftUI views are value types (structs) that are recreated frequently. Standard var properties would be lost on recreation.
@State ensures that when the value changes, SwiftUI knows to re-render the view, while standard vars would not trigger updates.
The Swift compiler prevents direct modification of vars within a view’s body, guiding developers to use @State for mutable UI data.

How easy is it for web developers to get started with Swift and SwiftUI?

Swift’s syntax is C-like and shares many concepts with JavaScript, making it familiar.
SwiftUI’s declarative nature and hierarchical view declaration are similar to HTML and CSS concepts.
Existing coding knowledge, even from web development, provides a significant advantage.
Utilize Xcode’s previews and Device Hub for dynamic layout updates, similar to a browser’s live reload.

Where should a Java developer start with SwiftUI, given the abundance of tutorials?

Begin with the official Apple SwiftUI tutorials, which cover views, state, animations, and data flow.
Consider Paul Hudson’s “100 Days of SwiftUI” for bite-sized, helpful content.
Explore community resources like books and articles for supplementary learning.
Let the desired app idea guide the learning; search for how to implement specific features.

How should SwiftUI handle frequent real-time state updates without lag?

Use @Observable for frequently updating data; SwiftUI ensures only changed observable properties trigger UI updates.
Keep view bodies as lightweight as possible, ideally as “leaf views,” to minimize redraws.
Utilize lazy stacks (LazyVStack, LazyHStack) and List for content that only needs to be rendered when visible.
ForEach inside lazy containers (List, LazyVStack) is optimized by default — profile before adding custom optimizations.
Trust SwiftUI’s built-in laziness; optimize only when profiling shows a need.
Limit dependencies on rapidly changing data within the UI and avoid putting constantly updating values (like current time) in the environment.
Consider if the UI truly needs per-frame updates or if a semantic state change is sufficient.
Use TimelineView when developers need time-driven updates rather than pushing constantly changing values through state.
Coarsen semantic state when possible (e.g., three discrete states instead of per-frame values).
Keep async work out of view bodies; use the SwiftUI instrument in Instruments to profile update patterns.

Has Apple’s intelligence within Xcode been fed with all the information and documentation around SwiftUI?

Xcode’s agentic coding now includes “SwiftUI skills” trained on internal knowledge and best practices for data flow and new APIs.
These skills are automatically invoked by the coding agent in Xcode.
Skills can be exported for use with third-party AI models.
File feedback when developers encounter issues with the skills to help improve them.

What are the best practices to make SwiftUI views performant and avoid unnecessary view updates?

Use @Observable to establish dependencies only on properties read by a view, ensuring only relevant parts update.
Break down large views into smaller, reusable custom views to allow SwiftUI to re-evaluate only necessary components.
Moving code from body into computed properties does not improve performance — only extracting custom struct views enables separate invalidation boundaries.
Minimize the properties read from the environment within ViewBody to prevent unnecessary invalidations.
Extract repetitive modifiers or view snippets into custom modifiers or custom views for better maintainability and reusability.
Avoid heavy work or frequent allocations (like creating NumberFormatter or array transformations) directly within view bodies.

Is using AI to write SwiftUI code effective for beginners?

Treat AI tools as tutors: ask questions about generated code, explore alternative approaches, and understand the “why” behind the suggestions.
Interrogate the AI’s output; if a step is unclear, ask for clarification until understood.
Use AI for code reviews by providing custom code and asking for feedback on improvements or alternative APIs.
Focus on gaining a deeper understanding of the code and concepts rather than just generating more code faster.
Weigh trade-offs between different solutions and avoid letting the AI make all the architectural decisions for developers.

Is there a high-level resource, like a one-page overview or flow diagram, to build a clear mental model of SwiftUI?

Explore talks from early SwiftUI releases, such as “Intro to SwiftUI” and “SwiftUI Essentials.”
Refer to the official one-pager on getting started with SwiftUI on the developer website.
SwiftUI sessions from WWDC are highly recommended for quickly learning concepts.

How can beginners use Xcode AI tools to learn correct SwiftUI patterns?

Utilize Xcode’s “skills” which are trained on best practices and newer APIs to avoid incorrect patterns.
Allow the AI model to check its work by compiling; Swift’s compile-time error checking helps identify issues early.
Break down requests into smaller, piecemeal steps rather than asking the AI to implement everything at once.
Focus on encapsulated, well-structured code generated by the AI.

What’s one thing announced yesterday that beginners will overlook but will matter very much as they grow in SwiftUI?

Layout flexibility improvements, especially for resizable apps across different Apple platforms (iPad, macOS, Vision Pro, and mirrored iPhones).
Leverage SwiftUI constructs for flexible layouts and consider creating custom layouts for complex scenarios.
Use DeviceHub to test apps across various aspect ratios and screen sizes.

How should designer mockups be converted to SwiftUI?

Translate designs by considering SwiftUI’s layout primitives and custom understanding of how to map design elements to code.
Explore Figma and Sketch connections that can generate SwiftUI code directly from designs.
Avoid relying solely on AI for direct design-to-code conversion; manual translation and understanding are key.

visionOS

Miká Kruschel — Tue, 09 Jun 2026 00:00:00 GMT

visionOS

Unofficial AI summary of the WWDC26 group lab. May contain mistakes.

Watch on Apple Developer · Raw transcript

How can independent developers gain access to the front-facing cameras for app development?

Access to stereoscopic camera pairs is available through standard Apple Developer Program accounts, typically for incorporated businesses.
Developers with a clear use case and need for camera access can apply for it.
When developers encounter issues accessing cameras and have a valid use case, post on the developer forums.
Share the use cases for front-facing camera access on Feedback Assistant to help Apple understand developer needs.

How can developers debug applications in immersive spaces without losing context or relying solely on pass-through?

Enable the “Mac virtual display” developer setting within an immersive environment.
This allows developers to run and debug the app in Xcode while remaining within the immersive space, providing a safer and more efficient workflow.
The Mac Virtual Display offers a large, high-quality display for debugging and triaging issues.

Are there any agent skills from WWDC that are particularly relevant for visionOS development?

The most relevant agent skill helps resize existing iOS apps for visionOS.
This skill assists in translating iOS UI elements to the visionOS form factor, maintaining best practices for the platform.

What is the recommended workflow for exporting 3D models to USD, especially when dealing with FBX or GLB files?

Start with USD export directly from the 3D content creation tool (3DCC) to avoid format conversion issues.
Be aware that different 3DCCs may have variations in how they build files, which can sometimes complicate USD export.
For iterative workflows, consider using the USDA (ASCII) format over USDC (binary) to modify individual files without repackaging the entire scene.
Modern LLMs can potentially assist with USD file understanding and manipulation, leveraging the core USD specification.

Can spatial accessories be tracked when they are outside of the user’s direct line of sight?

visionOS 27 has expanded support for spatial accessories, opening the spec to new accessory types.
Accessories use a combination of Bluetooth, onboard IMUs for high-frequency tracking, and infrared emitters visible to Vision Pro’s cameras.
Tracking fidelity for occluded or distant accessories depends on the accessory’s size, distance, and the Vision Pro’s ability to see the infrared emitters.
A new debugging mode allows developers to see the infrared feed from Vision Pro to assess accessory visibility.
Developers are encouraged to share use cases, such as foot trackers, via Feedback Assistant.

When using Gaussian splatting, why are splats culled when the user’s face moves close to or inside them, and can this be disabled?

There is currently no known way to disable the vignetting or culling effect for Gaussian splats when they get too close to the user’s face.
This effect is also present for other 3D models to ensure an unobstructed user field of view.
Developers are encouraged to file feedback with detailed use cases, especially for telepresence applications, to inform future development.
Providing sample projects, videos, or screenshots with specific distances can help engineers reproduce and address issues.

Is Gaussian splat rendering supported on platforms other than visionOS, such as iOS?

Gaussian splatting should be supported across both iOS and visionOS.
When developers encounter issues or documentation mismatches in Xcode, file feedback.
Beta versions of features may not always work as expected, so reporting issues is important.

Why aren’t there user profiles on Vision Pro, similar to macOS, to allow for easy switching between different users (e.g., owner, child, guest)?

Vision Pro is designed as a personal device, prioritizing the best experience for the primary user.
To facilitate sharing, enrollment data can be saved to an iOS 26+ device, allowing quick switching via an App Clip code when in guest user mode.
Guest user mode with nearby device pairing allows others to access the Vision Pro without needing the owner’s passcode, with screen mirroring via AirPlay for assistance.

Is there an API to detect the owner’s lips and face to mimic them on 3D models like Persona, but with different effects?

Face tracking provided by ARKit is an iOS-only feature and is not available on visionOS.
While raw face data is not exposed, third-party apps can access a simulated video feed from the front-facing camera equivalent.
This simulated feed provides a matted version of the persona (persona in front of a background), suitable for video conferencing but not for applying lens-style effects to the face.
Developers are encouraged to file feedback for use cases involving custom face manipulation.

Does Visual Intelligence require third-party apps to access the main camera?

Visual Intelligence is a system-level capability and does not require third-party apps to access the main camera.
Information is not shared with third parties, ensuring a privacy-preserving experience.
The system can provide immediate answers about viewed content, including real-world objects.

How do game controllers fit into the visionOS interaction model in version 27?

Apple initially supported PlayStation VR2 Sense controllers and the Logitech Muse stylus via the Game Controller framework and ARKit.
These inputs are deeply integrated at the system level, usable for launching apps and controlling window behavior.
visionOS 27 introduced expanded spatial accessory capabilities, allowing developers to build custom accessories with high frame rate and accurate pose tracking.
The primary interaction model remains gaze and pinch, with controllers and spatial accessories offering extended capabilities for specific experiences.
The type of input should be thoughtfully chosen based on the intended user experience, whether for refined input, gaming, productivity, or natural interaction.

Are there any updates to WebXR in Safari with visionOS 27, particularly for immersive AR mode?

Safari on visionOS supports WebXR, but currently only in an immersive-only rendering mode (VR).
Immersive AR mode for WebXR is not yet supported.
Developers are encouraged to investigate visionOS’s platform APIs for augmented reality experiences, which may offer capabilities beyond current WebXR limitations.
New features like the <model> tag allow for positioning USD assets within a webpage and then pulling them out into the user’s environment.

For Visual Intelligence on visionOS, is it purely camera-based, or does it leverage depth sensors?

The system uses a blend of all available sensors on the device to provide the best possible and most accurate results.
This approach is not unique to Visual Intelligence and applies to other system-level functionalities like SLAM and hand tracking.
The specific sensor implementation varies by device to optimize for its capabilities.

How can Vision Pro stay awake on a desk during development?

There is no sanctioned way to keep the device awake on a desk during development due to security reasons.
Vision Pro lacks a lock button, and the device automatically locks when removed from the head to ensure authentication (Optic ID or passcode) upon re-wearing.
Mac Virtual Display (MVD) is the recommended workflow for development, allowing developers to keep the device active and connected while debugging.
Setting up Optic ID can significantly speed up re-authentication when removing and re-wearing the headset.

What is the state of automated testing for visionOS, ARKit, and RealityKit?

For RealityKit, use the RealityRenderer class for driving rendering through automated tests.
Explore the “Migrate to Swift testing” and “Get the Most Out of Device Hub” sessions for automated testing strategies.
Device Hub offers significant capabilities for automated testing.
RealityKit is written in Swift, so existing Swift automated testing infrastructure and Xcode tooling should work.

What are the biggest mistakes new visionOS developers make?

Information Density: Avoid overwhelming users with too much text or information in large windows, as it differs from 2D platforms.
Tap Target Size: Adjust the size of tap targets and UI elements for eye and hand interaction, which is different from touch-based interfaces.
Leveraging visionOS Capabilities: Don’t just port 2D apps; create new features and experiences that are uniquely possible in visionOS, such as 3D product models that can be placed in the user’s environment.
Content Quality: Pay close attention to encoding settings and visual quality for compressed content (video, images) as Vision Pro’s high-fidelity display can reveal artifacts.
Thinking Beyond Existing Paradigms: Embrace spatial computing’s unique capabilities rather than solely relying on past technological approaches.
Review the Build Next Generation Experiences for visionOS 27 session for Unity, Unreal, and streaming pathways.

Regarding agentic coding in visionOS, if an LLM generates visionOS project code with incorrect syntax, is there a way to fix this or teach the AI about visionOS code?

LLM-generated code may contain errors; always double-check the output (“trust but verify”).
Use the robust library of visionOS sample projects as training data for local LLMs.
Newer LLM models may not be trained on the latest API SDK capabilities, leading to potential discrepancies.
Utilize specific visionOS sample projects like “Hello World,” “Petite Asteroids,” “Canyon Crosser,” and the “Model Manipulator” sample for targeted learning.

For object tracking in visionOS, how fast can it get, and what are the possible frame rates and latency?

visionOS 2.0 primarily focused on tracking stationary objects at approximately 5 frames per second (Hz).
visionOS 27 introduces a high frame rate mode, supporting up to 30 frames per second with significantly lower latency.
Engineers have implemented smoothing algorithms that make tracked objects feel more attached and responsive.
The same trained object tracking models can now work on iOS devices, with an extended training mode in CreateML for higher accuracy and lower latency.
Object tracking updates are now frame display time-aligned, eliminating guesswork about frame timing.

Will Apple expose more underlying sensors and frameworks for accessibility telepresence?

Apple does not comment on future plans.
Developers are encouraged to file feedback with specific use cases, especially for accessibility.
Accessibility is a core principle, and Vision Pro has significant potential for enabling accessibility features through developer or internal initiatives.
Features like the magnifying glass and wheelchair control powered by Vision Pro highlight the platform’s accessibility potential.

How can Mac Virtual Display work on shared or enterprise Macs without a shared iCloud account?

Mac Virtual Display currently requires both the Mac and Vision Pro to be on the same iCloud account.
Alternative methods like reverse AirPlay or screen mirroring from Mac to Vision Pro exist but do not offer the same experience as Mac Virtual Display.
Spatial Preview functionality is not iCloud dependent and can be used to share USDZ compliant content to other devices.
Remote Immersive Space allows rendering on a Mac and streaming stereoscopically to Vision Pro without requiring the same iCloud account.
Foveated streaming also enables bringing PC-rendered content to visionOS, with the visionOS app retaining native capabilities like SharePlay.

Can Gaussian splats be part of a USDZ file, perhaps mixed with other meshes, and used in a website environment?

OpenUSD supports “particle fields,” a generic form of Gaussian splats, but this feature is not yet directly integrated with Reality Kit’s splat capabilities.
Apple is working on closing this gap in future releases.
USD can express multiple elements in a scene, allowing for the containment of different types of data, including splats and meshes, within the same scene.
The development process involves aligning specifications, runtime capabilities, and authoring tools for a complete Gaussian splat ecosystem.

Setting Up a Coolify Build Server with Hetzner and a Self-Hosted Registry

Miká Kruschel — Sun, 22 Jun 2025 00:00:00 GMT

Setting Up a Coolify Build Server with Hetzner and a Self-Hosted Registry

Using a dedicated build server offloads resource-intensive image building from your main application server. Here’s how to set one up with a Hetzner server and a self-hosted Docker registry managed by Coolify.

1. Prepare Your Build Server on Hetzner

Create a new server in Hetzner Cloud (Ubuntu recommended).
Configure a Hetzner Cloud Firewall:
- Allow incoming Port 22 (TCP) for SSH access.
- Block other incoming ports.
Note the server’s IP address and SSH credentials.

2. Connect Build Server in Coolify

In Coolify, go to Keys & Tokens and add the SSH Key for the build server.
Then go to Servers.
Click Add Server, toggle Use as Build Server.
Enter the Hetzner server’s IP address, SSH user, and choose the key you have just added.
Coolify will connect and set it up.

3. Why You Need a Docker Registry

When using a build server, the created Docker image needs to be transferred to your main hosting server. This transfer happens via a Docker Registry.

You can use a hosted service (like GitHub Packages) or self-host one. We’ll self-host using Coolify.

4. Self-Host Your Docker Registry (via Coolify)

Run the registry service on your main Coolify hosting server.

In Coolify, create a new Project (e.g., Infrastructure).
Add a Service within that project, select Docker Registry.
Under Service, click on the edit button next to the domain and set it to, e.g., https://docker-registry.yourdomain.com:5000. Start the service.
Set up Authentication:
- Go to the Persistent Storages tab for the registry service. Note the Source Path for the /auth/registry.password.
- Generate a user/password entry using htpasswd -nbB YOUR_USERNAME YOUR_PASSWORD. This can be run on your local machine. Copy the output string.
- SSH into your Coolify hosting server. Edit the auth/registry.password file. Replace the content with the string from htpasswd. Save the file.
- In Persistent Storages, click on the Load from Server button and save.
- Deploy the Docker Registry service.
Log in on both servers:
- SSH into your Hetzner build server. Run docker login docker-registry.yourdomain.com -u YOUR_USERNAME -p YOUR_PASSWORD. (Run docker logout first if needed).
- SSH into your Coolify hosting server. Run the same login command.

5. Configure Your Project for Build Server & Registry

Tell your application project where to build and where to push/pull the image.

Go to your Project in Coolify.
Find “Use a Build Server” and toggle it ON.
Find the Docker Image field in the Docker Registry section. You must prefix the image name with your registry address and add slash.
- Change the value to docker-registry.yourdomain.com:5000/milk (replace milk with your image name).
- Important: Without the / after the port/hostname (docker-registry.yourdomain.com:5000), Docker automatically prefixes the url with docker.io/library/ leading to the error: The push refers to repository [docker.io/library/docker-registry.yourdomain.com] and denied: requested access to the resource is denied.

Save settings and re-deploy. Coolify will now use the build server to build the image, push it to your self-hosted registry, and then the hosting server will pull it from there.

Indie App Catalog has a new maintainer

Miká Kruschel — Sun, 24 Nov 2024 00:00:00 GMT

IndieAppCatalog has a new maintainer 🎉

whoami

Hey, I’m Miká! I’m a math student and indie developer. Since starting with Apple development in 2020, I’ve been creating developer tools like Astra (App Store ratings), Trendly (sales analytics), Plutus (financial reports), and Squircle (macOS icon tool).

The Current State

The catalog features over 1,400 apps by nearly 1,000 indie developers – a wonderful showcase of what our community creates.

What’s next

I’ve hit the ground running, already enhancing how we gather app data. For instance, the catalog now supports newer device screenshots, higher resolution images, and displays app subtitles.

Looking ahead, I’m planning a fresh redesign, introducing a category for TestFlight links, and much more.

But I’d love to hear from you! What features would make IndieAppCatalog even better? Feel free to share your ideas via Mastodon, Bluesky or email.

Thanks

A huge thank you to Filip Němeček for creating and maintaining IndieAppCatalog until now. I’m honored to continue this project.

Miká Kruschel

Awesome App Landing Pages

Awesome App Landing Pages

Machine Learning & AI

Machine Learning & AI

How should developers decide between on-device Foundation models and private cloud compute?

What factors influence latency when choosing between local and private cloud compute models?

How can developers use both on-device and private cloud compute models within the same app or feature?

Why might an Xcode-connected local LLM using MLX server exhibit strange behavior like long delays and an IAM_N tag, and how can this be resolved?

How can local LLMs running on MLX LM or custom Core AI models be used as coding agents in Xcode to manipulate projects, beyond simple chat interactions?

How can developers detect when on-device or private cloud compute models have been updated, especially if prompt behavior regresses?

Can Foundation Models run from widgets, app intents, or background tasks, and what are the considerations for rate limits and thermal rules?

How can developers create or adapt models for their own apps, data, and domains, such as generating stylized user profile images or adaptive app guides?

What are the best use cases for the Foundation Models Framework, and which should developers avoid?

Where should a beginner start to learn about AI/ML, and what resources are recommended?

Is it possible to import everything from PyTorch into Core AI or the Apple ecosystem, and what are the limitations?

What is the best user experience when Foundation Models are unavailable (e.g., older devices, Apple Intelligence off, low battery), and how can developers detect availability and degrade gracefully?

How should developers migrate from Core ML to Core AI, and what is the recommended approach for supporting older devices?

What is the maximum on-device local model size that can be used before considering private cloud compute, and what are the considerations for iOS and macOS?

How should developers decide when AI should assist the user versus when it should remain in the background?

For older iPhones without Apple Intelligence and using a self-hosted LLM backend, is wrapping the backend in a custom language model provider the recommended path on iOS 27?

SwiftData

SwiftData

What’s the proper way to use SwiftData with widgets and app intents?

How should developers approach large data sets in SwiftData?

What are the best practices for creating sample data for previews and testing?

When should a developer choose ResultsObserver over Query?

How are sums and averages handled in SwiftData without loading all data into RAM?

What’s the best way to construct view state for populating non-optional attributes when adding a new model object?

How can SwiftData + CloudKit adopt an app group or schema version without losing data?

How does using an app group for the SwiftData local store affect CloudKit development and production environments?

When evolving the schema in Xcode during development, do I need to do anything to avoid creating duplicates in the local store between two apps writing to the same CloudKit?

What’s the most performant way to count SwiftData objects without querying them in views?

How can CloudKit synchronization be sped up between devices?

What’s the best way to store enums, including those that conform to Codable with associated values, in SwiftData?

What are the best practices for using multiple model contexts? When does it make sense to split work across separate contexts?

How do I know if I need to paginate my queries instead of fetching all records of a given type?

Is it a good idea to combine SwiftData with a cloud backend for sync, or is that an anti-pattern?

What’s the proper way to know if a database migration is required or not?

What’s the best way to do grouped queries, like grouping results by one property of a model and then displaying the results in sections?

What’s the recommended way to handle concurrency when a model actor needs to return model data?

App Store Connect

App Store Connect

What are the most overlooked App Store Connect APIs or capabilities developers should use?

How should apps without audio signal accessibility for hearing-impaired users?

What are the most common reasons subscription apps get rejected on their first review, and what are pro tips for new developers?

Will App Store Connect analytics show impressions, retention metrics, and how often a user revisits the cancel flow for retention messages?

What are the most common security mistakes developers make when implementing App Store Connect API integrations?

In App Store Analytics, is there a way to see how many people updated organically versus in the background (auto-update vs. manual)?

For large companies with many apps, is there a way to automate uploading only a few apps from CI without a team API key granting access to all apps?

Can universal purchase apps use different names or subtitles per platform?

Does the new retention workflow support localization, and should retention messages be localized to match app localizations?

What are the best practices for App Store app descriptions, especially when many popular apps use dense copy?

What are the best practices for using TestFlight for internal team testing, and how about external testing?

What are best practices for App Store Connect API keys in tooling and automation?

Is there a way to use the same product name on the App Store for a Mac app and iOS/Apple Vision Pro apps combo if they have different bundle IDs?

What should first-time App Review submissions get right for auth and API keys?

How can purchase restoration be validated when transitioning a paid app to freemium?

How do developers publish their first iOS app?

Once an app is approved, how can I increase its visibility?

Do I need a different binary for every platform (watchOS, iOS, etc.) for a universal app?

For review notes, if an app is localized to multiple languages, should the notes still be in English, or can they be in the developer’s native language?

What new App Store Connect workflows introduced this year should developers revisit, even if they already have mature automation in place?

What are the most common reasons for rejection on the App Store?

Which validations only run after TestFlight or App Store Connect upload?

Is there a way to organize TestFlight builds into streams or groups, for example, keeping a major new feature separate from regular builds?

Is there a technical or policy reason for the few-day delay on price changes for in-app purchases or subscriptions, including when lowering the price?

How should country-specific app listings be merged when features differ?

What features are provided by the new App Store dashboard with analytics, and how can developers maximize value?

Any tips for creating a successful featuring nomination submission?

What is the least-privileged App Store Connect API role for third-party tools?

Any advice on fetching live or last 24 hours of App Store Connect data via the API, given the UI shows this but the API only updates daily or provides aggregates?

How can organic search custom product page impact be measured without keyword-level data?

Is there a way to see the rollout progress of the current release while a new release is being prepared and submitted to review?

What options are open to developers building geospatial augmented reality games in terms of passing app review, especially if a full working demo is difficult to create?

Apple Intelligence

Apple Intelligence

What are the most useful Apple resources for learning and applying new APIs and design changes?

How do I integrate with Siri when no app schema fits my entities?

Should I use the closest schema match or skip schemas when the fit is imperfect?

Why might an Xcode-connected local LLM using MLX server exhibit strange behavior like long delays and an `IAM_N` tag, and how can this be resolved?

When should a developer choose `ResultsObserver` over `Query`?

What’s the best way to store enums, including those that conform to `Codable` with associated values, in SwiftData?

How to avoid `language model session.generation error.guardrail violation`?