WWDC26 Special: Fewer Fireworks, Better Plumbing

There are two kinds of WWDC. There's the fireworks year, the one that fills headlines for six months with a shiny new product that four people end up actually using. And then there's the other one: the year Apple rolls up its sleeves, pops the hood, cleans up what was dirty, fixes what had been broken for ages, and properly seats the pieces it had rushed into place. WWDC26, held June 8-12, was very clearly the second kind. And those are almost always the ones you end up thankful for a year later.

Apple did two things at once this year. On one hand, it cleaned house: Liquid Glass refined after a year of real-world use and legitimate complaints, SwiftUI with performance fixes we'd been asking for since forever, Xcode 27 lighter, faster and finally rid of the quirks it had been dragging around for a decade, macOS 27 Golden Gate closing out the Apple Silicon transition for good. On the other hand, it caught up on AI, which was frankly overdue: Foundation Models turned into an actual platform — open source, multimodal, third-party models, free tier — Core AI as the new on-device inference framework, an Evaluations framework to measure what we'd all been eyeballing until now, and coding agents living inside the editor.

None of this makes the evening news. All of this is exactly what will change your day-to-day over the next twelve months.

That's 100+ sessions and none of us has time to watch them all. So here's the thing we like doing: we watched them, cross-referenced our take with what the community recommended — Kodeco, Use Your Loaf's viewing guide and a handful of other roundups — and put together a list in three tiers: general interest, for people just starting out, and for AI enthusiasts. If a video is essential it gets the full write-up in the tier where it belongs and just a name-drop in the others. Let's go.

Tier 1: General interest — watch these, no excuses

Doesn't matter what corner of the ecosystem you work in. These are the videos that map out your year.

Platforms State of the Union · 61 minutes

If you only watch one video from all of WWDC26, make it this one. It's the complete map of the year told for developers, without the keynote's marketing wrapper. Everything's here: Liquid Glass refined with better diffusion, darkened edges, brighter specular highlights and — this one matters — a personalization slider so users decide how much transparency they want, plus seamless adaptation to accessibility settings. Here's the announcement that iOS apps become resizable on iPad and in iPhone Mirroring the moment you rebuild against the new SDK. Here's Core AI. Here's the Private Cloud Compute free tier. And here's the new era of Xcode with agents.

The whole session hangs off a sample app called Origami that they build in front of you while walking through each announcement. It's an old storytelling trick and it still works: you see what each thing is for, in context, instead of swallowing a feature list. If you're short on time there's an official 4-minute recap that works as an appetizer, but it's no substitute for the main course.

Keynote · 76 minutes

This year's keynote carries emotional weight it usually doesn't: Tim Cook took the stage for the last time as CEO. And Apple picked that moment to finally deliver on the promise it had been sitting on for two years: a completely rebuilt Siri, with its own app for revisiting conversations, running across iOS 27, iPadOS 27, macOS 27 Golden Gate, watchOS 27, tvOS 27 and visionOS 27. If you want the concentrated version of the Siri pivot without sitting through the whole keynote, Announcing Apple's next big step for Siri and iPhone runs a minute and a half and gets straight to it.

What's new in Xcode 27 · 28 minutes

Get ready to grin a lot. Xcode 27 is 30% smaller to download, Apple Silicon only, with settings synced across your Macs via iCloud, with actual themes — Emerald, Neon Noir, Coral Reef, with sliders for text and background intensity, plus per-project themes so you stop mixing up windows — a customizable toolbar, and untitled projects you can spin up instantly and save or throw away later. You can also open a loose Swift file and get playground results and UI previews in the canvas without setting up a whole project.

But the real meat is in Organizer and Instruments. Organizer got redesigned to surface high-impact issues first and adds two new metrics: Storage — your app size, documents, data and binary, which directly hits cellular downloads and launch time — and Animation Hitches, expanded beyond scrolling to cover Liquid Glass and SwiftUI views. It also now sets realistic metric goals computed from similar apps and your own historical baselines. And Instruments gets Top Functions, a view that points you at the most expensive code paths in seconds. In the demo they catch a paperPhysics function over-iterating inside the animation pipeline. That used to be two afternoons of grinding. Now it's two minutes.

Xcode, agents, and you · 24 minutes

