WWDC Quick Look đź’“ By SwiftGGTeam
中文 EN 日本語
Platforms State of the Union

Platforms State of the Union

WWDC 2020
Watch original video

Highlight

Apple announced that Mac will switch from Intel processors to self-developed Apple Silicon, and simultaneously released macOS Big Sur, iOS 14 (Widgets + App Clips), iPadOS 14 (Sidebar + Scribble), watchOS 7 (SwiftUI watch face component) and Xcode 12. Unified architecture enables unmodified iPhone/iPad apps to run directly on Mac for the first time.

Core Content

This State of the Union is not a single frame launch. It answers the most realistic questions for developers in 2020: Mac needs to change its processor, iOS home screen needs to be opened to third-party information, iPad needs to continue to grow from a large iPhone into an independent platform, and watchOS needs to turn the dial into an application entrance. Developers cannot just look at an API. They need to determine at which entrances their applications will be discovered by users, on which hardware they will run, and in which system UIs they will be re-rendered.

In the past, the boundaries of Apple’s platforms were clear. Mac apps have their own binaries and window models, iPhone/iPad apps stop on touch devices, Watch face components rely on ClockKit, and iOS apps typically rely on web pages or full installations for a lightweight experience. Changes in 2020 push these boundaries toward the middle: Universal apps contain both Apple Silicon and Intel code, iPhone/iPad apps can run on Apple Silicon Macs, WidgetKit brings SwiftUI views to the home screen, and App Clips break down a task into instant experiences under 10MB.

This also explains why SwiftUI appears repeatedly throughout the presentation. macOS’s Notification Center is built with SwiftUI. WidgetKit relies on SwiftUI view archiving. WatchOS 7’s complication can reuse SwiftUI views. SwiftUI itself also adds Lazy stacks, grids,@mainandDocumentGroup. The route given by Apple is clear: there are more system entrances and platform differences still exist, but the construction methods should be shared as much as possible.

Detailed Content

Apple Silicon: Mac migration starts with Universal apps

(01:35) Apple switches to self-developed Apple Silicon for Mac in the opening scene. The scope of the changes extends beyond the CPU instruction set itself, with a full set of SoC capabilities coming to the Mac: a unified memory architecture that reduces latency when the GPU accesses data, a Neural Engine that accelerates machine learning inference, a Secure Enclave that continues to protect user keys, and Metal and Apple GPUs optimized for graphics and gaming scenarios.

(17:09) The first step for developers is to create a Universal app. A Universal app contains code for both Apple Silicon and Intel processors. The two binary slices are placed in the same executable file. The system selects the version to run based on the current Mac hardware architecture. Resource files, images, and machine learning models do not need to be split between the two architectures.

Mac migration workflow
1. Open the existing Mac project with Xcode 12.
2. Choose the new "Any Mac" build destination.
3. Use Standard Architectures to generate a Universal app.
4. Run, debug, and test separately on Apple Silicon and Intel Macs.
5. For parts that cannot migrate natively yet, rely on Rosetta 2 as a transition path.

Key points:

  • Any MacIt is the Universal build entry provided by Xcode 12.
  • Standard Architectures will include both Apple Silicon and Intel architectures.
  • AppKit, SwiftUI, and Mac Catalyst projects have all been named for faster conversion to Universal.
  • Apple also provides Developer Transition Kit (DTK) with built-in A12Z, macOS Big Sur preview version and Xcode that supports dual-architecture builds.

(23:35) Rosetta 2 is the compatibility layer during the migration period. It translates Intel executable files into ARM instructions. Applications installed from the Mac App Store or packages will be translated in advance in the background; dynamically loaded code or JIT code will be translated at runtime. Metal graphics calls are converted into native calls to the GPU on the Apple SoC, and system calls are converted into native calls to the kernel. Apple positions it as a transitional technology to give developers time to complete native support.

