WWDC26 Videos

Jorge standing in front of a blackboard writing "WWDC 26 - Videos" with a numbered sequence of icons representing an eleven-step flow connected by arrows, while through the window a park with runners and a blue sky is visible.

Table of contents

My Problem 🤔

Every year the same ritual: the Monday after the Keynote I open the WWDC26 videos and find more than a hundred sessions. Apple offers filters by topic, platform and framework that you can stack until the catalog fits your needs — a great starting point.

What happens to me is that, even with those filters active, if I don’t set my own order I end up jumping from video to video based on whatever title catches my eye in the moment. I watch a bit of SwiftUI, then I jump to AI, then I move on to tools, and by the end of the day I’ve consumed five disconnected sessions that don’t reinforce each other. Comprehension is shallow because each topic block needs prior context that I don’t have.

For a while I’ve wanted to put together my own scheme over what Apple offers. A path with a sense of direction, that builds knowledge cumulatively, that puts the things providing context for everything else first — and that also works as a checklist to tick off blocks as I progress throughout the year.

This year I’ve done it.

My Solution 🧩

My criterion is simple: first the overall vision, then the language core, then the tooling, and finally the specific areas based on what I use most in my work. Each block prepares the ground for the next.

I leave out only the ASL versions and the recaps (Dub Dub Daily, State of the Union recap). Everything else is in — including Group Labs, which although they were live interactive sessions, Apple keeps them in the catalog, so I leave them at the end as a topic reference.

What follows is the grouping I use, and that I tick off block by block throughout the year. If it works for you, make it your own: what matters is having a path to follow, not that it’s mine.

Block 0 — The presentations

Before any technical session, these videos set the frame for the year. The teaser whets the appetite; Keynote and State of the Union are the ones that matter.

Get ready for WWDC26
The pre-event teaser from WWDC itself. Marginal once you’ve seen the Keynote, but it’s in the catalog.

Keynote
The big announcement of the year. Liquid Glass, Apple Intelligence with the new Siri, Xcode 27 with code agents. Not technical — it’s the why behind everything else.

Platforms State of the Union
The Keynote for developers. Here the technical layer already shows up: what changes on the platforms, what priorities Apple has for this cycle, and what will matter for day-to-day work. This video is the map of the territory.

Block 1 — Swift and tooling

With the year’s context clear, I move into the core. Swift first because everything else is built on top of the language.

What’s new in Swift
Language update: ergonomic improvements, enhanced concurrency, safer high-performance code, Embedded Swift and C and Java interop. The state of the language in 2026.

What’s new in Xcode 27
Updates to the environment: code agents, Device Hub, localization, performance and testing tools. If I’m going to live here, I need to know what’s changed.

Get the most out of Device Hub
Deep tour of Device Hub: how it speeds up the development flow and how to quickly diagnose and reproduce issues with devices and simulators. The natural companion to the previous video.

Xcode, agents, and you
How to fold the Xcode code agents into a real workflow. From the initial prototype to polishing a finished app. The practical side of what was shown in the previous video.

Create UI prototypes using agents in Xcode
Prototyping with agents: techniques to iterate over layouts, generate creative solutions and refine ideas into a polished experience. The creative side of agents in Xcode.

Translate your app using agents in Xcode
How agents translate String Catalogs using the app’s context. Strategies to review the output and adjust localizations. The practical side for a global product.

Build, deliver, and automate with Xcode Cloud
What’s new in Xcode Cloud: simplified onboarding, cloud tests, webhooks and distribution. Fundamentals for anyone using it in CI.

Profile, fix, and verify: Improve app responsiveness with Instruments
A full flow to tackle performance problems: Swift Concurrency instrument, Time Profiler and System Trace. Find the bottleneck, measure the improvement, confirm the fix.

Meet the new MetricKit
MetricKit refreshed with vital performance metrics and actionable diagnostics. Cross-referencing metrics with app state via the StateReporting framework for the complete optimization picture.