This is the session that best explains the actual shift in philosophy. Xcode 27 puts coding agents inside the editor — with panes, tabs and splits, not some toy sidebar — and the session organizes them into four phases: explore (the agent maps a codebase you don't know and generates flow diagrams with references back to source), build (with /plan to design before you type and sub-agents running in parallel), refine (attach sketches or screenshots to communicate design intent, with inline annotations right on the code), and orchestrate (you say "localize this to Filipino and improve accessibility" and it deploys whatever tools it needs).

Underneath there's MCP integration, built-in agents from Anthropic, OpenAI and Google, Agent Client Protocol support so you can plug in any compatible agent, and a plugin system with markdown skills, MCP tools and custom agents, plus one-click setup for partners like Figma and GitHub. There are also built-in Xcode specialists: SwiftUI, accessibility, universal sizing, testing and performance. The line that sums up the session is theirs: you drive the vision, Xcode helps you get there faster. Which is exactly the right framing.

What's new in Swift · 32 minutes

Swift 6.3 and 6.4, and this time the session has real substance. On the everyday side: weak let for immutable weak properties, ~Sendable syntax to mark types as non-Sendable without blocking subclasses, additional public memberwise initializers for structs with mixed-access properties, and the death of that silly parenthesis restriction on optionals. On availability, anyAppleOS collapses your multi-platform @available block into one line. @diagnose gives you fine-grained warning control inside a specific declaration. And module selectors with :: resolve cross-module name conflicts: Rocket::SaturnV().

On concurrency: await inside defer blocks — that historical restriction is finally gone — warnings when you silently swallow errors thrown from tasks, and withTaskCancellationShield to protect critical work that can't be left half-done. On performance, the juiciest part: @inline(always), @specialized, borrow and mutate accessors for reading or modifying without copying, plus new types like UniqueBox, UniqueArray, Ref and MutableRef. Equatable, Comparable and Hashable now work with ~Copyable types.

And the headline almost nobody covered: the OS kernel is now partially written in Swift. Alongside the TrueType font rendering engine rewritten in Swift, the QUIC transport layer rewritten in Swift, and hundreds of thousands of lines across bare metal firmware and drivers. Add the official Swift SDK for Android, WebAssembly compilation with safe bridging 35-40x faster than dynamic bridging, and Swift Build as SwiftPM's default backend. Swift stopped being "the language for making apps" a long time ago.

What's new in SwiftUI · 28 minutes

This is where the house-cleaning shows most. There are new features — reorderable() for drag-to-reorder in any container, not just List, swipe actions outside List, visibilityPriority and an overflow menu for toolbars, Tab(role: .prominent), full-fidelity text selection on iOS, document infrastructure with WritableDocument and ReadableDocument — but the important stuff is the other stuff.

The other stuff is @State becoming a macro and classes initializing lazily, once per view lifetime, instead of being spun up and thrown away every time the parent updates. It's backported to iOS 17 and macOS 14. Heads up though, this is a breaking change: if you were assigning a default value and assigning in init, you need to drop one of them. That's what TN3211 is for. The other stuff is also ContentBuilder, a unified builder that replaces the tangle of builder variants and single-handedly kills those "unable to type-check this expression in reasonable time" errors on deeply nested views. The other stuff is AsyncImage doing HTTP caching by default, nested stack layouts measuring children twice as fast, and menu pickers on macOS swallowing long lists without choking.

None of this shows up in a promo video. All of it makes your life better tomorrow.

Principles of great design · 17 minutes

Linda and Doug, two design evangelists, walk through eight principles: purpose, agency, responsibility, familiarity, flexibility, simplicity, craft and delight. Sounds like a textbook talk and it isn't, for two reasons. First, they insist the principles conflict with each other and that there's no formula — there's judgment. Second, the responsibility section explicitly covers anticipating harm in AI features. In a WWDC where everyone's about to be asked to stuff an LLM into their app, that's seventeen very well-spent minutes.

Profile, fix, and verify: Improve app responsiveness with Instruments · 26 minutes and Get the most out of Device Hub · 17 minutes

Two you'll skip and shouldn't. The first is the full profiling loop: measure, fix, verify. The second covers Device Hub, which replaces the old Simulator with a unified interface where you drive simulators and physical devices from the same window, tweak properties — dark mode, font size, contrast — take screenshots, dynamically resize iOS apps, and manage files and data containers. Goodbye to having five windows open.

Inside Apple Intelligence and Xcode: Special Presentation · 88 minutes

Shot in the Steve Jobs Theater, it's the longest session of the year and works as an index for everything else: Xcode 27 (19 min), App Intents (17 min), Foundation Models (18 min), Core AI (12 min) and MLX (13 min). If AI is your thing, start here and then drill down with the specific sessions. We mention it again in tier 3.

Tier 2: For people just starting out — the road with no shortcuts

If you're new to this, WWDC can be overwhelming. Here's an ordered path that won't burn you out. And one piece of advice Dave Verwer gets exactly right in his guide: you don't have to learn everything today.

Start with Principles of great design, covered above. Before you write code it helps to understand who you're writing it for. Then chain it with Craft clear names for features and labels in your app (15 min), one of those sessions that looks minor and then permanently changes your judgment. Naming things well is half the job.

SwiftUI for Beginners Group Lab · 61 minutes

Group Labs are the best thing that's happened to online WWDC: an hour of live Q&A with the Apple engineers and designers who actually build the technology. This one is explicitly aimed at SwiftUI newcomers. Real questions from real people, not the ones Apple decided you were going to have. If you're a beginner there are two more worth your time: the Coding Intelligence for Beginners Group Lab (62 min) to get comfortable working with agents without the vertigo. And the Icon Composer for Beginners Group Lab (62 min) to make decent icons without being a designer.

Code-along: Add persistence with SwiftData · 23 minutes

Code-alongs are gold for learning: you download the sample project and type along with them. This one starts from a SwiftUI app called Wishlist that loses its data on relaunch and walks you through identifying which state needs persisting, defining schemas with @Model, setting up to-many relationships, and swapping in-memory data sources for @Query. Honest warning: this is not ground zero. It assumes you're comfortable with SwiftUI, environments and observable patterns. If that's where you're at, it's the best entry point into SwiftData Apple has published. Follow it with What's new in SwiftData (13 min), which is short and sweet.

Migrate to Swift Testing · 21 minutes

If you're starting now, start directly on Swift Testing and save yourself a future migration. The session covers @Test, #expect, parameterized tests and exit tests, but the interesting part is the strategy: you don't need to migrate anything all at once. Leave your XCTests where they are, write new ones in Swift Testing, and let them coexist in the same project through four interoperability modes (Limited, Complete, Strict, None). Swift Testing 6.4 also adds issue severity levels, Test.cancel() for dynamically skipping cases, and --repeat-until-failure for hunting flaky tests.

One thing though: a test that doesn't exercise observable behavior isn't a test, it's decoration. Start right from day one.

Code-along: Build powerful drag and drop in SwiftUI · 15 minutes

You build Solitaire. An actual card game, with piles, rules and multi-card drags. Along the way you learn reorderable(), reorderContainer(), dragContainer(), dragPreviewsFormation() with .stack, .pile and .list formations, and business-rule validation in dropConfiguration(). It's intermediate level and you'll want to have watched Meet Transferable from WWDC22 first, but it's a blast and the result is something you can show people.

To round out the basic toolkit for a modern app: WidgetKit foundations (20 min) and Live Activities essentials (15 min) cover widgets and live activities from scratch. Design intuitive search experiences (16 min) is a masterclass on a pattern you'll implement a thousand times over your career. And Dive into lazy stacks and scrolling with SwiftUI (21 min) explains why your list stutters, which has been the number one forum question since 2019.

If you're coming from UIKit or AppKit — or you inherited a project that did — Use SwiftUI with AppKit and UIKit (14 min) and Modernize your UIKit app (16 min) are the bridge. You don't have to rewrite everything. You never have to rewrite everything.

And when you want to understand what all the noise this year is about without going deep, there's the Platforms State of the Union and Xcode, agents, and you, both covered in tier 1.

Tier 3: For AI enthusiasts — the year Apple got serious

Here's the main course. This is the block where WWDC26 stops being a maintenance release. If applied AI is your thing, there's more useful material here than in the previous three editions combined.

What's new in the Foundation Models framework · 21 minutes

If you only watch one AI video, this one. The framework became a full platform and it did so on six fronts at once:

Rebuilt on-device model · better reasoning and tool calling · APIs to inspect contextSize and count tokens · refined guardrails with fewer false positives · vision support via image attachments in the prompt

Private Cloud Compute · server model with a 32,000-token window · .light and .deep reasoning levels · no API keys, no auth, no accounts · no prompt storage, verifiable by independent researchers · now on watchOS 27 too

Model abstraction layer · new LanguageModel protocol · official Swift packages from Anthropic and Google · open-source CoreAILanguageModel and MLXLanguageModel implementations · swap models via SwiftPM without touching downstream code

System tools · BarcodeReaderTool · OCRTool · a Spotlight search tool for local RAG over the Core Spotlight index

Dynamic Profiles · declarative API to swap models, instructions and tools on the fly while keeping the transcript

Tooling · the Evaluations framework · a Foundation Models instrument in Xcode · the fm CLI on macOS 27 · a Python SDK

And two things that deserve their own paragraph. First: the framework goes open source, which means you can use it on any Swift platform, Linux servers included. Second, and this one is huge for indie developers: a free Private Cloud Compute tier for apps under 2 million first-time downloads. Zero cloud cost. iCloud+ subscribers get higher limits. Apple just removed the financial barrier to entry for generative AI across basically the entire indie ecosystem.

Meet Core AI · 21 minutes

The new framework of the year. Core AI is the inference engine that drives Apple Intelligence under the hood, and Apple is now opening it to developers. It covers the full model deployment lifecycle: conversion from PyTorch via coreai-torch, optimization, ahead-of-time compilation in Xcode, visual debugging and profiling with dedicated instruments. The Swift API is modern and memory-safe, with progressive disclosure:

let model = try await AIModel(contentsOf: modelURL)
let function = try model.loadFunction(named: "main")!
var inputs = NDArray(shape: [...], scalarType: .float32)
var outputs = try await function.run(inputs: ["input": inputs])

It scales from compact vision models on an iPhone to 70-billion-parameter LLMs on a Mac. No server. No token cost. Follow up with Integrate on-device AI models into your app using Core AI (24 min) for the practical implementation, and Dive into Core AI model authoring and optimization (29 min) if you're converting your own models.

Build agentic app experiences with the Foundation Models framework · 22 minutes

The densest session in the block and probably the most important. It explains Dynamic Profiles properly: a profile is an agent with its own goal, capabilities and configuration, and you can switch between them inside the same LanguageModelSession while keeping the transcript. DynamicInstructions lets you compose instructions and tools into reusable pieces. historyTransform trims context without mutating the session. @SessionProperty shares state across profiles.

Then come the orchestration patterns, which is where you can tell Apple did its homework: baton-pass (multiple profiles share the full transcript and a tool flips the active profile), phone-a-friend (a tool spawns a short-lived child session with an isolated transcript), and the skills pattern for procedural context loading. Plus toolCallingMode control with .allowed, .disallowed and .required, and transcript error policy with .preserveTranscript or .revertTranscript.

The technical warning that'll save you the most pain: rewriting the transcript invalidates KV caches and blows up your latency. Appending preserves them. Use the Foundation Models instrument in Xcode to catch invalidations. This is the kind of detail that separates an AI feature that works from one that crawls.

Meet the Evaluations framework · 26 minutes

This might be, long term, the most important announcement of WWDC26. Generative AI breaks the "same input, same output" contract that traditional unit tests are built on. Evaluations is Apple's answer: a Swift framework for quantitatively measuring the quality of generative features.

You define an Evaluation in five steps — subject, dataset, metrics, evaluators and aggregation — build rule-based evaluators for anything you can measure in code, and ModelJudgeEvaluator for the subjective stuff, using a capable model (Private Cloud Compute) to judge a smaller one, with explicit score dimensions and scales. It integrates with Swift Testing through the .evaluates(...) trait, generates a visual per-sample report, and ships SampleGenerator to synthetically expand datasets from seeds.

The methodology they propose — start with 20-30 samples, define expectations, quantitative metrics first, measure, read the rationales behind failures, refine instructions, measure again — has its own session: Improve your prompts by hill-climbing with Evaluations (27 min). And for the agentic case, Create robust evaluations for agentic apps (21 min).

Secure your app: mitigate risks to agentic features · 25 minutes

Don't skip this one. If you're putting an agent in your app, this is how you avoid embarrassing yourself. It covers four vectors: indirect prompt injection (instructions hidden in a calendar event, a feed or a tool result), data poisoning (the attacker manipulates the action's parameters — say, a message recipient), action poisoning (the attacker influences which action runs), and unintended side effects — financial risk, data exfiltration, data loss, and lock-screen attacks via Siri.

Then the mitigations, prioritized with very good judgment: deterministic ones first — user confirmation via onToolCall, device authentication with authenticationPolicy = .requiresAuthentication on destructive intents, risk-based confirmations inherited from intent schemas — and probabilistic ones second — PII redaction before anything reaches the model, and spotlighting, which wraps untrusted content in <<UNTRUSTED>> delimiters so the model treats it with suspicion. It's defense in depth, well explained, threat modeling included. Twenty-five minutes that could save you a very ugly headline.

Bring an LLM provider to the Foundation Models framework · 21 minutes and Build AI-powered scripts with the fm CLI and Python SDK · 17 minutes

The first covers implementing the LanguageModel protocol to bring your own provider. The second opens a door we weren't expecting: the on-device model reachable from the terminal and from Python. Things like fm chat "what's a valley fold in origami?" or fm image-analyze IMG_1234.jpg to generate descriptive filenames. Local automation, free, private, without leaving the Mac.

MLX: Run local agentic AI on the Mac · 14 minutes · Explore distributed inference and training · 22 minutes · Explore numerical computing in Swift with MLX · 15 minutes

The MLX block is pure candy. The first stands up a complete local agentic stack in three commands: install mlx-lm, launch mlx_lm.server with a HuggingFace model, and connect any agent that speaks OpenAI's chat completions protocol — Xcode included, plus OpenCode and Pi. The performance numbers are what matter: the M5's Neural Accelerators process prompts roughly 4x faster than the M4, there's continuous batching for concurrent agents, and distributed inference across multiple Macs over Thunderbolt with RDMA, hitting up to 3x speedup with 4 nodes. Four Mac minis as your home inference cluster. In the demos they generate a SwiftUI drawing app from scratch and fix bugs in Xcode, all with the model running locally.

Siri and App Intents: Build intelligent Siri experiences with App Schemas · 27 minutes and Discover new capabilities in the App Intents framework · 18 minutes

If you want the new Siri to be able to do things with your app, this is the path. Entity schemas to describe your content, intent schemas to describe your actions, the Spotlight semantic index for personal context, and View Annotations so users can refer in natural language to whatever's on screen. The App Intents session adds very practical pieces: EntityCollection — which passes only identifiers to perform() instead of resolving full entities, making "tag 1,000 photos" instant in the demo — SyncableEntity so a Siri conversation continues across devices, RelevantEntities so the system surfaces your content at the right moment, @UnionValue for parameters accepting multiple types, and LongRunningIntent + CancellableIntent to blow past the 30-second limit with progress reporting and graceful cancellation.

To close out the block: LLM search using Core Spotlight (16 min) for local RAG over the system index, Debug and profile agentic app experiences with Instruments (14 min) for when things get slow and you don't know why. And Inside Apple Intelligence and Xcode — the 88-minute special from tier 1 — as the big picture. If you prefer Q&A format, the Machine Learning & AI Group Lab (63 min) is an hour of engineers answering real questions.

The ones that don't fit any tier but we loved anyway

Because WWDC has its wonderful oddities too. Bringing Cyberpunk 2077 to Mac (28 min) is a masterclass in real AAA game porting. Meet the Music Understanding framework (17 min) opens up a brand new music analysis framework with enormous creative potential. Discover container machines (11 min) is for anyone doing backend work. Build real-time apps and services with gRPC and Swift (24 min) confirms server-side Swift is very much for real. And Speedrun your game port with agentic coding (28 min) shows off the Game Porting Toolkit with agent skills, which slashes porting times dramatically.

On accessibility, Refine accessibility for custom controls (16 min) and Enhance the accessibility of your reading app (20 min). And on the business side, Enhance your presence on the App Store (8 min) is short and pays for itself.

And that's about it

This was a good WWDC. One of the quiet ones. The kind that fixes @State so it stops instantiating objects nobody used, that rewrites SwiftUI's builder so the compiler stops giving up on a nested view, that adds a storage metric to Organizer because it turns out your app's size affects downloads, that admits generative AI can't be tested with XCTAssertEqual and ships an entire framework to measure it. And yes, also the kind that throws the on-device AI door wide open with Core AI, makes Private Cloud Compute free for most of the indie ecosystem, and open-sources Foundation Models.

Apple cleaned house on one side and caught up on the other. It was overdue. Now it's our turn: there are 100+ sessions waiting and summer is long. Our practical recommendation, if you don't know where to start: State of the Union, Xcode 27, What's new in Swift, What's new in SwiftUI, and What's new in the Foundation Models framework. Five videos, two and a half hours, and your whole year is mapped. The rest depends on what you're building.

If you want to leave us a comment or tell us anything, you know where to find us.

See you soon, and until then: take care and write good native code.

Thanks for reading our Newsletter! See you at Be Native and Good Apple Coding.