(32:00) Apple Silicon also brings unmodified iPhone/iPad apps to Mac. The reason is that the iOS frameworks behind Mac Catalyst have binary compatibility on Apple Silicon Macs. The talk showcased Monument Valley and Documents by Readdle: iOS apps appear in the Dock and get an auto-generated menu bar, preferences pane, window minimization, resizable windows, macOS scrollbars, system opening pane, and sharing services. Developers can still choose whether to make their iOS/iPadOS apps available on the Mac App Store.

macOS Big Sur: Design updates also affect code structure

(38:08) Big Sur’s new interface aims to reduce visual clutter while giving macOS and iPadOS a stronger sense of family. The Dock, icons, menu bar, sheet, toolbar, sidebar, Control Center, and Notification Center have all been redone. Notification Center is completely built with SwiftUI, notifications and widgets are presented at the same time, and applications can use the Notification API to provide custom content extensions.

(40:54) The toolbar is not just reskinned. The search bar can be folded into a glyph when there is insufficient space. The three-column layout can divide the toolbar into areas corresponding to different panes. Both AppKit and Mac Catalyst have added toolbar APIs to express this separation. SwiftUI toolbar is attached toNavigationViewPane will automatically get separators. Apple explicitly recommends not usingNSToolbarMac apps are starting to adopt it.

Big Sur UI adaptation checklist
1. Use toolbar, full-size content view, and a split-view controller with sidebar style.
2. Put the search field into the new search toolbar item so the system handles collapse and expansion.
3. Use SF Symbols as the icon source for toolbar and sidebar.
4. Provide the app accent color in Info.plist so selected states, sidebar icons, and standard controls stay consistent.
5. For Mac Catalyst apps, evaluate Mac idiom and switch to native Mac resolution.

Key points:

  • Big Sur will automatically adopt a new structure for the compliance window, eliminating the need to manually redraw each pixel.
  • SF Symbols are configurable on Mac for text size and weight, suitable for sidebars and toolbars.
  • Apply accent colors from plist, affecting system controls, not self-drawn themes.
  • Mac Catalyst adds Mac idiom to avoid using the iPad zoom interface.
  • The macOS version number jumped from 10.x to macOS 11. Apple used this change to emphasize that Big Sur is a system-level update.

iPadOS 14: Sidebar, input controls, LiDAR and Scribble

(47:21) The whole point of iPadOS 14 is to make large-screen apps easier to navigate. The new sidebar expands from two to three columns on all iPad sizes, and is also available in portrait orientation. Photos moved the Library and Albums in the original bottom tab bar to the sidebar, and moved deep entrances such as Favorites and Places forward. outline supports hierarchy and folding, and related capabilities are built on existing components of SwiftUI and UIKit.

(48:46) Input controls have also become more systematic: the date picker supports inline calendars and compact styles, the emoji picker can be evoked with the same shortcut keys as macOS, and the color picker API provides the ability to save commonly used colors and screen color picking. The design direction given by Apple is very specific: reduce modal state and improve the discoverability of deep functions.

(51:36) iPad Pro’s LiDAR Scanner exposes capabilities via ARKit. Scene Geometry provides the scene 3D mesh, and the Depth API gives the precise distance information captured by LiDAR. The talk uses it for more realistic AR placement, Motion Capture, People Occlusion, and room scanning for professional applications like Shapr3D.

(53:51) Scribble makes standardUITextFieldAutomatically supports Apple Pencil handwriting to text. PencilKit adds Canvas API, Stroke API and Drawing Policy API: Stroke API provides angle, pressure, ink type and precise position when the user writes; Drawing Policy is used to distinguish between finger scrolling area, free drawing area and text input area.

iPad app upgrade path
1. Move core entry points from bottom tabs or deep lists into the sidebar.
2. Use outlines and collapsible items for hierarchical data.
3. Replace custom input panels with system date picker, color picker, and emoji picker.
4. For Apple Pencil scenarios, first confirm whether standard text fields already satisfy Scribble needs.
5. When real-time handwriting analysis is needed, then integrate the PencilKit Stroke API.