Migrate to Swift Testing
Adopt Swift Testing alongside existing XCTests using framework interop. Patterns to introduce the new testing capabilities incrementally. Connects with what I cover in SIGBUS.

Block 2 — SwiftUI and persistence

The UI and data stack. I watch them together because in practice they go hand in hand.

What’s new in SwiftUI
New Document protocol with direct disk access, reorder APIs in lists and grids, toolbar improvements, new presentations, AsyncImage caching and lazy state for Observable. The overview of what’s new in the framework.

What’s new in SwiftData
Persistence of external types with Codable, grouping results into sections for SwiftUI, ModelResultsObserver and HistoryObserver to observe changes outside the view. The updates to Apple’s ORM.

Code-along: Add persistence with SwiftData
Hands on keyboard: adding persistence to an existing app step by step. Defining models, integrating persisted data with SwiftUI, managing app state. The best place to cement what was shown in the previous video.

Code-along: Build powerful drag and drop in SwiftUI
Building Solitaire to explore the new drag and drop capabilities: reorder API, drag containers to move multiple items, and a custom lifecycle. Practical and direct.

Dive into lazy stacks and scrolling with SwiftUI
List and scroll performance in SwiftUI. When to use lazy stacks, how to optimize scroll behavior, which patterns to avoid.

Compose advanced graphics effects with SwiftUI
Advanced graphics effects with SwiftUI. Layer composition, blending modes and visual effects that go beyond the basics.

Use SwiftUI with AppKit and UIKit
Incremental adoption of SwiftUI in existing AppKit or UIKit apps: the Observation framework to update views, integrating SwiftUI components into existing hierarchies, and adding full SwiftUI scenes without changing the architecture.

Modernize your UIKit app
Updating iPhone layouts to work well with iPhone Mirroring and on iPad. New tab and navigation bar APIs, preparing the app for Apple Intelligence, and a skill for the code agent that modernizes the codebase.

Block 3 — Apple Intelligence and Foundation Models

The block I’m most interested in this year. I watch it as a unit because each video builds on the previous one.

What’s new in the Foundation Models framework
Access to Private Cloud Compute, integration with third-party and open source models, vision capabilities, context management APIs, built-in semantic search and primitives for agentic experiences. The overview of Apple’s main AI framework.

Build agentic app experiences with the Foundation Models framework
Dynamic profiles, dynamic instructions, context management and orchestration patterns between local and server models. The advanced layer on top of the previous video.

Bring an LLM provider to the Foundation Models framework
Extending the framework by implementing a LanguageModelExecutor for new models. Interacting with the session transcript, managing state, optimizing the KV cache and supporting custom segment types. The door to integrating your own model into Apple’s stack.

Debug and profile agentic app experiences with Instruments
How to debug and profile agentic experiences with Instruments. Because when something fails in an agent, you need to know where and why.

Meet the Evaluations framework
In a probabilistic world, unit tests aren’t enough. Quantitative and qualitative metrics, model judges, aggregate statistics to ensure AI features work reliably.

Create robust evaluations for agentic apps
The advanced evaluations layer: flows with tool calling, dynamic conditions, synthetic data generation, judges and dataset validation. The real work behind getting an agent to behave correctly.

Improve your prompts by hill-climbing with Evaluations
Using the evaluation loop to improve prompts iteratively. The closing piece of the evaluations block.

Build AI-powered scripts with the fm CLI and Python SDK
Scripts with the Foundation Models CLI and Python SDK. Automation and prototyping outside the Swift environment.

Block 4 — Siri and App Intents

The bridge between the app and the system’s intelligence. I go from the conceptual to the practical.

Announcing Apple’s next big step for Siri and iPhone
The big announcement of the new Siri. The essential context before diving into the technical integration videos.

Discover new capabilities in the App Intents framework
ValueRepresentation, RelevantEntities, EntityCollection, SyncableEntity, richer parameter types and long-running intents. What’s new in the base framework.

Explore advanced App Intents features for Siri and Apple Intelligence
Advanced techniques so Siri can interact with the app naturally: content discovery, semantic indexing, structured search and connection with notifications and Now Playing.