Key points:

  • Sidebar is a navigation structure adjustment, not just a visual component.
  • Picker updates address data entry efficiency and consistency.
  • LiDAR capabilities are exposed through ARKit, and developers get scene mesh and depth information.
  • Scribble automatically works for standard text boxes, and existing PencilKit applications can inherit many new capabilities.

iOS 14: WidgetKit and App Clips change discovery portal

(58:43) The core model of WidgetKit is timeline entry. Each entry contains SwiftUI view archive, time and date, and relevance score. The system renders the widget on demand when it is both timely and visible, without the need to run the application process. Smart Stack will use device-side intelligence and relevance score to move the currently more relevant widget to the top of the stack.

(01:01:34) When developers define a widget, they need to comply with the Widget protocol and return the widget configuration. This configuration consists of widget kind and timeline provider. The timeline provider is responsible for the snapshot and a set of timeline entries with time. Configurable widgets use the Intents framework, and the system will generate a configuration UI based on the incoming parameters.

WidgetKit content model
1. Widget extension defines the widget.
2. Widget configuration points to the timeline provider.
3. Snapshot returns a single entry for the system to show previews or temporary states.
4. Timeline returns a set of entries declaring when each piece of content should appear.
5. Relevance score tells Smart Stack which entry is more worth showing early.

Key points:

  • Widgets cannot rely on the application to run permanently, and the content must be organized into a timeline in advance.
  • SwiftUI views are serialized into lightweight archives and rendered asynchronously by the system.
  • The previews seen in the Widget Gallery are also from entries created by developers.
  • Configurable UI is generated by Intents framework and is suitable for users to select parameters such as roles, locations, accounts, etc.

(01:03:53) App Clips solves another entry problem: users only want to complete a current task and do not want to download the complete app first. The App Clip card is automatically generated by Apple based on App Store metadata, and the App Clip has been downloaded in the background when the user sees the card. It can be paid with Apple Pay, signed in with Sign in with Apple, doesn’t occupy the home screen for long, and recent usage history can be found from the App Library.

App Clip ordering flow
1. Create an App Clip target in Xcode.
2. Add only the classes and asset catalog needed for ordering to target membership.
3. Control size by removing libraries not needed for the current task, staying within the 10 MB limit.
4. Use the eight-hour notification permission for short-term reminders such as order completion and parking expiration.
5. Show StoreKit overlay when the task is complete to guide users to install the full app.

Key points:

  • App Clip is a small part of a complete app that still uses SDK capabilities.
  • Apple Pay and Sign in with Apple reduce input costs in immediate tasks.
  • The eight-hour notification permission is only suitable for short-term scenarios, and the speech uses parking expiration and order completion instructions.
  • App Clip-specific API to verify that it was evoked at the expected location.
  • When upgrading to the full app, the choices made by the user in the App Clip can be carried over.

watchOS 7, Xcode 12 and SwiftUI: string together system entries

(01:08:53) watchOS 7 lets developers build complications with SwiftUI views and allows multiple complications to be created per family. The Whale Watch example in the speech creates complication descriptors for different observation stations. Each descriptor uses the site name as a unique identifier. Click to jump to the corresponding details page; another descriptor is used to quickly record sighting information; the complex Season Data complication only supports large rectangular spaces.

(01:11:05) SwiftUI complications can use Gauges, Progress Views, or wrap existing SwiftUI views in the app. Xcode 12 complication previews let developers preview the effect in different watch face sizes, full color or tint mode. Watch Face Sharing shares the watch face configuration. If the recipient lacks the application, it will enter the App Store to obtain it during the sharing process.

(01:16:51) Xcode 12’s tool changes focus on the real development process: StoreKitTest allows in-app purchases and subscription configurations to be placed directly in the project, without the need to deploy to the App Store first; StoreKit Transaction Manager can purchase, confirm, and refund during debugging, and observe real-time app updates. SwiftUI previews add toolbars, code completion speeds up to 12 times, and Swift Packages support asset catalogs, resources, and localized content.

(01:21:30) SwiftUI’s new capabilities remain additive, and existing code continues to compile and run. In terms of performance, the speech used an example of 20,000 photos to illustrate: after replacing the ordinary stack with the Lazy stack, the startup is faster and the memory is reduced from the 500MB level; complex layouts can be used with lazy grids. In terms of application structure, SwiftUI has added new features based on@mainapp entry andDocumentGroup, you can get multi-document application, save state and Undo support with just a few lines of declaration. macOS can also add Settings scene.

SwiftUI 2020 adoption order
1. Evaluate Lazy stacks and lazy grids first for large lists.
2. Try `@main`, App, Scene, and DocumentGroup in new projects.
3. Reuse SwiftUI views in widgets, watch complications, macOS Notification Center, and similar entry points.
4. Use Xcode previews and Library support to turn in-project components into reusable controls.

Key points:

  • SwiftUI updates are additive, and migration risks come from adopting new entries, not from the invalidation of old code.
  • The value of Lazy stacks in large data volumes, lecture illustrated with 20,000 photos.
  • DocumentGroupManage creation and opening of files, and the system provides platform-native behavior.
  • SwiftUI simultaneously connects widgets, watchOS complication, macOS system UI, and multi-platform app structures in 2020.

Core Takeaways

1. Perform Apple Silicon migration audit for existing Mac applications

What to do: Build an existing AppKit, SwiftUI, or Mac Catalyst project into a Universal app and document differences between native runs, Rosetta runs, plugins, or driver dependencies.

Why it’s worth doing: This session clearly regards Universal app as the primary path for Mac migration, and Rosetta 2 just gives time for migration.

How to get started: Choose with Xcode 12Any Mac, confirm that the project uses Standard Architectures, and then check the dynamic loading code, Audio Units, DriverKit peripheral drivers and out-of-process extension one by one.

2. Decide how iPhone/iPad apps are presented on Mac

What to do: Create a Mac availability table for iOS/iPadOS apps, distinguishing between “directly on Apple Silicon Mac” and “deep adaptation with Mac Catalyst.”

Why it’s worth it: Unmodified iPhone/iPad apps run on Apple Silicon Macs, but Catalyst offers more room for Mac customization.

How to start: Check whether the application relies on iPad multi-window, file access, sharing services, setting bundles and extensions; modules that can work directly are allowed to be put on the shelf first, and modules whose experience is not Mac-like are promoted to Catalyst.

3. Make high-frequency information in the application into a Widget

What to do: Put information such as game character status, schedule reminders, weather warnings, and inventory changes that users want to know without opening the app into widgets.

Why it’s worth doing: WidgetKit lets the system display timely content on the home screen or in a Smart Stack through timeline entries and relevance scores.

How to start: First define a timeline that will change within a day, and then design SwiftUI views for small, medium, and large sizes; when the user needs to select an object, use the Intents framework to hand it over to the system to generate the configuration UI.

4. Split an offline or real-time task into an App Clip

What to do: Provide App Clips for single tasks such as ordering, paying for parking, renting equipment, and checking in at the exhibition hall.

Why it’s worth it: App Clip card, Apple Pay, Sign in with Apple, eight-hour notification permission and StoreKit overlay make discovering, completing tasks, and converting complete apps into a short path.

How to start: Create a new App Clip target in Xcode and add only the code and resources required for the current task; invoke it with a URL or on-site logo; use StoreKit overlay at the end of the task to give a reason to install the complete app.

5. Complete large screen and Pencil workflows for iPad apps

What to do: Move deep navigation to the sidebar, use system pickers to simplify input, and support Scribble or real-time handwriting analysis in the Pencil scene.

Why it’s worth doing: iPadOS 14’s sidebar, pickers, Scribble, and Stroke APIs all serve the same goal: making iPad apps more like productivity tools on a large screen and Apple Pencil.

How to start: first extract the key entry from tab or modal to sidebar; replace the standard text input withUITextField;If you already have a drawing canvas, use the PencilKit Stroke API to obtain the pressure, angle, ink type and position.

Comments

GitHub Issues · utterances