Build intelligent Siri experiences with App Schemas
Adopt App Schemas so people can ask questions about app data and take actions through natural language. Practical example with calendar events and Spotlight.

Code-along: Make your app available to Siri
The code-along of everything above: integrating App Intents into a real calendar app, creating entities, triggering Siri actions and customizing response snippets.

Validate your App Intents adoption with AppIntentsTesting
AppIntentsTesting: validate intents with the same infrastructure used by Siri, Shortcuts and Spotlight. Execute intents, inspect results, test entities and queries without UI automation. The closing piece of the block — test what you’ve integrated.

Block 5 — Core AI and ML

For anyone who wants to go beyond high-level frameworks and step into the model layer.

Meet Core AI
The new framework for deploying AI models on device: a full ecosystem from Python for conversion and optimization to the Swift API for inference. Deep integration with Xcode and ahead-of-time compilation.

Integrate on-device AI models into your app using Core AI
A collection of open source models optimized for Apple silicon — Qwen, Mistral, SAM3 — and how to integrate them in a few lines of code. AOT compilation and on-device specialization.

Dive into Core AI model authoring and optimization
Authoring and optimizing models with the Python tools in Core AI. The deep layer for anyone who wants to control the full pipeline.

Optimize custom machine learning operations with Metal tensors
The Metal Tensor API and the MPP Tensor Ops library. Create portable operations that take advantage of the Neural Accelerators on M5 and A19, build custom kernels for Core AI apps and work with quantized formats. The low-level layer to push performance to the limit.

Explore numerical computing in Swift with MLX
MLX for numerical computing in Swift. The primitives everything else in ML builds on.

Explore distributed inference and training with MLX
Distributed inference and training with MLX. Scale to multiple Macs.

Run local agentic AI on the Mac using MLX
AI agents running locally with privacy, low latency and offline. OpenCode, integration with Xcode and techniques to scale across Macs.

Build with the new Apple Foundation Model on Private Cloud Compute
Using Apple’s new model on Private Cloud Compute. The end of the spectrum: when the device isn’t enough but privacy still comes first.

Block 6 — Networking, services and infrastructure

Three videos that cover the communication and runtime layer: from the client to the service, and the infrastructure that runs them.

Build real-time apps and services with gRPC and Swift
gRPC Swift for real-time experiences: the open source RPC framework with bidirectional streaming, built on Swift concurrency. From the service definition in Protobuf to production deployment. Protobuf messages are 50% smaller than JSON and the runtime is modern and safe.

Discover container machines
Container machines on Apple platforms. Infrastructure for development and deployment of Swift services.

Expand the capabilities of your Virtualization app
New capabilities in macOS 27 for Virtualization apps. Automating macOS guest setup at first boot, USB accessory passthrough, custom network topologies and port forwarding.

Block 7 — Design and accessibility

The layer you don’t see but that defines whether an app is good or not.

Principles of great design
The foundational principles of Apple app design. The conceptual frame before diving into concrete APIs.

Communicate your brand identity on iOS
Express brand identity on iOS with the new visual personalization tools.

Design intuitive search experiences
Designing searches that people understand and use. Patterns and antipatterns.

Craft clear names for features and labels in your app
Naming features and labels. One of those videos that seems minor and ends up being among the most practical.

Refine accessibility for custom controls
Accessibility on custom controls. How to make what you build work for everyone.

Modernize your AppKit app
Modernizing AppKit to current macOS conventions. Input with control events and gesture recognizers beyond tracking loops, keyboard navigation, state restoration, and new corner concentricity APIs to fit the macOS aesthetic.

Block 8 — System integration

The APIs that put my app inside the system: surfaces like Live Activities, widgets, Lock Screen or CarPlay; integration with native apps (Workouts), Bluetooth accessories, and shortcuts. If the app lives beyond its own window, this block is relevant.

Live Activities essentials
Fundamentals of Live Activities: where they show up, the new landscape Dynamic Island style, how to structure content and data, and how to trigger them in real time with ActivityKit and push notifications. The foundation if I’m going to use this API.

WidgetKit foundations
The widget types, what makes them memorable, and how to keep them up to date. Personalization via App Intents and dynamic styles. If the app needs to live outside its icon, start here.

Create live communication experiences
LiveCommunicationKit turns real-time communication apps into integrated experiences. Native conversation UI, full-screen presentation on Lock Screen, multitasking with Dynamic Island. Incoming, outgoing and group conversations.

Rev up your CarPlay app
New features for audio, navigation and voice-driven conversation apps on CarPlay. Video apps to play content in compatible vehicles when parked. Thumbnails, media info and voice controls.

Deliver workout insights with HealthKit workout zones
HealthKit with workout insights — heart-rate zones and cycling power zones. Built-in or custom zones, current zone and time in each zone to guide during and after training.

Find your accessory with Bluetooth Channel Sounding
Channel Sounding adds distance and direction to Bluetooth accessories. New Nearby Interaction and Core Bluetooth APIs and the required changes on the accessory. Optimized power consumption without losing responsiveness.

What’s new in Shortcuts
Building shortcuts with app content, new system automations, and the Use Model feature to refine how an App Entity is presented to LLMs. Shortcuts that store rich information synchronized across devices.

LLM search using Core Spotlight
Turning basic search into a RAG system with SpotlightSearchTool and LanguageModelSession. Integration with Core Spotlight, delegate-based hydration, PipelineStages for tasks like sentiment analysis. Real contextual search over the system index.

Block 9 — Security and administration

Five videos that matter more than ever this year. With all the added AI, assuming that app integrity, prompt injection or user manipulation aren’t your problem is a risk. And for apps living in managed environments — education, enterprise, fleet — the admin posture matters too.

Secure your app: mitigate risks to agentic features
Evaluating threats from indirect prompt injection: data exfiltration, unintended actions. System safeguards and best practices with App Intents and Foundation Models — user confirmations, safe prompt design, authentication. A must if I have agentic features.

Secure your apps with App Attest
App Attest against unauthorized modification and fraud. How attackers spoof data and skip checks, and how to defend. Generating and managing keys in the Secure Enclave, validating attestations and assertions, and using the fraud metric to detect abuse.

Meet Trust Insights
Trust Insights uses privacy-preserving ML to detect when someone might be being manipulated into risky actions. Integration, signal interpretation and designing interventions that protect while respecting privacy.

What’s new in managing Apple devices
Updates to declarative device management, Apple Business and Apple School Manager. Streamlining deployment, strengthening security and improving the managed fleet experience.

What’s new in assessment on macOS
Automatic Assessment Configuration on macOS for education apps. APIs to create secure, configurable exam environments that incorporate more system features. Automatic prechecks and accessibility controls for a reliable exam experience.

Block 10 — visionOS, RealityKit and spatial content

The largest block in the catalog. I only watch it if I’m working with Vision Pro or if I want to experiment with spatial scenes. If it’s not my area, I leave it for later.

Build next-generation experiences with visionOS 27
The visionOS 27 overview: the different paths to build experiences — native Apple tools, immersive streaming from Mac or PC, third-party engines, porting iOS apps. Advances in 3D content creation, immersive media and object tracking. The video to start the block with.

Explore advances in RealityKit
What’s new in RealityKit: interactive cloth simulations, NavMesh pathfinding, mixed reality lighting, customizable reverb meshes for spatial audio. Better shading, character rendering and support for Gaussian splatting.

Design immersive environments for visionOS apps and the spatial web
Creating photorealistic environments for visionOS apps, websites and SharePlay experiences. Design principles, reference capture, high-fidelity CG asset preparation and real-time effects like motion and lighting.

Iterate your spatial scenes faster with Reality Composer Pro 3
What’s new in Reality Composer Pro 3: content, VFX, lighting and interactivity without leaving the editor. AI-assisted features integrated into the flow. The tool you’ll live in if you build spatial content.

Extend Reality Composer Pro 3 functionality with Xcode
Project-specific plugins in Reality Composer Pro 3: custom components, custom systems, custom ScriptGraph nodes. Full control over the spatial authoring workflow.

Discover the Spatial Preview framework
The new Spatial Preview framework sends content from Mac directly to visionOS. Live-syncing and bidirectional editing across platforms. The SpatialPreview API, device discovery, 2D/3D integration and new Quick Look capabilities.

Explore enhancements to visionOS object tracking
Advances in object tracking and spatial accessories. Tracking moving and handheld objects, new supported classes of spatial accessories, and how to build custom accessories to unlock unique interaction models.

Collaborate on structured 3D models in visionOS
Structured 3D models in visionOS: USDZ preparation, manipulating entities within hierarchical assemblies, inspecting with a cross-section cut plane. Exploded-view animations for design and collaboration on Vision Pro.

Discover USDKit and what’s new in OpenUSD
USDKit in Swift, the new spatial preview API, enhanced spatial web. Updates to the OpenUSD standard: accessibility, Gaussian splats, compressed geometry. Expanded USD editing and rendering tools in Preview for Mac.

Use foveated streaming to bring immersive content to visionOS
Foveated streaming: scenes rendered remotely to Vision Pro in maximum fidelity. Combines native capabilities with third-party streaming wirelessly, demonstrated with an OpenXR scene and NVIDIA CloudXR. Dynamic foveated streaming without compromising privacy.

Explore immersive website environments in visionOS
The new Immersive API in JavaScript takes your website visitors into virtual environments on Vision Pro. Transitions from an inline model element, video docking, real-scale optimization. A few lines of code running on the web.

Supercharge your spatial workflows with Reality Composer Pro 3
Rich interactivity and full visual effects inside Reality Composer Pro: Shader Graph for materials, Animation Graph for blending skeletal animations, Compute Graph for particles. Script Graph for interactivity, Sequencer for events and Behavior Trees for NPCs.

Build live production tools for Apple Immersive Video
Live production of Apple Immersive Video. Packaging immersive video, spatial audio and scene metadata for IP transport with the SMPTE 2110 standard. Immersive Media Support, Video Toolbox and AVFoundation for real-time flows.

Block 11 — Games and Metal

If I work on a game, this block is a mandatory stop. If not, I watch it out of curiosity because there are performance pieces that also apply to non-game apps.

Bringing Cyberpunk 2077 to Mac
How CD PROJEKT RED brought Cyberpunk 2077 to Mac taking advantage of Apple hardware, software and tools. Techniques applicable to other games. The For this Mac preset that automatically optimizes settings to balance visual fidelity and framerate across the Mac lineup.

Speedrun your game port with agentic coding
The new agentic skills in Game Porting Toolkit 4 speed up porting. Adopting Metal 4, integrating MetalFX, tuning the game for Apple hardware. Agents that diagnose GPU rendering issues autonomously.

Make your game great with touch
Convincing touch controls for games. Insights from indie to AAA devs, best practices, and how to take advantage of the Touch Controller framework and Metal for optimal performance.

Design no-code games with Reality Composer Pro 3
ScriptGraph in Reality Composer Pro 3 for no-code 3D content. Visual nodes for animations, interactive moments, and integration with SwiftUI to add speech bubbles and UI to the experience.

Build real-time neural rendering pipelines with Metal
ML integrated into the rendering pipeline with Metal 4. MetalFX neural denoising with insights from Maxon Redshift Live. Training and deploying a neural tone mapper inline with the ML command encoder, and the new tensor API for small networks inside your shaders.

Find and fix performance issues in your Metal games
Hunting performance problems with Metal tools: Game Performance Overview in Instruments, background traces with metalperftrace and Control Center, and the new StateReporting API to correlate metrics with the game’s runtime state. Hours of telemetry turned into actionable insights.

Block 12 — Camera, photography and imaging

For apps with camera or image processing. Some videos are very specific (RAW, Center Stage), others apply even if I’m just displaying a preview.

What’s new in image understanding
Updated Vision framework and Foundation Models. The new tap-to-segment request to segment images, Vision on watchOS, and image support in the Apple Foundation Model combined with OCR, barcode scanning and custom tools.

Best practices for integrating visual intelligence in your app
How Visual Intelligence transforms content discovery. Defining entities, processing images, handling multiple result types. Optimizing speed and relevance, and intents for direct actions like opening or playing content with a tap.

Build a responsive camera app that launches quickly
Optimizing the full camera startup sequence — from launch to the first preview frame. New APIs for faster launches, smooth rendering and sustained performance. So people never miss the moment.

Implement high resolution photo capture
High-resolution photo capture with AVFoundation. The three options — RAW, exposure-bracketed, fully processed — and when to use each one. Configuring 24MP and 48MP capture on Main, Tele and Ultra Wide cameras. Deferred photo processing so the app stays responsive even with rapid bursts.

Enhance RAW image processing with Core Image
Version 9 of Core Image’s RAW APIs: sharper detail, more defined color, Apple Neural Engine for performance. CIRAWFilter to edit exposure, noise, sharpness and contrast. New CIImageProcessor APIs with fine control over tile sizing and buffers.

Support the Center Stage front camera in your iOS app
Center Stage with AVCapture APIs on the front camera of iPhone 17, 17 Pro and Air. Zoom and rotate, flexible framing for selfies and videos, everyone framed in group photos. Integration into video calls with auto-framing and real-time stabilization.

Create high quality images using Image Playground
Image generation with Image Playground. Generative model on Private Cloud Compute, images in almost any style including photorealistic, specific dimensions, and modification through natural language and touch.

Block 13 — Web and Safari

For web devs: what’s new in WebKit and the new pieces of CSS and HTML that Safari premieres this year.

What’s new in WebKit for Safari 27
The overview of WebKit and Safari 27: Grid Lanes, Customizable Select, HTML Model, Immersive Environments, the latest in Web Extensions. Over 1,000 engine improvements to make the web more reliable.

Get started with the HTML Model Element
The model element brings interactive 3D content to web pages on iOS, iPadOS, macOS and visionOS. Tools to create and optimize 3D assets, model element features, and where web standards in 3D are heading.

Create web extensions for Safari
Build and test Safari web extensions from scratch — without Xcode. Content blocking, page modification, native messaging and the permissions mode working together for a powerful, privacy-respecting experience.

Learn CSS Grid Lanes
Grid Lanes for adaptable web layouts with elements of varied shapes. Clean and flexible CSS, plus flow-tolerance to refine accessibility without losing malleability.

Rediscover the HTML select element
Full styling control over select menus on the web. New CSS appearance value and new pseudo-elements, rich content inside options with new HTML possibilities. Selects tailored to the design system without giving up accessibility or robustness.

Block 14 — StoreKit, App Store, subscriptions and Wallet

For everything that touches monetization and App Store Connect. If I sell anything in my app, this block matters.

What’s new in Apple In-App Purchase
The new monthly subscriptions with a 12-month commitment as a more affordable option. Configure and test with App Store Connect, StoreKit APIs and Xcode testing. Improvements to offer code redemption and to the App Review experience.

Enhance your presence on the App Store
Reimagining marketing on the App Store using images and videos in new places. New visual placements on the product page, search results and Apple Ads campaigns. The new Asset Library centralizes assets and a tool lets you preview the product page before publishing.

What’s new in Wallet
New pass styles for rich designs. New barcode formats and a flexible pass actions API. Pass Designer and Pass Builder simplify designing, personalizing and distributing passes at scale.

Explore Retention Messaging in App Store Connect
Retention Messaging to reach subscribers before they cancel. Configure it in App Store Connect, add subscription offers, and use the API for real-time messaging and alternatives that encourage them to stay.

Unlock in-game content with StoreKit and Background Assets
Native In-App Purchases in Unity with the new StoreKit plug-in. Smaller download sizes with the Background Assets plug-in delivering per-language packs. And a Steam Asset Converter to migrate existing builds.

Offer subscriptions to groups and organizations
Group Purchases: one subscriber buys multiple seats and invites others from the app. Volume Purchasing via Apple Business and Apple School Manager puts your subscriptions in front of enterprise and education buyers who already purchase apps at scale.

Block 15 — Music, audio and subtitles

For apps with multimedia content. There’s a new framework this year (Music Understanding) worth attention even if you don’t build music apps.

Meet the Music Understanding framework
The new Music Understanding framework that analyzes audio across six dimensions, on-device: key, rhythm, structure, pace, instrument activity and loudness. Plus a sample app, Music Understanding Lab, to visualize results.

Integrate MusicKit into your app
Apple Music inside your app with MusicKit. Authorization, subscription, music selection, playback control and sharing songs across storefronts. New Music Picker to browse the catalog and personal libraries. Differences between SystemMusicPlayer and ApplicationMusicPlayer.

Discover generated subtitles and subtitle styles
Generated subtitles on-device that transcribe or translate from another language. Caption style preview to customize and preview during playback. Implementation with AVKit, AVPlayerLayer and Media Accessibility.

Meet the Now Playing framework
The new Swift Now Playing framework connects your app’s playback with system surfaces: Lock Screen, Control Center, Dynamic Island, CarPlay. Publish state, respond to commands via an observable API, and remote playback sessions to render media on external devices.

Block 16 — Accessibility, reading and text

The text and reading layer. This isn’t just new APIs — it’s how the app fits with each person’s preferences.

Enhance the accessibility of your reading app
Robust reading experiences for VoiceOver and Speak Screen. Intuitive text selection, clear navigation between lines and paragraphs, and continuous reading across elements and pages.

Prepare your tvOS apps for Dynamic Type
Dynamic Type on tvOS: implementing font scaling, adapting layouts for large sizes, optimizing grids and media-focused carousels. So any text size remains comfortable.

Elevate your app’s text experience with TextKit
Combining the convenience of built-in text views with the control of TextKit. New APIs to extend UITextView and NSTextView with custom behaviors like line numbers or collapsible sections. TextKit architecture, caching and reuse policies for text attachments.

Unwrap PaperKit
Canvas-based applications with PaperKit. New data model APIs to access, create and modify markup elements. Custom controls, annotations, and best practices to integrate a full creative canvas.

Read between the strokes with PencilKit
Handwriting recognition with the same technology behind Freeform and Notes. Recognition across many alphabets and languages, and new capabilities to integrate PencilKit into more types of apps.

Block 17 — Group Labs

The Group Labs were live Q&A sessions with Apple engineers and designers during the event week. Apple keeps them in the catalog even though the interactive session is over, so they serve as a quick reference for whichever area I’m working on. The official descriptions are essentially the same boilerplate, so I group them by topic with a one-line context.

My Result 🎯

With this order I skip the catalog chaos and start seeing results from the first week.

My summarized sequence:

  • Block 0 — The presentations
  • Block 1 — Swift and tooling
  • Block 2 — SwiftUI and persistence
  • Block 3 — Apple Intelligence and Foundation Models
  • Block 4 — Siri and App Intents
  • Block 5 — Core AI and ML
  • Block 6 — Networking, services and infrastructure
  • Block 7 — Design and accessibility
  • Block 8 — System integration
  • Block 9 — Security and administration
  • Block 10 — visionOS, RealityKit and spatial content
  • Block 11 — Games and Metal
  • Block 12 — Camera, photography and imaging
  • Block 13 — Web and Safari
  • Block 14 — StoreKit, App Store, subscriptions and Wallet
  • Block 15 — Music, audio and subtitles
  • Block 16 — Accessibility, reading and text
  • Block 17 — Group Labs

If you’ve been watching WWDC for years you know the catalog never expires — the videos are available all year at developer.apple.com. June is for the new stuff, the rest of the year for going deep. As I covered in WWDC 26, the technical sessions are the main course — and now I already have my own checklist to tick off as I go.

Keep coding, keep running 🏃‍♂️