Now that I've done all the video watching, my next plan on deck is to get my WWDC session progress app into a state I'm happy with and can use so that it's ready to got for next year.

Bring your machine learning and AI models to Apple silicon

This session is entirely focused on bringing existing ML models to Apple Silicon, and covers the new features for quantizing models, as well as support for stateful models, and multifunction models.

Optimize for the spatial web

This session covers how web technologies can be used on visionOS. In particular is talks about how to use content ships to highlight interactive elements cleanly when the user looks at them, how to display spatial photos, and how to use WebSpeech, WebAudio and WebXR.

What’s new in Quick Look for visionOS

Quick Look in visionOS is interestingly different from other platforms as it’s tied into other applications and lets applications present content with it. This year is adds the ability to display a collection of objects, supports enough data that an application can keep track of if the preview for an item has been closed, and Quick Look supports configurations within a file on all platforms now, so that one asset can represent multiple colors or other configurations of a model.

Deploy machine learning and AI models on-device with Core ML

This session follows on from the technologies discussed in “Bring your machine learning and AI models to Apple silicon”, and shows how to deploy models with these features using CoreM, and how to measure performance.

Build a spatial drawing app with RealityKit

This session walks through a lot of the features for implementing a 3D drawing app, and covers a lot of useful low level details for working in RealityKit. In particular this covers how to work with different vertex buffer formats, low level mesh formats, and how to create a low level texture driven by a Metal shader.

Support real-time ML inference on the CPU

This is an in-depth dive into using BNNS Graph to execute ML model in a real time context, such as processing audio, and walks through importing the model, setting up the project, and implementing the BNNS graph from the audio.

Render Metal with passthrough in visionOS

This I a detailed talk about that it takes to create a renderer that reads the transforms for the user’s viewpoint and other trackable anchors, and then renders the scene correctly for the user. It also explains the different requirements in the passthrough mode compared to full immersion.

Build a great Lock Screen camera capture experience

Locked camera capture allows 3rd party cameras to be used while the device is locked, and this session explains how to build an extension to do this, what the limitations are when running in that extension, and how data can be sent from your extension to the photo library or your application.

Optimize your 3D assets for spatial computing

This session walks through the practical concerns for how to optimize a scene for rendering on visionOS. This includes texture optimizations, baking lighting, when to use different texture types, and splitting up geometry so that objects not in view can be culled.

Break into the RealityKit debugger

This session walks through using the RealityKit debugger to spot some common issues, and talks through what could have caused each issue, and how to address it.

Explore App Store server APIs for In-App Purchase

This session covers enhancements to the App Store server APIs, including the ability to receive notifications for all purchases, as well as fetching the full transaction history for a user. It also covers how to create various types of offers such as win back offers.

Build immersive web experiences with WebXR

This session covers the practical concerns for setting up a WebXR experience, talks about some available frameworks to make it easier to work with, and then goes into detail about how the different input types work.

Discover area mode for Object Capture

Area mode allows you to capture objects in contexts where the object can’t be easily isolated. Object capture also added the ability to export quad meshes with square polygons to make them easier to work with for 3d artists, higher quality export options, and easier ways to add extra data to object capture samples.

Design interactive experiences for visionOS

This session walks through some of the design choices from the Encounter Dinosaurs app, and primarily focuses on how to design interactions to help guide a user in immersive experiences.

Train your machine learning and AI models on Apple GPUs

This session is aimed at developers who are used to using python to train ML models, and want to take advantage of hardware acceleration on Apple Silicon. It covers the frameworks that have Apple Silicon support, and how to enable support for both model training and model export.

Bring your iOS or iPadOS game to visionOS

This session focuses on how to add visionOS specific features to an existing game, such as dynamic backgrounds, supporting parallax rendering, and head tracking.

What’s new in device management

Device management is now supported on visionOS, and there is a long list of new convenience features. The most important one is likely that managed devices can now have activation lock disabled by the MDM software.

Discover Swift enhancements in the Vision framework

The Vision framework now supports asynchronous/await, which will make integrating with Vision much cleaner than it was with the old completion handler based API. There are also some new types of requests, the most interesting one to me is assessing image aesthetics.

Implement App Store Offers

This session covers how to implement win back offers for subscriptions in detail, including configuring eligibility conditions, how to choose the best offer for a customer in app, handing off purchases of these offers from the App Store, and how to test them in Xcode.

Accelerate machine learning with Metal

This walks through some of the new optimizations available in Metal Performance Shaders, and the debugging tools. If I hadn’t spent a while doing ML work this year, I don’t think any of this would have made any sense to me.

Customize spatial Persona templates in SharePlay

This session walks through the things to consider when working with a spatial Persona template. It covers how to set up seating, how to reserve seats for particular roles, considerations for transitions, and affordances to be made for users on other platforms or who aren’t using Spatial Personas.

Modeling Progress

I primed, painted, and weathered the first few sprues in the kit, and did some experimenting to get a glow effect on the eyes rather than using the clear plastic part as-is and I think it looks good when viewing it from a distance.

I then got a second set of sprues primed and have the base coat in place on those, so I just have weathering left there.

Enhance ad experiences with HLS interstitials

Interstitials now support more integration into the primary timeline, and can be shared across a SharePlay session, so that things like recaps, previews, and other ad content can cleanly be used in interstitials on a stream.

Meet the next generation of CarPlay architecture

The new CarPlay system will include the ability for phone rendered elements, on car rendered elements, and passthrough elements like video feeds from the car to all co-exist and be combined by a compositor that keeps animations and such in sync. It looks interesting, and it will be very interesting to see what happens when cars with this tech ship.

Use HDR for dynamic image experiences in your app

This session goes into detail on how HDR images are structured, and the implications for those formats when working with the files in an image editor. HDR content is often saved as a SDR image plus extra data that describes the brightness of pixels outside of the standard SDR range.

Enhance the immersion of media viewing in custom environments

This session covers how to set up mounting points in a custom environment, and how to set up reflections, environment probes, and tints on the passthrough video for a custom environment.

Explore game input in visionOS

This session covers both gesture based and controller based game input on visionOS. Controller support is exactly the same as on the other operating systems, and the gesture support section covered both how to use system gestures, and work with hand tracking.

What’s new in privacy

This session is a high level overview of the changes in privacy, most of the content in it has dedicated sessions explaining the details of how to work with those changes. Getting an overview of the direction behind all of the privacy sessions was particularly informative, and it’s nice seeing that the focus is on both privacy and user friendliness.

What’s new in DockKit

DockKit adds improved tracking, support for buttons on devices, battery information, and the ability for an app to interact with the stream of focus interest data from the device. Most of this was done to add support for gimbal mounds, and to allow DockKit to be used for photography and panorama.

Keep colors consistent across captures

Having spent time doing product photography and attempting to get the color grading correct from capture to display, it’s absolutely fascinating hearing about how this was implemented. The system captures an image with and without flash, and uses how the known light source from the flash changes the brightness of pixels to correct the color on images.

What’s new in USD and MaterialX

This is a session on new features in the content creation ecosystem that can be used across Apple platforms. Of particular interest is some of the new tools being added for things like reducing the file size of USDZ files, better quicklook support, and some Apple shaders that can be used in MaterialX workflows.

Port advanced games to Apple platforms

This is an overview of all of the tools that Apple has made available for porting games to Apple platforms. Given that Apple was ambivalent at best about gaming for a long time, it’s nice to see they’ve both built up a toolchain for porting games to their platforms, and that they continue to add features showing the project is important.

Build compelling spatial photo and video experiences

This session walks through how to work with both the display and capture of spatial video and photos. It covers a range from simple things like how to display spatial video in a video player, to the math involved in using a dual camera setup for spatial video capture and how to make sure the image planes are properly aligned for a good 3d viewing experience.

Discover RealityKit APIs for iOS, macOS, and visionOS

This session walks through building a simple game, and handling things like physics, portals, and controls in a visionOS project, and then walks through how those features can all be enabled on other platforms.

What’s new in App Store Connect

The biggest change here is the ability to send notes on future feature releases to App Store editorial and they can then collaborate with you to feature them on launch. There’s also the ability to deep link into an app after the install via a custom project page, improvements to tester onboarding in TestFlight, and the ability to create marketing images.

Create enhanced spatial computing experiences with ARKit

This session covers some of the new features coming to ARKIit, the headline items are the ability to track a room, tracking angled planes, and improved hand tracking options.

Explore object tracking for visionOS`

This session walks through the process of setting up object tracking in visionOS, which starts with training a ML model to recognize a known object from a reference model, and then you can use that to find the object and track it. The reference model created for training also is useful to create an occlusion object so that content rendered by the OS can be blocked by the tracked object.

Explore machine learning on Apple platforms

This is a high level overview of all of the new machine learning features that came out this year. IT was interesting to see the focus on research and open source contributions alongside the regular SDK work.

Meet TabletopKit for visionOS

TabletopKit is a new API for creating either single player or multiplayer board gaming experiences on vsionOS. IT allows you to create a table, game objects and a game board,, and easily set up multiplayer games using SharePlay. It will be really interesting to see what developers do with it.

What’s new in Create ML

This session is an overview of new features in Create ML this year.The headline feature is object tracking, but there are also some nice improvements to the tools for visualizing your data sets to be able to make sure the data is good before using it to train a ML model.

Compose interactive 3D content in Reality Composer Pro

Reality Composer Pro keeps adding new features, this session covers how to work with animations, inverse kinematics, skeletal poses, and blend shapes. With these updates, it looks like the built in tooling for the system supports a lot of what used to be in highly specialized tools.

Enhance your spatial computing app with RealityKit audio

This session covers how to work with audio in RealityKit. It walks through adding sound effects to an object and controlling directionality and volume on those, how to set up sounds for collisions both in an environment, and with real world objects, and how to add music and ambient sounds to an environment.

Get started with HealthKit in visionOS

This session covers how to work with HealthKit in visionOS. The current APIs are available with feature parity to other platforms, so the only change is it has special handling for guest mode, and will not allow data to be saved or permissions to be changed when a guest is using the device.

Modeling Progress

At the end of fall last year, I had to stop work on a kit that was about 75% done because it got too cold to open the window to vent outside while painting with lacquers. So I dug that out and finished the paint work and did a quick pass of panel liners on it. I really can't say enough good things about the lacquers in terms of how thin they go on, and how durable they are. The shine on the high gloss finish is just great in person. At some point in the near future, I'll probably put together some sort of simple base for it to be able to pose it more dynamically.

After that I started in on one of the kits I picked up in Japan. I managed to finish cutting out and sanding all of the parts from the first few sprues, and will be priming those next week.

Meet FinanceKit

This is a new framework that gives access to a user’s Apple Card, and Apple Pay Cash balances. It will be interesting to see if Apple eventually extends it so that other cards in Apple Pay can also be exposed to this API.

Meet AdAttributionKit

This session explains how AdAttributionKit works, and how it allows tracking of impressions, but with a focus on user privacy. That means that data is delivery with some randomization to time values, and also the granularity of data is affected by the size of the data set.

Bring your Live Activity to Apple Watch

This session covers code changes to be made to make a live activity work well for the watch, and also covers some of the new behaviors, especially how live activities are budgeted on the watch, and how to support the always on watch modes.

Customize feature discovery with TipKit

This session covers how to make more efficient use of TipKit by creating custom tip identifiers, creating tip groups, and syncing the tip state between devices so users only see the tip once.

What’s new in Wallet and Apple Pay

This session is a return to the WWDC of old where there’s a grab bag of sort of related content. It covers how to support 3rd party browsers with Apple Pay on the web, as well as updates to how passes are handled in wallet.

Build custom swimming workouts with WorkoutKit

This session covers updates to custom workouts, including both the ability to name workout phases, allow the user to select indoors or outdoors for a given workout, and build time / distance workouts.

Explore wellbeing APIs in HealthKit

This session explains the science between the wellbeing APIs in HealthKit, as well as how to long data that API, and how to interpret the data you read from the API.

Enhanced suggestions for your journaling app

This session covers visual update to the journaling suggestions, new data that will be available, how this data relates to the wellbeing APIs, and how to update an existing app to take advantage of these new features.

Meet the Translation API

This session explains how to the use translation API in many different circumstances. At a high level you can either have a popover view that translates the text, or you can have a translation session that will translate strings that you pass into it. It also covers how to configure the language settings if you want to manually specify languages to translate.

Introducing enterprise APIs for visionOS

This session covers the new enterprise only APIs available for visionOS. These include being able to capture the pass through environment in screen sharing, recognize bar codes from the camera feed, access the neural engine for running ML models, and run the device at higher speeds at the cost of battery life and having the fan run faster. The first two are privacy implications, but the second two are just changing device settings to shift trade-offs from what Apple has defined as “best”.

What’s new in App Intents

This session covers some of the new functionality in App intents, and how to tie into those features in the system. In particular it covers a lot of details on how the Transferable API can be used to pass data both from spotlight to your app, and also from your app into other apps.

Broadcast updates to your Live Activities

This session cover how to use channels to be able to send a push notification to all interested users at once via APNS instead of needing to schedule a push notification for every interested user.

Bring your app to Siri

This session explains the data schemas required to expose intents to Siri, and how your app data can be shared with Siri both in search and in executing intents.

Bring your app’s core features to users with App Intents

Keeping on the intents theme, this session shows how to expose app functionality as an Intent, including both creating controls, and app shortcuts that can be involved via Siri and render the UI in a modal view instead of needing to launch your app, or even answering in audio if the user is asking a device that doesn’t have a screen.

Streamline sign-in with passkey upgrades and credential managers

This session is the next step in the push towards passkeys, and shows how to opt your app or website into automatic passkey creation, so that when a user logs in successfully with other credentials the system can check if a passkey should be created, and if it is it will store it in your preferred credential manager.

Meet AccessorySetupKit

AccessorySetupKit is a new framework that both makes it so an app doesn’t need to ask for permission to access bluetooth devices or wifi to set up accessories, and offers an experience similar to Airpots setup. It’s another bit of UI that runs out of process with your app to handle the permissions sandboxing, and looks like it will make the pairing process for many accessories much smoother.

Add personality to your app through UX writing

This session walks through the process of deciding of a voice and tone for your app, and then thinking about how to write to match that tone. The idea of having key personality traits to write from, and thinking of which ones are the most appropriate to emphasize in a given situation is a very interesting way of looking at UX writing.

Design advanced games for Apple platforms

This session contains lots of details on how to get the UX right when porting a game to Apple platforms, including both minimum sizes for text and controls across platforms, and guidelines on how to implement touch controls for a game.

Capture HDR content with ScreenCaptureKit

ScreenCaptureKit now supports HDR video, microphone capture, and recording directly to files. It’s nice seeing cleanly supported ways of doing all of these things as these things used to be fairly complex to implement and often required very low level work.

Discover media performance metrics in AVFoundation

AVPlayer now supports generating detailed matrices for HLS playback, and this session shows how to subscribe to those metrics and gather data on performance of your HLS streams on user devices.

Use CloudKit Console to monitor and optimize database activity

This session explains how to use the CloudKit console to set up notifications for activity, so that you can be alerted when issues arise. It also covers how to use the telemetry pages to debug app issues.

Modeling Progress

I wrapped up the tiny kit this week, and am very happy with how it came out especially as I picked the color scheme myself instead of following the original design for the kit. I also primed a set of Gloomhaven minis for a co-worker who's interested in getting into painting.

Dive deep into volumes and immersive spaces

This session explains the new features in visionOS related to volumes and spaces. It also covers a lot of the thought process of how to structure volumes, for instance breaking out content that should scale and track the user into ornaments.

Evolve your document launch experience

The new document launch experience is a new default that will just show up in an app if the configuration is set up correctly in iOS 18. This session covers some customization options, and also how to the into features like creating documents from templates.

Support semantic search with Core Spotlight

This session walks through what’s needed to donate content to spotlight, and how that donated content.will be stores in such a way that it’s only accessible to your app and spotlight. If content is added to spotlight in formats that support semantic indexing like text or pictures, semantic indexing will automatically become available.

Extend your app’s controls across the system

This session explains how to create controls. Which are a new class of widget that can either be a button, or a toggle. It also covers customizing those controls, and how to share state from the controls between multiple devices via push notifications.

Enhance your UI animations and transitions

This session explains the improvements to the animation system, in particular how to use SwiftUI animations to get cancellable, interactive animations in UIKit views, and also how to make use of the new zoom animation.

Build multilingual-ready apps

This session explains best practices for localization, and how to tap into some of the new system behaviors, like being able to learn user keyboard preferences for individual sections of your app, and new inline formatter behaviors. It also explains some common issues that can be run into with text, like bold-ing not behaving as expected in some languages, the fact italics aren’t rendered in some languages, and how to not use autocomplete suggestions for partial characters.

Create custom hover effects in visionOS

Learning how to work with hover effects on visionOS is particularly interesting. All of the effect states are rendered at the same time, so that the OS can handle moving between them out of process without revealing eye tracking data to your app. Multiple effects can be composited together in groups, and there are delay modifiers to help not have effects toggle on and off multiple time in quick succession.

Tailor macOS windows with SwiftUI

This session covers how to handle common window management tasks in SwiftUI, including making windows not re-open when restored, and handling placement and scaling on a screen.

What’s new in SF Symbols 6

SF symbols adds some new animation tricks, adds a lot more glyphs, and generally builds on top of the existing library. All of these effects are aimed at adding subtle indications of functionality or activity to an app and fill out the functionality nicely.

Demystify SwiftUI containers

This session walks through all of the new APIs that were introduced to let you build your own container views. These cover reading out all of the resolved subviews, how to perform layout, how to react to the amount of content, and how to add custom drawing elements that are set as modifiers on the child view, but that are rendered by the container.

Create custom visual effects with SwiftUI

This session explains several different ways to create visual effects. The new Text Effects API looks quite impressive, as does the new APIs for creating transitions or animations of content in a scroll view. It also has a refresher on the ability to use metal shaders, which was added last year.

Meet the Contact Access Button

The contact access button is a view that allows an app to request momentary access to selected contacts on demand. This along with the changes to the contacts store and contacts authorization make it easy for apps to request limited access at the time of use instead of needing to request access preemptively.access for ongoing access to all contacts.

Bring context to today’s weather

The weather API now has the ability to give updates on significant changes to weather, so it’s easier to create contextual information about temperature, precipitation, etc. There’s also more forecast data added to the API, and support for more compact data formats on the Javascript API.

What’s new in location authorization

There’s a entirely new version of location authorization available, and now location authorization is tied to sessions, and has lots of new rules on when a feature can be started, especially that a full accuracy tracking session can only be started when the app is foregrounded. It also adds some much improved diagnostic information for keeping track of the status of a session including things like losing user permissions as well as things like insufficient accuracy.

Unlock the power of places with MapKit

Market now has unique place identifiers for points of interest so they can be shared and referenced more easily, there’s also automatic UI for displaying those places as cards. The Javascript version of MapKit also has a simplified token format that lets you use a token tied to a domain instead of needing to create JWTs.

Design Live Activities for Apple Watch

This session covers design considerations for live activities for the watch. By default the most compact version of the iPhone activity is used to automatically make a watch activity, but there are opportunities for customization and places where you can add interactivity if it will help.

Design great visionOS apps

This covers the design concerns for making an visionOS app, and has several quotes from developers of existing visionOS apps. There’s a focus on coming up with a “wow” experience for the for visionOS, and making sure all of the interactions are comfortable for the user.

Explore multiview video playback in visionOS

This shows off the ability to play multiple videos at once using AVPlayer on visionOS, how and how to combine that with a content browser to allow the user to pick which videos to add.

Say hello to the next generation of CarPlay design system

This is an interesting look into Apple’s opinions and goals in building an automotive interface. A lot of this is quite possibly taken form the Apple Car project and has been repurposed for CarPlay 2. It will be interesting to look back

Create custom environments for your immersive apps in visionOS

This session goes through the process of taking an environment built in a 3d authoring too and how to optimize it for use in visionOS. This involves optimizing the models of objects that are far away from the center of the environment, pre-rendering the lighting, and combining the textures of many elements into a shared texture.

Design App Intents for system experiences

This session explains how to design intents. The care details were creating an intent that reads like a sentence, not making duplicate intents for similar actions, and providing sensible defaults where possible.

Modeling Progress

This week was painting the little kit. I did half of the kit, and have almost finished the detail work on the second half so should finish this weekend. I'm happy with the color scheme, and how the kit is coming along, especially given how hard it is to do the detailing on something this small. The kit is Pallas Athene, so I looked up colors associated with Athena and used that to build the palette.

Go small with Embedded Swift

This session is a practical demo on deploying Embedded Swift to a matter device. It also covers some of the limitations of Embedded Swift, and how to work around them, such as having to use generics instead of a any type.

Go further with Swift Testing

This session goes into detail on the new Swift Testing setup and how to work with it. One thing that stuck out to me was being able to mark tests as known issues so they’re still compiled, run, and will report when they’re fixed. Having more tools to sort tests, such as tags and suites also seems very useful, as is the fact that tests are now run in parallel and a random order by default.

Explore the Swift on Server ecosystem

This session is a tutorial showing how to use Swift on Server to get up and running, and how versos tools from the community can be used together. It also covers best practices, such as the order which different subsystems should be initiated.

Run, Break, Inspect: Explore effective debugging in LLDB

This is the yearly reminder of all the ways to use the debugger. In particular this covered debugging from a crash log, how to use breakpoints, and a refresher on the debugger itself. The most useful new bit of into is the Swift error symbolic breakpoint.

Consume noncopyable types in Swift

This session explains what non copyable types are, and covers some of the complications of how to work with them. There’s the lifecycle of a non copyable type, how to pass it, and also how to make generics that are conditionally noncopyable so they work as expected when they contain a copyable type.

Migrate your app to Swift 6

This session is a practical tutorial on migrating a sample app to Swift 6 with strict concurrency checking.. It covers both quick wins and how to deal with some of the more complex cases. There is also a lot of good explanation of why these checks are important.

Catch up on accessibility in SwiftUI

This session goes through some of the common ways to add accessibility in SwiftUI, and some of the new features that are available. One detail that sticks out is the ability to conditionally add an accessibility label so that if the default value is enough most of the time, then you can use that and only override as needed.

Get started with Dynamic Type

This session is a catch up on how to use dynamic type, and walks through common scenarios in both SwiftUI and UIKit. IT re-iterates the use of AnyLayout and swapping horizontal and vertical stacks based on the text size class.

Track model changes with SwiftData history

This session covers how SwiftData history works, how to integrate with it custom backed. It explains concepts like the history token, and how to set up tombstone values to be able to track deletions so that you can avoid re-instating deleted items when applying a change set.

Explore Swift Performance

This is a deep dive into working with micro level performance issues in Swift. It covers the cost of different types of memory allocations, and how the compiler applies optimizations. It also was very interesting to see how async calls are translated into machine code.

Analyze heap memory

This session covers how to use the various memory debugging tools in Xcode and Instruments, and how to fix common issues like memory leaks and memory spikes.

Elevate your tab and sidebar experience in iPadOS

This session covers how to make use of the new tab view in both SwuftUI and UIKit. There’s both a new more type safe way of specifying tabs in SwiftUI, and the customization of.a Tab View can be saved in @AppStorage to make it easy to persist user changes.

What’s new in AppKit

The changes that came to AppKit are mostly exposing features that are also available in SwiftUI or UKIt, but it’s nice to see parity being maintained there. The interesting AppKit specific features are support for the various window tiling modes, and the ability to use system cursors.

What’s new in StoreKit and In-App Purchase

The focus of this was on using win back offers, and the new SwiftUI views that can render store kit content. Another item of note is that StoreKit 1 is deprecated and will be removed in a future release so there’s a strong push to update to the new framework.

What’s new in watchOS 11

Some of the most interesting changes here are that watchOS will be able to show live activities on the Smart Stack with no configuration, and lots of changes to widgets. Having widgets that can perform an action without launching your app will potentially add lots of new interactions on watchOS.

Swift Charts: Vectorized and function plots

This update allows rendering functions and vector data using Swift Charts. This makes It shows off how to combine a function plot with a standard chart to show how the data matches a distribution curve.

Work with windows in SwiftUI

This showcases how to work with windows in SwiftUI, particularly how to transition between different windows, and how to react to user behavior rejigging and moving widows.

Migrate your TVML app to SwiftUI

Apple is deprecating TVML, so this session is a walkthrough of how to reproduce may of the stock TVML elements and behaviors in SwiftUI.

Get started with Writing Tools

Integrating the new writing tools in app looks to be quite simple.as most of it is automatic and handled by the system. The session does explain how to exclude portions of text from the writing tools, for example code blocks, and how it integrates with the underlying text storage and undo manager.

Squeeze the most out of Apple Pencil

This session explains how to make custom tools for the Apple Pencil, how to work with the tool picker, and how to respond to the new gestures and rotation data sent from the new Apple Pencil.

Bring expression to your app with Genmoji

This session covers how to handle using Genmoji in your app, and especially how to support including the generated image glyphs as embedded content in an attributed string and serialization into an RTF format so than the default data store, and what it would take to implement it for your own custom data store.

Modeling Progress

This week, I spent a lot of time working on a very small kit that I picked up in Japan. I prepped the whole kit, primed all of the pieces in black, put it together, and did a zenithal prime that will help accentuate the details when the final paints go on. Finally I took it back apart and started prepping each section for painting with base colors.

As an attempt to learn more about the development landscape outside of the iOS ecosystem, I went through a course on using Nuxt, and so I used the things I learned from that to re-work my blog again as part of my prep for this year's WWDC as I plan on trying to watch all of the sessions and post a brief summary of each one here.

The new stack that I'm using to run this blog is:

• Nova to edit text.
• GitHub to host the code
• Nuxt.js to generate the page
• Nuxt Content to let me use Markdown files to generate posts
• Tailwind CSS for styling
• GitHub Pages now that pages supports deploying via actions, it was easy to set up a statically rendered version of the site
• Google Fonts to delivery custom fonts
• Unsplash to pull images to add some visual interest

Once again, I’m on a mission to watch 100% of the WWDC session videos. I have some tools to help with that that are almost done, so hopefully in the next week or two I’ll be ready to share a bit more about those. For now I managed to keep a solid momentum of 3 videos a day.

Keynote

I don’t have a lot to say here, most of the announcements were for things that won’t be developer facing. I am a bit amused that Apple is essentially implying that AI image generators are good for turning out custom clip art.

Platforms State of the Union

The platforms sate of the union is hard to talk about in a whole different way as it’s so dense with things to think about. The new code completion is promising, Swift 6 concurrency is both promising and looms large as pretty much every project out there has work to do to pass muster there. Swift Testing looks promising, and the new presentation animations in SwiftUI look nice. I’m sure I missed a bunch of things, but will talk about them in the right session videos.

Week 1

What’s new in Xcode 16

An overview of the new features in Xcode 16. The stand out features to me are the new macros to make working with tests and previews easier, and the new tools to help with performance issues. The flame graph in Instruments should be very useful for analyzing performance issues in apps.

SwiftUI Essentials

Nothing new here, but it was the best overview I’ve seen of the design goals that went into SwiftUI. It also was very interesting that this talk spent a fair amount of time explaining how to interoperate with UIKit and AppKit.

What’s New in SwiftUI

Lots of feature improvements here that will make a big improvement. The zoom transition will be very interesting to play with, the scrolling enhancements cover things that required a bunch of trickery to get right. Bridging animations between UIKit and SwiftUI and using UIKit gesture recognizers in SwiftUI has some interesting potential uses, and the TextRenderer looks very promising for adding some more exciting effects to text.

Meet Swift Testing

Swift Testing looks like it will be a really nice improvement un usability compared to XCTest. Being able to use a handful of macros instead of remembering all of the XCTExpect rules should be a very nice improvement.

Xcode Essentials

This is a great talk for anyone who wants to learn ways to make working in Xcode faster. It covered some of my favorites like quick open, reminded me that there’s a command Manu, and went over how to get the most value out of the logging and testing tools.

What’s new in SwiftData

Looks like there are some nice things added to Swift Data, in particular the ability to specify that a combinations of values need to be unique for a record. Custom storage backends have a ton of potential for teams that want to migrate to Swift Data from another system. #Expression also looks like it fixes a lot of my issues I had working with Predicates.

The biggest thing that I caught here isn’t directly Swift Data, the new PreviewModifier protocol will make working with previews ,such easier.

What’s new in Swift

This covers the new features in Swift 6. The most day to day usable things will be the data race safety (after the pain of fixing all of the potential; problems the new system will expose), and types Throws. There’s also a lot of things that are interesting for the long term, like the C++ interoperability, and improvements to the swift for Linux toolchain.

A Swift Tour: Explore Swift’s features and design

I think this video would be a great video to show to someone who’s an experienced developer who wants to learn about Swift, or someone very new to Swift. It did a great job covering core information about the language but there was no new information that hasn’t been covered before in other places.

What’s new in UIKit

Unsurprisingly the majority of the content here is either UIKit getting updates to make sure it stays in sync with SwiftUI like the new tab bar stye, SF Symbol animations, etc.

Extend your Xcode Cloud workflows

This session shows off some of the more advanced features in Xcode Cloud. In particular it showed how to integrate running tasks at the request of an outside service via the API, and then report the results via. a webhook.

Demystify explicitly built modules

This session explains explicitly build modules, and how to turn them on and fine tune project settings to save build time. I’ll be interested to try this out and hopefully see some build time improvements on my projects.

Create a custom data store with SwiftData

This covers how to create your own data store for SwiftData. It looks surprisingly easy to get the basics off the ground, and then there are many optional improvements that can be made. Lots of potential here for using this to allow for a phased adoption of Swift Data in an app by bridging to an existing store.

Model Shots

I spent the week wrapping up a kit I started earlier, it's a request so it's not on my usual theme, but it was a very fun project to work on. It's 90% done and looking good:

Progress report: 177 of 177 videos watched and summarized. So that means I've managed to watch all of the session videos and now have a passable index of ideas introduced at WWDC this year. So now that I've finished the ”watch all the things” task I set out for myself, I need to figure out what to do with all of the information, aside from the obvious part of using it in my day job, and also see if now that I've managed to get some momentum going if I can stick to the blogging thing again.

Discover Metal for immersive apps

Enhance your spatial computing app with RealityKit

Create immersive Unity apps

Bring your Unity VR app to a fully immersive space

These sessions all focused on developing games in visionOS, and other low level implementation topics for the OS. It’s promising to see that Unity has lots of integrations for visionOS close to ready, and that it’s using things like MaterialX to bridge the unity Materials system to visionOS.

Customize on-device speech recognition

This session explained how to train the on device speech recognizer for both user specific and domain specific content. It explains how to weight terms, and how to do things like use phonetic annotations to ensure that the words are parsed properly.

Explore 3D body pose and person segmentation in Vision

Detect animal poses in Vision

These sessions show off the new enhancements to Vision. Having support for 3d pose detection for people adds interesting potential for modeling and animation, and the new person segmentation should allow lots of interesting new effects.

Explore Natural Language multilingual models

Discover machine learning enhancements in Create ML

Optimize machine learning for Metal apps

Improve Core ML integration with async prediction

Use Core ML Tools for machine learning model compression

These sessions explained all of the new features in CoreML and the related tooling that are coming to the new OSs. This includes support for multilingual models, support for LLMs, improved model compression options, and the ability to use async predictions to efficiently handle many prediction requests.

Integrate with motorized iPhone stands using DockKit

This session showed off what you can do with DockKit. This is a system level toolkit for interacting with compatible motorized iPhone docs. It offers both person and point of interest tracking.

What’s new in privacy

This session is an overview of all of the new privacy technologies coming in the new OSs. As I watched this late, there wasn’t anything of interest that wasn’t in another session video,

Protect your Mac app with environment constraints

This session explains how to add environment constraints to Mac apps which allow for more control over the allowed execution environment. In particular, it allows for developers to do things like only allow helper tools for the application to be launched by the app itself to avoid parent processes being used to alter execution behavior.

Support HDR images in your app

This session explains the new tooling that’s coming to the OS for working with HDR images. Image views now support setting the displayed content to SDR, limited HDR or full HDR. Limited HDR is meant to be used in situations where there is mixed SDR and HDR content, or where HDR content would be distracting.

Support external cameras in your iPadOS app

This session explains how to use wired external camera on an iPadOS app, and how to handle the fact that device rotation and camera rotation can now be independent of each other.

What’s new in CSS

Explore media formats for the web

These sessions show off the work that the WebKit team has been doing to support emerging web standards. It’s interesting seeing successor formats to JPG, PNG and GIF coming after all of there years.

What’s new in web apps

This session demonstrates the new features that are available in web apps. The most important feature is that you can now create web apps from Safari on macOS. And there are new configuration options to help site maintainers scope and customize what a web app will look like.

What’s new in Safari extensions

This session explains all of the new features coming to Safari extensions. Among other things it includes more CSS selectors for content blockers, and new permissions for redirecting requests or modifying headers.

Meet Object Capture for iOS

This session shows the new ObjectCaptureView on iOS. It’s a SwiftUI view, and uses a state machine to manage state, which is very interesting as an architecture note. It supports capturing LIDAR data alongside photos, and can either generate the 3d model on device, or has tooling to export the images for processing on a Mac in Reality Composer Pro.

Explore enhancements to RoomPlan

This session has details on improvements to RoomPlan. The marquee feature is multi-room scans, but it also has support for more object types, more complex rooms, and exporting metadata along with the USDZ file.

Discover Quick Look for spatial computing

This session shows off Quick Look into visionOS. It has full support of the quicklook features of other platforms, and also the ability to drag content out of you app into a windowed quicklook view.

Create 3D models for Quick Look spatial experiences

This session covers details on using 3d models in Quick Look on visionOS, and includes lots of details about how to optimize materials, textures, and models to keep the model performant when being used.

Work with Reality Composer Pro content in Xcode

This session explains how to work with content from Reality Composer pro, and explains both how to load the content into the view, and also how the data in the Entity Component System is structured and how to work with them from Swift.

Explore rendering for spatial computing

This session covers details on how to optimize content for rendering in visionOS. In particular, it covers optimizing models and layer based content to better handle the foveated rendering.

Build spatial SharePlay experiences

This session explains how SharePlay works in visionOS, how the scenes are set up so that people can collaborate around different elements, and how to control which windows are shared in the SharePlay session.

Meet ARKit for spatial computing

This session summarizes the API updates to ARKit that were added for support in visionOS. This includes world tracking, hand tracking, and scene reconstruction.

Get started with building apps for spatial computing

This session is a kick off guide showing how to work with spatial computing shows off the variety of sample projects Apple has provided and shows how to get started.

Progress report: 147 of 177 videos watched and summarized, or 83.0%. I averaged of 3 videos a day, so a significant slowdown but not surprising it's getting outside of the areas of interest for me. In particular things like enterprise device management are going in the "not useful now, but may be useful later" column.

Support Cinematic mode videos in your app

This session explains how to integrate viewing and editing content created with the cinematic camera on iOS in an app. It also describes the format of data that Cinematic mode produces, which is the video stream, a depth stream, channels that describe points of interest in the scene, and then a control track.

Add SharePlay to your app

Share files with SharePlay

These sessions cover the new SharePlay functionality, in particular the ability to start of SharePlay sessions via share sheets and other contexts, and the ability to send files via SharePlay.

What’s new in ScreenCaptureKit

ScreenCaptureKit continues to add features. This release adds a system picker for screen sharing and allows for users to share content from a window to another app via the title bar. It also adds a tool for taking screenshots with most of the same affordances of the video capture tooling.

Tune up your AirPlay audio experience

Explore AirPlay with interstitials

These sessions go over fine details of AirPlay integration, both how to make sure you properly use the buffer to allow instant reaction t control events in audio apps, and how to support interstitial events both for live and VOD content.

Enhance your app’s audio experience with AirPods

What’s new in voice processing

These sessions talk about how to integrates with the new features coming to AirPods to enable features like muted talker detection, and tap to mute on the devices.

Create a great spatial playback experience

Deliver video content for spatial experiences

These sessions go over how to set up video playback in visionOS, and also detailed information about how to encode 3d video in a format that visionOS can use well.

Discover Continuity Camera for tvOS

This session goes over how to integrate with Continuity Camera on tvOS. Most of it is similar to iOS, but then with the need to manage devices being added or removed as the cameras are connected wirelessly and can change at any time.

Deploy passkeys at work

What’s new in managing Apple devices

Explore advances in declarative device management

Do more with Managed Apple IDs

Meet device management for Apple Watch

As I don’t dealt with managed devices, these session largely don’t apply to me, but it’s always interesting to see what Apple is working on. The interesting bits are that there’s now a way to set up passkeys in enterprise environments and restrict them to managed devices, and that declarative device management is being pushed as the main way to manage devices.

Build a multi-device workout app

This session covers how to set up a multi-device workout. This involves a new API that lets you mirror the session between devices and handle sending data in both directions.

Your guide to Metal ray tracing

This session goes over how to set up acceleration structures for metal ray tracing, and shows off the new curves type. It’s nice to see consistent progress on this.

Explore the USD ecosystem

This session talks about working with USD files, and talks about the integration with MaterialX, which is coming to visionOS first but will probably roll out to more platforms over time.

Explore materials in Reality Composer Pro

This session walks through building materials in the material graph in Reality Composer Pro, starting out with some very basic color manipulation and ending with swapping between two material and geometry sets.

Build great games for spatial computing

This session goes over the basics of how to build games for spatial computing, focused on explaining the available input types and also the different rendering modes that you can use and the performance implications of those modes.

Modeling Progress

Evangelion unit 0 is now completely assembled, and I'm waiting until I'm in the right mood to spend a couple hours doing lots of very fussy details.

I also managed to get this kit assembled and painted, and the weathering about 2/3 of the way done.

And I started on another kit, and am playing with enamels for the metallics. Which look quite nice, and they're more durable, but require a lot more fuss in terms of handling:

Progress report: 126 of 177 videos watched and summarized, or 71.0%. I managed to keep a slightly higher average of 4.14 videos compared to last week. More of the features in sessions are starting to fall into the “things to keep an eye on for future projects” bucket than things I'll use day to day, but it's good to have a mental index of what's out there.

Build robust and resumable file transfers

This session covers both how to use the existing capabilities to resume a failed download, and also how to use resumable uploads. Most of the support for this is built into URLSession, and supporting resuming uploads will require a server that supports it as it’s using a brand new specification.

Design dynamic Live Activities

This session covers lots of the considerations about crafting a live activity that will fit into the dynamic island well, and also maintain the personality of your app when place in that space.

Design considerations for vision and motion

This session explains how to design for visionOS in a way that won’t make the user uncomfortable. It focuses on how to avoid eyestrain by sending the right messages about depth to the user, and understanding which eye movements take more energy. It also covers how to move elements on screen to avoid triggering motion sickness.

Keep up with the keyboard

This session explains the upcoming changes coming as the keyboard moves out of process with the currently running app and more of the operations that it performs are asynchronous. It also shows off the improvements to the keyboard layout guides, and how to handle the keyboard in contexts like Stage Manager where the app isn’t full screen.

Create a great ShazamKit experience

This session goes over improvements to ShazamKit, in particular it adds the ability to use a managed session for audio recognition to make the setup for use in app much easier.

What’s new in VisionKit

Lift subjects from images in your app

These sessions show off the improvements in VisionKit, in particular the ability to recognize and lift the subjects out of images. Given how hard it used to be to manually do this, getting a decent mask of the subject in an image for free is quite impressive.

Integrate your media app with HomePod

This session explains how to integrate your media app with HomePod, including how commands are routed to phones to help understand potential issues with that handoff process.

What’s new in StoreKit 2 and StoreKit Testing in Xcode

Explore testing in-app purchases

What’s new in App Store server APIs

Meet the App Store Server Library

These sessions all cover how to integrate with the App Store, both on the app side and server side. It’s nice to see that there’s more tools for testing, and that there’s a library to help with server implementation that’s available in Swift, Node, and Python.

Explore enhancements to App Intents

This session shows how to provide more data to app intents, and how to use the new features like providing the name of produced data at the end of a step in Shortcuts to make it easier to reason about the flow of data.

What’s new in App Clips

This session goes over improvements to App Clips. The interesting news is that the clip size is now 50 mb for digital invocations, but still 15 mb physical invocations. There’s now also default app clip links that are hosted on an Apple domain so that you can create an app clip link without having to perform all of the set up work on a live domain.

Meet Core Location for spatial computing

This is a session explaining how Core Location works on visionOS. It only supports while in use location data, and “in use” is when the app is being looked at or is in the users peripheral vision, which is interesting.

What’s new in Wallet and Apple Pay

This covers all fit new features in Wallet and Apple Pay. It’s interesting to see how may categories Apple Pay is moving into. Including allowing transferring funds There is also improvements to order tracking improvements to integrate more deeply into the system. The ID information is also interesting, but is of limited use to me until there is digital ID support in the EU.

What’s new in Core Motion

This session covers new Core Motion features, most of which are focused on watchOS. Newer watches can capture high frequency motion data, and also data related to water depth and temperature.

Update Live Activities with push notifications

This session explains how to use push notifications to update Live Activities, including important concepts like how different priority levels of notifications are handled and how the system may throttle updates.

What’s new in Background Assets

This session describes improvements to background assets. Among other things, how to mark assets as "essential" so they will attempt to download before the app can be launched, but if the download fails the app can be launched without those assets.

Discover streamlined location updates

Meet Core Location Monitor

These sessions show off the improvements to Core Location, in particular there is a new API for subscribing to updates that returns them as an AsyncSequence and attempts to simplify the process of monitoring updates, including more robust background tracking.

Meet Assistive Access

This session describes how Assistive Access works, and what you can do to improve support for assistive access in your app by adding configuration keys to let the system know your app has a layout that will work with the large bottom back button that's always on screen in Assistive Access.

Extend Speech Synthesis with personal and custom voices

This session shows how to add annotations to better control speech synthesis, and also what you need to do to request permission from the user to use a personal voice.

Create accessible spatial experiences

This session went over the new accessibility needs that are specific to visionOS, including how to allow app hand gestures, and how to integrate RealityKit content into the accessibility system.

Build accessible apps with SwiftUI and UIKit

Lots of detail about basic accessibility features, the most interesting detail in the session was the ability to use closures to set UIKit accessibility values so that they'll be evaluated on read and therefore always up to date.

What’s new in App Store pre-orders

What’s new in App Store pricing

Explore App Store Connect for spatial computing

Not much of interest here, having per-region pre-orders is nice, and it went over the extended pricing options that were previously announced, and did a nice job of explaining how to manage different pricing options.

Modeling Progress

Evangelion Unit 0 is close to complete, the last rack of parts are painting and waiting for assembly. After the kit is assembled, there's a bunch of stickers + weathering to do to make the kit look finished. Plus I need to figure out what to do for a diorama for the kit.

Progress report: 97 of 177 videos watched and summarized, or 54.80%. Another slight slowdown since last week, but not a huge one since I averaged 3.85 videos per day this week compared to last week. And I still have a couple sessions that had really interesting tidbits that I hadn't heard anywhere else this week, in particular there's a lot of potential in the support for app level network relays.

Debug with structured logging

This session explains some improvements to the debug console in Xcode, in particular p now uses a “do what I mean print” command under the hood, to make it easier to print data when debugging. It also shows off some of the new console tools that you get access to when using os_log instead of print based logging.

Perform accessibility audits for your app

This is and overview of the newly added features in to be able to use accessibility audits while running UI tests to expose features there, and some basic troubleshooting issues to fix some common issues.

Bring your game to Mac, Part 2: Compile your shaders

This session goes into depth in how to convert DirectX shaders to Metal, and also how to make use of features like precompiled shaders. One item of note is that Apple is porting some of these tools to Windows to make it easier to integrate into the game development process

Bring your game to Mac, Part 3: Render with Metal

Optimize GPU renderers with Metal

These sessions went deep in depth on how to optimize a metal rendering pipeline. Which is far enough outside of the realm of what I do that I don’t think there’s anything particularly interesting that I can say about it.

Fix failures faster with Xcode test reports

This shows off some of the new features in Xcode test reports. Being able to scrub through a video of a UI test to pinpoint a failure seems really useful, as does Xcode being able to show trends in your tests to help catch slow tests and patterns of failures.

What’s new in App Store Connect

This session goes over some of the changes that have happened in App Store Connect in the last year. One thing of note is that you can now create user scoped API tokens, which may make using App Store Connect API tooling a bit easier.

Rediscover Safari developer features

What’s new in Web Inspector

Most of these sessions apply to web developers, but the new in-app web view debugging may be useful when web content in an app isn’t behaving properly. The standards based automation tooling also may be useful in the future.

Optimize app power and performance for spatial computing

Meet RealityKit Trace

These sessions covered performance concerns in RealityKit and how to address them. One mine technique of note is that it was called out at drop shadows are expensive over the translucent backgrounds used by default in visionOS, so a useful thing to keep in mind.

Create practical workflows in Xcode Cloud

This session was a quick run through of setting up a handful of Xcode cloud workflows. It’s nice to see some of the tooling that’s been put in place to make it easier to migrate into Xcode cloud from other CI environments.

Analyze hangs with Instruments

This session shows how to diagnose and handle hangs in Instruments, and walks through several common scenarios. It also does an excellent job of showing how to combine multiple instruments, and pull out extra details to make it easier to fully solve the problem.

Principles of Spatial Design

Design for spatial input

Design for spatial user interfaces

Design spatial SharePlay experiences

These sessions help teach the foundations of designing for visionOS. One of the more interesting topics covered is how to structure content so that the eye is drawn to the center of the element, and also how the system will use adaptive scaling so that UI elements remain the same relative size and the window will scroll up if it’s placed further away from the user.

What’s new in Core Data

I can’t help but wonder how many of the new things added to Core Data were added to support Swift Data. The most interesting new feature in this session is composite attributes, which are a way of structuring your data without having to add relationships or deal with transformable objects.

Ready, set, relay: Protect app traffic with network relays

This session shows off a few things with interesting potential. Apps can now specify relays and route traffic through them. Devices will also be able to specify that all traffic to specific domains need to route through a relay, so there’s potential to replace a proxy server with a relay.

Create seamless experiences with Virtualization

This shows off some of the new Virtualization features, of particular interest, support is coming for saving the active state of a VM to reload later, and a display type that will change the resolution to match the window size.

Sync to iCloud with CKSyncEngine

This shows off using CKSyncEngine to drive sync with CloudKit. This handles most of the integration required to sync via CloudKit and lets your app focus on handling conflicts without needing to worry about things like network errors, iCloud account changes, and the like.

Explore immersive sound design

This session explains how to work with immersive sound design, and how Apple build the sound of environments that will ship with visionOS. One key detail is using random variation to break up the repetitiveness of sound using randomness and variation.

Optimize CarPlay for vehicle systems

This covers new features added to CarPlay. These include AirPlay2 style audio buffering, and also support for automatically pairing a phone when it’s used as a car key.

Reduce network delays with L4S

This session goes into a lot of detail about how Low Latency Low Loss Scalable Throughput works. From the app level, the implementation details are handled by URLSession, but at the transport and server level, it involves reacting to congested network conditions and changing the strategy for sending out packets.

Meet Push Notifications Console

Testing push notifications has slowly improved, first you had to figure it out yourself and only could test on device, then you could send payloads to the simulator via drag and drop. Now there’s a web console that lets you test all sorts of APNS scenarios and track notification delivery status.

Discover Calendar and EventKit

This session shows off some of the new EventKit tooling coming to the latest OSs. Of note, you can now write to the calendar via an out of process UI with no user permissions.s if they’ll be used often.

Spotlight your app with App Shortcuts

Design Shortcuts for Spotlight

A pair of sessions describing the design and development considerations for Shortcuts. It's nice to see that device side ML is going to be used to help Siri match voice prompts to Shortcuts, even if there isn't a perfect match, and that there's now a good way of testing Shortcuts without having to install and test on device.

Modeling Progress

I completed assembly of the kit I've been working on, I'm still contemplating if I want to do any sort of weathering or base for it.

This is the torso of the next kit that I'm working on, eight pages into the instruction book. It's particularly interesting as there's articulation all along the spine, so the finished kit should be quite flexible.

And this is where I finished the week, with the torso, head, and one leg completed. This is somewhere around half of the steps in the kit, so I'll probably be close to finishing it up by this time next week.

Progress report: 70 of 177 videos watched and summarized, or 39.55%. So less progress than last week, but I still averaged 4 videos a day which is respectable progress with about a month left. I'm guessing that I'll keep slowing down as the videos get more and more off topic from my core interests.

Create rich documentation with Swift-DocC

This gets into detail on some of the more advances DoCC features. The rendering directives look really nice, and having a live preview is a big improvement for iteration.

Write Swift Macros

A great step by step guide for writing macros. When I need to write a Macro for something, I’ll come back to this session for reference. One interesting detail of note is how much Apple is pushing using testing to ensure correct macro behavior.

Beyond scroll views

This goes over several new SwiftUI features that make scroll view behaviors that were previously very difficult like snapping to content at the end of a scroll easy to do with help from the system. This should be a huge win for implementing custom designs faster and with fewer ugly hacks.

What’s new in SF Symbols 5

Seeing how animation in SF Symbols works is interesting. It’s a relatively limited set of animations, and there’s no keyframes or other information, instead it’s using the layer information to choose which parts of the symbol to highlight or scale

Meet StoreKit for SwiftUI

This continues the pattern of Apple working to make working with subscriptions and in app purchases significantly cleaner. The StoreKit in SwiftUI additions give you a decent base view, and offers lots of places for customization, and also allows you to observe StoreKit state and update your view hierarchy based on state from that.

Wind your way through advanced animations in SwiftUI

This explains phase based and keyframe animations in detail. Phase based animations are a series of discrete steps, whereas keyframe based animations let you manually set up the keyframes and curves within an animation. This adds some of the last parts of animation support that was missing from previous release.

Bring widgets to new places

A light overview of the new places that widgets are supported, and the changes in the widgets API that were made to support those new places, in particular moving backgrounds to a new modifier so they can be removed easily, and changes to how to use the container padding.

Unlock the power of grammatical agreement

This covers the new grammatical agreement modes to both help make sure that you use the correct versions of words in grammar sensitive languages, and support for intelligently changing text based on preferred pronouns.

Design and Build apps for watchOS 10

This session is presented by both a designer and a developer, and explains both design and functional decisions for the UI updates in watchOS 10. It explains how to use the new layouts, and some of the new UI features like the color full bleed backgrounds.

Take SwiftUI to the next Dimension

This session goes into detail on how to integrate 3d elements into SwiftUI views in visionOS. Having done a bit of 3d work in the past, I’m very impressed with how much work is going into making it easy to use familiar design patterns, and how those patterns are extended into 3 dimensions.

Update your app for watchOS 10

This was a hands on demo of applying the design principles mentioned in other sessions to your app. If you’re looking for some concise code examples for a how to use the new design elements in watchOS this is a good session to refer to.

Evolve your ARKit app for spatial experiences

This session covers the new and updated capabilities that are available on visionOS. In particular it adds the ability to track world anchors at the system level, and hand tracking.

Design widgets for the Smart Stack on Apple Watch

Build widgets for the Smart Stack on Apple Watch

These sessions cover the design decisions to think about when putting together widgets in watchOS 10, and also detailed instructions for how to build a widget on watchOS 10. Definitely worth a look when sitting down to start that task.

Create animated symbols

Animate symbols in your app

These sessions show off how to create and annotate symbols for animation, and then how to use the annotations to trigger animations in your apps. Create animated symbols also shows off using symbol components to add modifiers to your custom symbols and get system like behavior with minimal effort. Animate symbols in your app shows off how the different animation types can be triggered and how they work in an app.

Explore SwiftUI animation

This video does a great job explaining how animations work in SwiftUI, in particular it diagrams how data flows through animations and that Animatable and Animation are in SwiftUI. It also shows off the new scoped animation modifiers, custom animations, and shows how to work with transactions.

Build better document-based apps

A good overview on new features for document based app. The code example was UIKit focused, showed off how much code you could remove from. Document based app and still integrate well with the system.

Create a more responsive camera experience

This covers how to use the new APIs for zero shutter lag, and deferred photo processing and explains how those settings work with the photos processing pipeline. It also explains how to work with reaction effects in video streams.

Embed the Photos Picker in your app

The headline of this video is that you can now embed an out of process photos picker in your app, there are a lot of other improvements set up to allow you set up your own interactions with that. It also shows the correct flags to use if you want to export HDR content instead of down

What’s new in text and text interactions

This shows off the changes to text interaction in the new OS versions, and how to take advantage of those new interactions. It also shows off new text features, and the one that caught my eye is support for lists in attributed strings.

Demystify SwiftUI performance

This session has lots of useful in-depth explanations of the view update cycle in SwiftUI, and explains some targeted optimizations that can be made to improve the rendering speed of SwiftUI views.

Explore pie charts and interactivity in Swift Charts

This shows off the new chart types added to Swift Charts, and also how to add new interactive behaviors. Having the ability to easily select and get more data on an element, and define scroll snapping makes Swift Charts now handle a lot of the use cases that previously required pulling in other libraries or doing lots of challenging work.

Go beyond the window with SwiftUI and

Elevate your windowed app for spatial computing

Another pair of sessions showing how to use the different visonOS scene types in SwiftUI, and how to integrate existing views into visionOS. One interesting item shown off in this session was how to creates meshes that can be displayed tracked to the users hands while in a fully immersive scene.

The SwiftUI cookbook for focus

This session walks through how the focus system works in SwiftUI, and explains how to use it in several common scenarios. Of particular interest, it explains how to automatically set keyboard focus for text views properly and also how to add focus behaviors to custom controls.

Animate with springs

An excellent overview of how and why to use spring based animations, and an explainer of the math behind the spring animations. It's also nice to see that since it's non-trivially complex to work with springs, Apple has been adding more affordances to the API to make them easier to reason about.

Modeling Progress

I finished the core of the kit that I've been working on, and have all of the accessories in various states of completed-ness. So primary assembly of that model is almost done, and then I'll have to decide what I'd like to do for extra detail work.

I also prepared the next kit that I'll be working on when I finished cutting out the last pieces from the sprues of the current kit. This kit is the second tier of complexity of kit, so there's more pieces and more colors of plastic. It's also an Evangelion instead of a Gundam, so it's a very different design of robot to work with.

Progress report: 42 of 177 videos watched and summarized, 23.74% of videos viewed. Not a bad dent for the first week. I took in a lot of really fascinating sessions, and am really excited about the new tooling, and how much of it has been focused on developer ergonomics.

I'm going back to a normal schedule next week, which means watching fewer videos per day, so I'll probably be posting weekly from now on.

Model your schema with SwiftData

Nice documentation of how annotation work, the most surprising thing in there is that basic relationships between model types don't even require annotations. Also of note, having migrations between schemas driven by the type system looks like it will be quite nice.

Dive deeper into SwiftData

This explains more of the low level features in SwiftData. This explains how ModelContext and ModelContainer work together, how to build queries with fetch and sort descriptors, and how to work with SwiftData in non-view contexts. Having type safe queries and sorts looks great. It also looks like SwiftData does a to make things work well by default, but offers customization under the hood as needed.

Beyond the basics of structured concurrency

This has a great overview of how to manage groups of tasks, and how to pass data through the task hierarchy. It also feels like the section about distributed tracing is potential very interesting groundwork for tooling to build distributed systems using Swift concurrency.

Mix Swift and C++

I don't think I'll end up using this much directly, but I'm guessing that over time I'll start using it indirectly as cross platform C++ libraries will be much easier to use directly in Swift without needing a middle bridging layer.

Generalize APIs with parameter packs

Seeing parameter packs ship is great as it removes the need to define multiple variants of the same function to take and emit a number of mixed parameters. At the point of use, this should be completely transparent and fix the annoying SwiftUI error when you have too many subviews in a result builder, and it looks like it should be relatively straight forward to implement, though I'm guessing that I'll be referring back to this video when I need to do this myself.

Meet mergable libraries

It looks like an interesting way to get the benefits of both static and dynamic linking for frameworks that will be included in the bundle, and especially should make it easier to work with apps that are broken down into many sub-modules.

Design with SwiftUI

This talk is aimed at designers, encouraging them to use SwiftUI as a prototyping tool. It's an interesting idea, but is a harder sell somewhere that needs to support both iOS and Android.

Migrate to SwiftData

I don't currently maintain any apps using CoreData, but the session was still useful to watch because it helps explain the mechanisms that Swift Data uses to share the same underlying data structure as Core Data.

Discover Observation in SwiftUI

This session did a great job of diagramming when to use the new observation macros, and how they work under the hood. It also covered caveats of how to let the macros know about how to handle observation of computed values that aren't derived by state on the object itself, which is useful but an edge case.

Expand on Swift Macros

This was a really nice, dense session that explains how the macro system works in Swift, and what it can and can't do. It was nice to see how much work was put into making macros safe and predictable. One of the more interesting little details is that it takes what looks like strings in the macro definition and converts them into useful input for the code generation system.

Enhance your iPad and iPhone apps for the Shared Space

A nice overview of what it will take to make iPad and iPhone apps fit in nicely with visionOS, especially how to make sure controls will work with the eye tracking system since the hover effect is abstracted away from your app

Progress report: 31 of 177 videos watched and summarized, 17.51% of videos viewed.

I'm finished the last video in “Essentials” category, so starting tomorrow I get to start working on the “Swift” category.

Meet ActivityKit

This was a nice overview of what's in ActivityKit and how to use it. I didn't catch anything particularly new in this video, but I think it's the first comprehensive video on ActivityKit since it was a beta feature during last years WWDC and release cycle.

Unleash the UIKit trait system

This had the best description of how traits flow through the view hierarchy, and they change to make it easier to reason about makes lot of sense. I find it interesting how much they mentioned performance overhead for adding custom traits here. Finally it looks really nice that you can bridge traits with the SwiftUI environment to share custom configuration between frameworks.

Build programmatic UI with Xcode Previews

The new #Preview Macro makes it a lot nicer to add previews compared to the previous syntax, and it's also exciting that previews now explicitly support UIKit and AppKit instead of having to hack around by wrapping in SwiftUI. Pinned previews and on-device previews both look really useful additions.

Bring widgets to life

Nice overview on how to work with animated and interactive widgets. Having the ability to put together preview timelines for widgets to check out state changes is great. Seeing the use of intents to drive interactions in widgets out of process makes a lot of sense, and it's interesting seeing how different parts of the system compliment each other.

Verify app dependencies with digital signatures

Nice improvements for ensuring dependencies haven't been tampered with automatically. It's impressive to see continued and improving support of 3rd party dependencies having started work back when it felt like Xcode was downright hostile to using them and you were pretty much forced to use complex systems like CocoaPods.

Simplify distribution in Xcode and Xcode Cloud

There's some nice improvements on the local release side, especially things like push notifications when a build finishes processing. Same for the improvements in Xcode Cloud, but since I mostly work with self hosted CI for deployment, I don't get to use any of the new stuff in this session.

Get started with privacy manifests

This was a surprisingly packed session. Privacy manifests themselves aren't big because they're just used to help you fill out the privacy nutrition label for you app, but there were some other big changes that are then backed by the date you get from those. In particular the OS will now block access to domains tied to tracking until the user has opted in to tracking, and there are going to be frameworks listed as “privacy impacting” that will have requirements of signatures, and declare tracking domains in the manifests. APIs that can be used for fingerprinting devices will also now required to choose from a list of valid reasons why they need to use those APIs.

Inspectors in SwiftUI: Discover the details

Inspectors look like a nice way to show more detail about elements in an app, This session also had a good reminder of some of the presentation customization options that were added in iOS 16.4 to let you specify things like which detents to dim the view that is being presented over.

What's new in AppKit

An a (primarily) iOS developer, I mostly watch these sessions to get an idea of convergence between the OSs. On that note, the fact that AppKit is going to do the same thing as UIKit and not clip views by default is interesting.

Prototype with Xcode Playgrounds

Having the ability to make sure that Xcode always builds the active scheme so that you can use playgrounds for active prototyping is nice, and looks like there's a lot of affordances to do things like test out UI. It looks like it will be worth adding a playgrounds scratchpad to most projects to be able to use this.

Meet Swift OpenAPI Generator

This is something I've been chasing since my first full time iOS job. I'm very interested in seeing how well this works in practice, and how much work it is to make a custom re-usable transport library. Probably the most exciting session of the day in terms of potential to save developer time.

Modeling Progress

I varnished the rack that had detail paint done yesterday, and cut out, sanded down, and primed the parts for the next step of the kit.

The varnished pieces then got some basic panel lining in place, and then I assembled the completed section of the kit. With the completed torso the upper body of the kit is done, along with most of the parts for the feet, which then will be assembled into the legs in the next two steps.

Progress report: 21 of 177 videos watched and summarized, 11.86% of videos viewed.

I'm closing in on finishing everything in the “Essentials” category, so in a day or two I'll start focusing on whatever areas of tech catch my eye. And probably rotating between sessions I'm very interested in, and sessions that will be great to follow along with while painting or doing other hobby related things.

Build an app with SwiftData

This was a detailed walkthrough of setting up a very basic SwiftData App. There wasn't much new to learn compared to the Meet SwiftData session, but this will probably be useful for future reference. The one big takeaway was how easy it is to set up a document based app that's backed by SwiftData.

Make features discoverable with TipKit

How to add onboarding hints is something that I've had to implement in lots of apps. Having a rules based system for choosing when to display tips is great, and looks like there's a lot of customizability and granularity to only show tips at the right time. Plus it has an option to sync tip state via iCloud so users don't get duplicate onboarding across multiple devices.

Meet MapKit for SwiftUI

I used to find working with MapKit in UIKit very cumbersome, so all of the SwiftUI updates for MapKit look really nice to me. In particular it looks like there's a lot of affordances to make positioning the map “correctly” easier, and it should also make managing annotations simpler. If I need to do anything with maps in an app, this is definitely the tool that I'm going to want to use.

Build spatial experiences with RealityKit

Really impressive demo of how to add RealityKit backed content a spatial computing app. Good info on how to bridge with SwiftUI gestures, and how to non-destructively work with USDZ files via nesting. When I have a chance to play with a spatial computing app I'll be giving this another watch to pick up more details.

Bring your game to Mac, Part 1: Make a game plan

I'm not a game developer, so this was mostly interesting to me in terms of how much attention Apple is paying to gaming. Having a easy to use translation layer is really interesting, and it may mean games get ported over to Apple platforms faster.

Meet Reality Composer Pro

Reality composer pro looks like a fascinating tool for building 3d scenes, but without the complexity of a game dev environment or 3d modeling and animation set up. I have some fun ideas for things to do involving assembling virtual dioramas and integrating models created using object capture.

Meet Safari for spatial computing

Another not directly applicable to me talk, but seeing the push for a support to USDZ models directly in browser is interesting, and has potential applications in regular desktop browsers. I also look forward to seeing the fun ways that sites break when windows are resized to be larger than the virtual screen.

Meet watchOS 10

It looks like there's a lot of thought that went into how the updates to watchOS are structured. Vertical pagination looks like it will make breaking UI into usable chunks on the watch easier.

Discover String Catalogs

This adds a much nicer UI to working with strings, especially pluralized strings. I'm very interested in seeing how this integrates with 3rd party localization tools. Also of interest, it can detect potentially unused strings and make it easier to clean up stale translations.

Run your iPad and iPhone apps in the Shared Space

Another talk on integrating with visionOS. This a nail in the coffin on Storyboards as they're not supported natively in visionOS, only in iPad compatibility mode which is limited compared to a full port.

Develop your first immersive app

A super high level demo of building something for visonOS from scratch. One of the most interesting details is that the export format from Reality Composer into Xcode is a Swift package. Aside from that, it's something that will be good to refer back to when the visionOS SDK is available and I can try things out.

Modeling progress

Here's the results of the first round of painting for the day. I base coated on rack of parts and did detail highlights on the other.

Then the second round of painting, which adds detail highlights to the rack that was base coated last time, and varnish to the rack that had detail coats in place.

Finally, here's the parts that were varnished have had panel liner added, were assembled, and are now sitting with the rest of the kit that's been put together.

I had another good day in terms of taking in content, all of the “What’s new” sessions had a lot of things I'm looking forward to digging in to in more detail, and I'm impressed with how complete most of the new things that are coming out this year feel. I'm really enjoying having taken the week off to focus on diving in to the new content, and am having a ton of fun playing with my viewing tracking app.

What's new in Xcode 15

Macros look even more exciting, and the ability to expand them inline for debugging is amazing. The type safe asset catalog stuff will be fun to play with, it'd be nice to drop yet another dependency. String catalogs look great, but it'll be interesting to see how long it takes 3rd party tooling to integrate with the new format. I'm interested to see how it feels using Xcode bookmarks in practice. Overall it looks more promising. TestFlight internal only builds are a welcome surprise that fixes some distribution workflow problems.

What's new in SwiftUI

It's nice to see SwiftUI getting more views, in particular the MapView looks really promising. The simplified data flow parts of SwiftUI should solve a lot of problems, particularly the magic it's pulling off where @Observable will only invalidate a view for changes that it observes. More Swift Data stuff, nothing new from other sessions but still exciting to see it. The new Table stuff looks nice, but also like almost all of the improvements are for macOS and iPadOS, which I rarely have a chance to work on. Keyframes look nice for when you need a super detailed animation, but having the option to cleanly chain together a few animations will go a long way for less effort.

I've implemented some of what .visualEffect and scrollTransition does by hand, so it's nice to have a cleaner and easier way to add visual flare to views in the future. Adding styles to texts in string interpolations looks great, as does animated SF Symbols. There's so many exciting scroll view things mentioned here, but there's an entire session on ScrollView improvements.

What's new in Swift

Treating if and case statements as expressions should help with code readability, and reduce the number of ternary operators used in code, which is really nice. Type parameter packs allowing any number of arguments for result builders should be great in practice. Macros continue to look really well implemented and I'm looking forward to getting even more details in those session videos

It will be interesting to see how ownership and C++ interoperability shows up in iOS development, especially as it looks like the C++ bridging will allow for more direct calling of C++ apis, so it could open up use of C++ frameworks from Swift code.

What's new in UIKit

UIKit previews without having to wrap in SwiftUI will make building UIKit views easier. viewIsAppearing fills a missing hole in UIKit lifecycle, and it's great that it's back deployed to iOS 13. The trait system enhancements sound interesting, but there wasn't enough info in this video to say anything useful. The content unavailable configuration for views is something that consistently needs to be added to views, so it's great seeing framework level support for it. There are also lots of new tools to make internationalization easier to handle, especially the dynamic line heights. The ability to share layout info across siblings in a collection view compositional layout is really nice. The grab bag at the end had lots of interesting stuff, the one that particularly catches my eye is the new page control progress APIs.

Build custom workouts with WorkoutKit

Custom workouts look interesting, but are also really of the range of work I'm likely to be doing on iOS, so this one is filed as for future reference in case something that needs it comes up rather than having any detailed opinions on it.

Meet SwiftUI for Spatial Computing & Meet UIKit for Spatial Computing

It's really interesting to see how Apple is building the elements for the new OS, and how it adapts components from previous platforms. Lots of emphasis on using Materials instead of colors for backgrounds, and having content automatically adapt to the environment because of that. Having the ability to put RealityKit data directly into SwiftUI views also is quite nice. I also will be interested in seeing how the new ornament elements are applied to other operating systems over time, especially macOS.

WWD See progress

I refactored the data to support many to many relationships between sessions and topics, and made a bunch of UI refinements to make the app easier to use, so I can now search for talks and quickly mark things as ignored or seen.

Viewing progress

10 of 177 videos, 5.65%, 4 videos ignored.

Modeling progress

I watched a few non-critical sessions today, so I got some painting in too. Nothing super exciting to look at, but I got a base coat down on on rack of parts, and primed a second rack of parts:

Here's the parts that needed a base coat:

And here's the parts with a base coat, and the freshly primed parts:

The painting tomorrow should be more exciting as I'll be putting highlights and varnish on the first rack of pieces, which makes the parts "pop" a lot more, and gets me close to assembly.

It's nice to see the Mac Studio getting a yearly upgrade, and the new 15" MacBook air looks like a really nice computer for the vast majority of users. On the other side, the Mac Pro is now targeted at an even smaller audience than ever. Lots of user facing features that I'm looking forward to on all of the OSs. The most interesting part of the keynote was Apple Vision Pro. I don't know what the killer app, if anything, will be for the platform, but the hardware sounds impressive and I'm looking forward to getting a chance to try it out eventually.

Platforms State of the Union

This was probably the most exciting Platforms State of the Union for me since the introduction of Swift in 2014. Tons of exciting new features, I've been hoping for a Swift first replacement for Core Data since Swift became my "daily driver" language. Plus things like sherlocking SwiftGen for asset catalogs, Swift Macros, keyframes in SwiftUI, interactive Widgets. Plus the VisionOS stuff. 🤯

Minor Detour

The session videos didn't come out until this afternoon, so I spent a bit of time playing with a fun project to kick the tires on the new tools. As I learn things in the session videos, I'll be making more improvements and iterating on it.

Meet SwiftData

First impressions of SwiftData are that it's amazing. Before the session videos dropped I already got a very basic app using SwiftData off the ground. This session only covered surface details, but I'm now even more excited for the sessions with more details when they come out.

Current Progress estimate:

3 of 177 videos, 1.69%.

For anyone not in the the Apple developer community, its WWDC week, which means apple is going to announce new technologies and tooling. They also are going to release about 200 videos to help developers learn about all the new things over the course of the week.

Over the next few months, I plan to watch all of these videos. There are core videos that will get my full attention, but for the vast majority I build and paint model robots with the video playing and make note of anything of interest to pay attention to later.

This year, I also plan of tracking my progress and posting very short summaries of the talks here, along with work in progress shots of the model robots. Hopefully this gets me back in the habit of writing again, as it gives me a something to post about weekly for a few months.

With all of the basic UI in place, the last thing to get in place is figuring out how to get the right click gesture working. I came up with a [proof of concept]() so now it's just a matter of putting the pieces together.

The first step was to split the cell based on the OS involved, and I had to change the structure to get the behavior to work correctly. In particular, I needed to set an explicit frame, and set the foreground color before disabling the view to make sure that un-clickable cells kept the correct colors.

struct Cell: View {
    let value: Game.SpaceState
    let click: () -> Void
    let flag: () -> Void

    @ViewBuilder var body: some View {
        #if os(macOS)
            AppKitCell(state: value,
                       click: click,
                       flag: flag)
            .frame(width: 30, height: 30)
            .foregroundColor(value.foregroundColor)
            .disabled(isDisabled)
        #else
            if isDisabled {
                buttonContent
            } else {
                Button(action: click) {
                    buttonContent
                }
                .foregroundColor(value.foregroundColor)
                .highPriorityGesture(flagGesture)
                .buttonStyle(.plain)
            }
        #endif
    }
}

I then got to re-use the updating gesture recognizer from my proof of concept, but there was a lot of book keeping involved. Also of note, this is created as a NSHostingController that wraps a SwiftUI View, so all of the UI is still driven by SwiftUI, but with a thin enough shim of AppKit exposed that we can add some gesture recognizers.

final class ButtonHostingViewController: NSHostingController<ButtonHostingViewController.Body> {
    class ButtonViewModel: ObservableObject {
        @Published var state: Game.SpaceState = .unrevealed
        @Published var isPrimaryDown = false
        @Published var isSecondaryDown = false
        @Published var primaryAction: (() -> Void)? = nil
        @Published var secondaryAction: (() -> Void)? = nil

        var isButtonDown: Bool {
            isPrimaryDown || isSecondaryDown
        }
    }

    struct Body: View {
        @ObservedObject var viewModel: ButtonViewModel

        var body: some View {
            viewModel.state.content
                .frame(width: 30, height: 30)
                .background(viewModel.state.fillColor)
                .opacity(viewModel.isButtonDown ? 0.3 : 1)
        }
    }

    private let viewModel = ButtonViewModel()

    private lazy var primaryGestureRecognizer: NSClickGestureRecognizer = {
        let primaryGestureRecognizer = UpdatingGestureRecognizer(target: self, action: #selector(primaryEvent))
        primaryGestureRecognizer.onMouseUp = { [viewModel] in
            viewModel.isPrimaryDown = false
        }
        primaryGestureRecognizer.onMouseDown = { [viewModel] in
            viewModel.isPrimaryDown = true
        }
        return primaryGestureRecognizer
    }()

    private lazy var secondaryGestureRecognizer: NSClickGestureRecognizer = {
        let secondaryGestureRecognizer = UpdatingGestureRecognizer(target: self, action: #selector(secondaryEvent))
        secondaryGestureRecognizer.onMouseUp = { [viewModel] in
            viewModel.isSecondaryDown = false
        }
        secondaryGestureRecognizer.onMouseDown = { [viewModel] in
            viewModel.isSecondaryDown = true
        }
        secondaryGestureRecognizer.buttonMask = 0x2
        return secondaryGestureRecognizer
    }()

    init(state: Game.SpaceState,
         primaryAction: @escaping () -> Void,
         secondaryAction: @escaping () -> Void) {
        super.init(rootView: Body(viewModel: viewModel))
        view.addGestureRecognizer(primaryGestureRecognizer)
        view.addGestureRecognizer(secondaryGestureRecognizer)
        update(state: state,
               primaryAction: primaryAction,
               secondaryAction: secondaryAction)
    }

    @MainActor required dynamic init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    func update(state: Game.SpaceState,
                primaryAction: @escaping () -> Void,
                secondaryAction: @escaping () -> Void) {
        viewModel.state = state
        viewModel.primaryAction = primaryAction
        viewModel.secondaryAction = secondaryAction
    }

    @objc private func primaryEvent() -> Void {
        viewModel.primaryAction?()
    }

    @objc private func secondaryEvent() -> Void {
        viewModel.secondaryAction?()
    }
}

This handles creating the view, adding the gesture recognizers that update the state as it changes, and updating the SwiftUI view as needed. It feels like a lot of code for a really small behavioral change, but I'm thrilled that I got it working.

Now that there's a working game board, we need a header that shows how many mines are left, how much time has elapsed, and the win / loss state. It's a simple view, but there are a few interesting tricks involved.

The first view of interest is the timer view:

private struct TimerView: View {
    @ObservedObject var gameService: GameService
    @State private var elapsedTime: TimeInterval = 0

    var body: some View {
        Text("\(elapsedTime, format: .number.precision(.integerAndFractionLength(integer: 3, fraction: 0)))")
            .monospacedDigit()
            .onReceive(Timer.publish(every: 0.2, on: .main, in: .default).autoconnect()) { _ in
                elapsedTime = gameService.elapsedTime
            }
    }
}

The game service can return an elapsed time, but we need to use a Timer to force the view to update. The game service could do that internally, but that would invalidate all views that observe the service, so it's less disruptive to the rest of the app to put the timer in this view.

Next we have the time label, mines label, and action button. One minor detail of note is the modern format syntax available in iOS 15.

private extension Header {
    private var timeLabel: some View {
        HStack(alignment: .firstTextBaseline, spacing: 0) {
            Text("Time:")
                .foregroundColor(.secondary)
                .font(.callout)
            TimerView(gameService: gameService)
        }
    }

    private var minesLabel: some View {
        HStack(alignment: .firstTextBaseline, spacing: 0) {
            Text("Mines:")
                .foregroundColor(.secondary)
                .font(.callout)
            Text("\(gameService.remainingMines, format: .number.precision(.integerLength(3)))")
                .monospacedDigit()
        }
    }

    private var actionButton: some View {
        Button {
            gameService.resetGame()
        } label: {
            Image(systemName: gameService.state.image)
        }
        .buttonStyle(.borderedProminent)
    }
}

private extension Game.State {
    var image: String {
        switch self {
        case .active:
            return "face.smiling.fill"
        case .win:
            return "flag.checkered"
        case .lose:
            return "xmark.seal.fill"
        }
    }
}

Finally, the whole thing is wrapped up in a view modifier, and is packaged to use the toolbar on iOS, but to inject the views as a header on macOS because I couldn't quite get the right layout of content in the menu bar.

Now the game is play-able, so next post is going to be pulling in the ability to right click on the mac, and the project will be some level of done for now.

Now that the game logic is in place, I'm ready to build a game board. Since there's a new layout system to work with, I'm going to use a Grid. The first thing that I need to do is to make an Identifiable type that stores a row worth of grid cells, and expose it in the GameService:

struct GridPointRow: Hashable, Identifiable {
    var id: Int { row }
    let row: Int
    let points: [GridPoint]

    init(row: Int, width: Int) {
        self.row = row
        points = (0..<width).map { column in
            GridPoint(x: column, y: row)
        }
    }
}

class GameService: ObservableObject {
    var gridRows: [GridPointRow] {
        (0..<height).map { row in
            GridPointRow(row: row, width: width)
        }
    }
}

Since GridRow is already Identifiable, this puts everything in place to be able to put together the board. Since I've done work to put the game logic together in other places, the board view is very simple:

struct GameView: View {
    @EnvironmentObject var gameService: GameService

    var body: some View {
        Grid(horizontalSpacing: 1, verticalSpacing: 1) {
            ForEach(gameService.gridRows) { row in
                GridRow {
                    ForEach(row.points) { point in
                        Cell(gridPoint: point, gameService: gameService)
                    }
                }
            }
        }
        .padding(1)
        .background(Theme.gameBackground)
        .disabled(gameService.state.isDisabled)
    }
}

private extension Cell {
    @MainActor
    init(gridPoint: GridPoint, gameService: GameService) {
        let value = gameService[gridPoint]

        self = Cell(value: value) {
            if case .revealed = value {
                gameService.revealSurroundingIfSafe(gridPoint)
            } else {
                gameService.reveal(gridPoint)
            }
        } flag: {
            gameService.toggleFlag(gridPoint)
        }
    }
}

private extension Game.State {
    var isDisabled: Bool {
        switch self {
        case .lose, .win:
            return true
        case .active:
            return false
        }
    }
}

This creates a grid with a 1px border and 1px line between all of the cells, so the next thing to do is to create the cell. for the first pass implementation, I created a simple version of the view that works on iOS and macOS, with the intention of integrating the ability to right click later. The body switches when the view is disabled to avoid having the button style change the opacity of the content when disabled. I've also split the creation of the content and colors out of this view so that when we switch based on the OS, there won't be duplicated code:

struct Cell: View {
   let value: Game.SpaceState
   let click: () -> Void
   let flag: () -> Void

   var body: some View {
       if isDisabled {
           buttonContent
       } else {
           Button(action: click) {
               buttonContent
           }
           .foregroundColor(value.foregroundColor)
           .highPriorityGesture(flagGesture)
           .buttonStyle(.plain)
       }
   }
}

private extension Cell {
   var buttonContent: some View {
       value.content
           .frame(width: 30, height: 30)
           .background { value.fillColor }
           .foregroundColor(value.foregroundColor)
   }

   var isDisabled: Bool {
       switch value {
       case .revealed(let count):
           return count == 0
       case .flaggedMine,
               .incorrectFlag,
               .unrevealedMine,
               .revealedMine:
           return true
       case .unrevealed, .flagged:
           return false
       }
   }

   var flagGesture: some Gesture {
       LongPressGesture()
           .onEnded { _ in
               flag()
           }
   }
}

extension Game.SpaceState {
@ViewBuilder var content: some View {
    switch self {
    case .unrevealed:
        Color.clear
    case .revealedMine:
        Image(systemName: "xmark.seal.fill")
    case .flagged:
        Image(systemName: "flag")
    case .revealed(let count):
        if count > 0 {
            Text(count, format: .number)
                .fontWeight(.bold)
        } else {
            Color.clear
        }
    case .flaggedMine:
        Image(systemName: "flag.fill")
    case .incorrectFlag:
        Image(systemName: "flag.slash")
    case .unrevealedMine:
        Image(systemName: "seal.fill")
    }
}

var fillColor: Color {
    switch self {
    case .flagged, .unrevealed, .unrevealedMine, .incorrectFlag, .flaggedMine:
        return Theme.unrevealedFill
    case .revealed:
        return Theme.revealedFill
    case .revealedMine:
        return Theme.failure
    }
}

var foregroundColor: Color {
    switch self {
    case .revealedMine, .unrevealedMine, .unrevealed, .flagged:
        return Theme.primary
    case .revealed(let count):
        return Theme.foreground(for: count)
    case .incorrectFlag:
        return Theme.failure
    case .flaggedMine:
        return Theme.success
    }
}

So with all of this, the base game is working, so next is going to be adding right click, and possibly some other small playability enhancements.

One of the "missing" features in SwiftUI that's tripped me up since the first version of Minesweeper that I implemented is that due to the cross platform nature of SwiftUI, there's no concept of a "right click", in previous version I've worked around that by supporting an option click recognizer for the touch gesture recognizer, but that isn't ideal for the macOS implementation.

As far as I can tell, there's still no right click support natively in SwiftUI, so I decided to hack something together myself. I decided that it should support:

• Left Click
• Right Click
• Pass the up / down state into the SwiftUI view rather than having some of the view state handled by AppKit.

To get that working, requires a handful of layers. The outermost layer is:

struct SecondaryActionButton: NSViewControllerRepresentable {
    let status: Int
    let primaryAction: () -> Void
    let secondaryAction: () -> Void

    func makeNSViewController(context: Context) -> ButtonHostingViewController {
        ButtonHostingViewController(status: status,
                                    primaryAction: primaryAction,
                                    secondaryAction: secondaryAction)
    }

    func updateNSViewController(_ nsViewController: ButtonHostingViewController, context: Context) {
        nsViewController.update(state: status)
    }
}

This is the SwiftUI view that wraps the AppKit controller, and handles passing the actions / state into the AppKit controller. Since this was build out as a test, right now I'm, just using an Int and the test code increments / decrements the value.

The next thing that came up was to get the up + down events from the gesture recoginzer, I needed to create a subclass that let me add events for mouse up / down events, as well an handling cancel events:

private class UpdatingGestureRecognizer: NSClickGestureRecognizer {
    var onMouseDown: (() -> Void)?
    var onMouseUp: (() -> Void)?

    override func reset() {
        super.reset()
        onMouseUp?()
    }

    override func mouseDown(with event: NSEvent) {
        super.mouseDown(with: event)
        if buttonMask == 0x1 {
            onMouseDown?()
        }
    }

    override func rightMouseDown(with event: NSEvent) {
        super.rightMouseDown(with: event)
        if buttonMask == 0x2 {
            onMouseDown?()
        }
    }
}

Finally, I had to create the view controller that wraps the SwiftUI view and adds the gesture recognizers. To pass data from UIKit into SwiftUI, I created an ObservableObject that the ViewController owns and passes into the SwiftUI view, which keeps the UIKit and SwiftUI states in sync.

final class ButtonHostingViewController: NSHostingController<ButtonHostingViewController.Body> {
    class ViewModel: ObservableObject {
        @Published var status: Int = 0
        @Published var isPrimaryDown = false
        @Published var isSecondaryDown = false

        var isButtonDown: Bool {
            isPrimaryDown || isSecondaryDown
        }
    }

    struct Body: View {
        @ObservedObject var viewModel: ViewModel

        var body: some View {
            Text(viewModel.status, format: .number)
                .opacity(viewModel.isButtonDown ? 0.3 : 1)
        }
    }

    private let viewModel = ViewModel()
    private let primaryAction: () -> Void
    private let secondaryAction: () -> Void

    private lazy var primaryGestureRecognizer: NSClickGestureRecognizer = {
        let primaryGestureRecognizer = UpdatingGestureRecognizer(target: self, action: #selector(primaryEvent))
        primaryGestureRecognizer.onMouseUp = { [viewModel] in
            viewModel.isPrimaryDown = false
        }
        primaryGestureRecognizer.onMouseDown = { [viewModel] in
            viewModel.isPrimaryDown = true
        }
        return primaryGestureRecognizer
    }()

    private lazy var secondaryGestureRecognizer: NSClickGestureRecognizer = {
        let secondaryGestureRecognizer = UpdatingGestureRecognizer(target: self, action: #selector(secondaryEvent))
        secondaryGestureRecognizer.onMouseUp = { [viewModel] in
            viewModel.isSecondaryDown = false
        }
        secondaryGestureRecognizer.onMouseDown = { [viewModel] in
            viewModel.isSecondaryDown = true
        }
        secondaryGestureRecognizer.buttonMask = 0x2
        return secondaryGestureRecognizer
    }()

    init(status: Int,
         primaryAction: @escaping () -> Void,
         secondaryAction: @escaping () -> Void) {
        self.primaryAction = primaryAction
        self.secondaryAction = secondaryAction
        super.init(rootView: Body(viewModel: viewModel))
        view.addGestureRecognizer(primaryGestureRecognizer)
        view.addGestureRecognizer(secondaryGestureRecognizer)
    }

    @MainActor required dynamic init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    func update(state: Int) {
        viewModel.status = state
    }

    @objc private func primaryEvent() -> Void {
        primaryAction()
    }

    @objc private func secondaryEvent() -> Void {
        secondaryAction()
    }
}

It's more verbose than I'd like, and this particular version tightly couples the button wrapper and the content, but it should work and it will be interesting to see if there's a performance hit on larger boards.

Part of why I implemented this is that I'm not running the macOS Ventura betas on my Mac yet, I'm holding out for the public betas, so I don't have a place to run the Mac build of Minesweeper quite yet. I'm interested in putting this together with my other code when I get a chance.

I've done enough UI development to be able to test out the rules, but I'm going to just ignore that for now. Since I've built Minesweeper a handful of times now, I had a decent place to start from. This requires:

• A GridPoint struct to allow for addressing points on the grid
• A Game struct that tracks all of the game state and allows the gameplay actions
• Enums that report the state of the game (active, win, lose), and the possible states that each grid point can occupy.

The interfaces for all of that are:

struct GridPoint: Hashable, Identifiable {
    var id: GridPoint { self }

    let x: Int
    let y: Int
}

struct Game {
    var state: GameState { get }
    var elapsedTime: TimeInterval { get }
    var remainingMines: Int { get }

    init(width: Int, height: Int, mineCount: Int)

    subscript(_ gridPoint: GridPoint) -> Game.SpaceState { get }

    mutating func reveal(_ gridPoint: GridPoint)
    mutating func revealSurroundingIfSafe(_ gridPoint: GridPoint)
    mutating func toggleFlag(_ gridPoint: GridPoint)
}

extension Game {
    enum State {
        case active
        case win
        case lose
    }
}

extension Game {
    enum SpaceState {
        case unrevealed
        case revealed(Int)
        case flagged
        case revealedMine
        case flaggedMine
        case incorrectFlag
        case unrevealedMine
    }
}

One interesting detail to note is that the SpaceState includes both the states used for when the game is active, and when the game has been won or lost.

The Game struct is also used to only allow valid moves. Hence why subscript is read only, and then there are flag and reveal functions instead of allowing the game board direct write access to the game data. The data included in the Game struct is:

struct Game {}
    private let width: Int
    private let height: Int
    private let mineCount: Int
    private let startDate = Date()
    private var endDate: Date?
    private (set) var state: State = .active

    private var board: [GridPoint: Space]?
    private var flagged = Set<GridPoint>()
    private var mines = Set<GridPoint>()
    private var revealed = Set<GridPoint>()
}

private extension Game {
    enum Space {
        case mine
        case empty(Int)
    }
}

The board is an optional var, because in Minesweeper the first move should never be a mine. That can be accomplished in different ways. I went with the relatively simple option of removing the first revealed tile from the list of tiles that are allowed to hold mines. It also means that the board isn't created until the user reveals a square, event if they flag squares first.

I've decided on using a Dictionary to store the grid points because in previous iterations I've used nested arrays, and have managed to write bugs related to grid / column lookup. To isolate out all of the code related to creating the board, it's implemented as extensions on Dictionary, including the initializer that takes all of the values and uses that to populate the grid. One thing that made me really happy in the implementation was that I could use some Collection<GridPoint> for the helper functions and not need to convert from ArraySlice to Array in the init.

private extension Dictionary where Key == GridPoint, Value == Game.Space {
    init(width: Int, height: Int, mineCount: Int, initialMove: GridPoint) {
        let allGridPoints = Set<GridPoint>(width: 0..<width, height: 0..<height)
        var board = [GridPoint: Game.Space](minimumCapacity: width * height)
        board.setMines(allGridPoints.subtracting([initialMove]).shuffled().prefix(mineCount))
        board.calculateCounts(allGridPoints)
        self = board
    }

    mutating private func setMines(_ mineGridPoints: some Collection<GridPoint>) {
        for index in mineGridPoints {
            self[index] = .mine
        }
    }

    mutating private func calculateCounts(_ gridPoints: some Collection<GridPoint>) {
        for index in gridPoints {
            switch self[index] {
            case .mine: break
            case .empty, .none:
                self[index] = .empty(emptyCount(index))
            }
        }
    }

    private func emptyCount(_ gridPoint: GridPoint) -> Int {
        gridPoint.surroundingGridPoints.filter { index in
            switch self[index] {
            case .empty, .none: return false
            case .mine: return true
            }
        }.count
    }
}

The last function of interest is the reveal function on the Game, since it also handles calculating the win / loss state.

It enforces that:

• Only unrevealed, unflagged points can be revealed
• If the board doesn't exist, create it
• Only reveal points that already exist on the board, every valid tile is populated when the board is created. This lets us not worry about overflowing the board when revealing surrounding tiles when a point with zero adjacent mines is revealed.
• Reveal the point
• If the revealed tile has zero adjacent mines, reveal all tiles surrounding this tile
• If a tile containing a mine is revealed, end the game in failure
• Otherwise, end the game is the number of revealed tiles equals the number of tiles on the board minus the mine count

extension Game {
    mutating func reveal(_ gridPoint: GridPoint) {
        guard !flagged.contains(gridPoint), !revealed.contains(gridPoint) else { return }
        createBoardIfNeeded(initialMove: gridPoint)
        guard board?[gridPoint] != nil else { return }
        revealed.insert(gridPoint)
        if case .empty(let count) = board?[gridPoint], count == 0 {
            for surroundingIndex in gridPoint.surroundingGridPoints {
                reveal(surroundingIndex)
            }
        }
        if mines.isDisjoint(with: revealed) {
            if revealed.count == (width * height) - mineCount {
                endDate = Date()
                state = .win
            }
        } else {
            endDate = Date()
            state = .lose
        }
    }
}

There's a lot more going on in this struct to drive the rules of the game, so for anyone interested in taking a look at all of the code:

import Foundation

struct Game {
    private let width: Int
    private let height: Int
    private let mineCount: Int
    private let startDate = Date()
    private var endDate: Date?
    private (set) var state: State = .active

    private var board: [GridPoint: Space]?
    private var flagged = Set<GridPoint>()
    private var mines = Set<GridPoint>()
    private var revealed = Set<GridPoint>()

    var elapsedTime: TimeInterval {
        (endDate ?? Date()).timeIntervalSince(startDate)
    }

    var remainingMines: Int {
        mineCount - flagged.count
    }

    init(width: Int, height: Int, mineCount: Int) {
        self.width = width
        self.height = height
        self.mineCount = mineCount
    }

    subscript(_ gridPoint: GridPoint) -> SpaceState {
        switch board?[gridPoint] {
        case .none:
            return .unrevealed
        case .mine:
            return mineState(gridPoint)
        case .empty(let count):
            return emptyState(gridPoint, count: count)
        }
    }

    mutating func reveal(_ gridPoint: GridPoint) {
        guard !flagged.contains(gridPoint), !revealed.contains(gridPoint) else { return }
        createBoardIfNeeded(initialMove: gridPoint)
        guard board?.keys.contains(gridPoint) == true else { return }
        revealed.insert(gridPoint)
        if case .empty(let count) = board?[gridPoint], count == 0 {
            for surroundingIndex in gridPoint.surroundingGridPoints {
                reveal(surroundingIndex)
            }
        }
        if mines.isDisjoint(with: revealed) {
            if revealed.count == (width * height) - mineCount {
                endDate = Date()
                state = .win
            }
        } else {
            endDate = Date()
            state = .lose
        }
    }

    mutating func revealSurroundingIfSafe(_ gridPoint: GridPoint) {
        guard revealed.contains(gridPoint),
              case .empty(let mines) = board?[gridPoint]
        else { return }
        let surroundingGridPoints = gridPoint.surroundingGridPoints
        guard surroundingGridPoints.intersection(flagged).count == mines else { return }
        for gridPoint in surroundingGridPoints.subtracting(flagged) {
            reveal(gridPoint)
        }
    }

    mutating func toggleFlag(_ gridPoint: GridPoint) {
        guard !revealed.contains(gridPoint) else { return }
        flagged.formSymmetricDifference([gridPoint])
    }
}

// MARK: - Private functions
private extension Game {
    func mineState(_ gridPoint: GridPoint) -> SpaceState {
        if revealed.contains(gridPoint) {
            return .revealedMine
        } else {
            switch state {
            case .lose, .win:
                if flagged.contains(gridPoint) {
                    return .flaggedMine
                } else {
                    return .unrevealedMine
                }
            case .active:
                if flagged.contains(gridPoint) {
                    return .flagged
                } else {
                    return .unrevealed
                }
            }
        }
    }

    func emptyState(_ gridPoint: GridPoint, count: Int) -> SpaceState {
        if revealed.contains(gridPoint) {
            return .revealed(count)
        } else if flagged.contains(gridPoint) {
            switch state {
            case .win, .lose:
                return .incorrectFlag
            case .active:
                return .flagged
            }
        } else {
            return .unrevealed
        }
    }

    private mutating func createBoardIfNeeded(initialMove: GridPoint) {
        guard board == nil else { return }
        self.board = [GridPoint: Game.Space](width: width,
                                             height: height,
                                             mineCount: mineCount,
                                             initialMove: initialMove)
        mines = board?.mineGridPoints ?? []
    }
}

// MARK: - Space Values
private extension Game {
    enum Space {
        case mine
        case empty(Int)
    }
}

// MARK: - Convenience inits for sets of GridPoints
private extension Set where Element == GridPoint {
    init(width: Range<Int>, height: Range<Int>) {
        self = width.reduce(into: Set<GridPoint>()) { grid, col in
            let column = height.reduce(into: Set<GridPoint>()) { column, row in
                column.insert(GridPoint(x: col, y: row))
            }
            grid.formUnion(column)
        }
    }

    init(width: ClosedRange<Int>, height: ClosedRange<Int>) {
        self = width.reduce(into: Set<GridPoint>()) { grid, col in
            let column = height.reduce(into: Set<GridPoint>()) { column, row in
                column.insert(GridPoint(x: col, y: row))
            }
            grid.formUnion(column)
        }
    }
}

// MARK: - Dictionary helpers
private extension Dictionary where Key == GridPoint, Value == Game.Space {
    init(width: Int, height: Int, mineCount: Int, initialMove: GridPoint) {
        let allGridPoints = Set<GridPoint>(width: 0..<width, height: 0..<height)
        var board = [GridPoint: Game.Space](minimumCapacity: width * height)
        board.setMines(allGridPoints.subtracting([initialMove]).shuffled().prefix(mineCount))
        board.calculateCounts(allGridPoints)
        self = board
    }

    mutating private func setMines(_ mineGridPoints: some Collection<GridPoint>) {
        for index in mineGridPoints {
            self[index] = .mine
        }
    }

    mutating private func calculateCounts(_ gridPoints: some Collection<GridPoint>) {
        for index in gridPoints {
            switch self[index] {
            case .mine: break
            case .empty, .none:
                self[index] = .empty(emptyCount(index))
            }
        }
    }

    private func emptyCount(_ gridPoint: GridPoint) -> Int {
        gridPoint.surroundingGridPoints.filter { index in
            switch self[index] {
            case .empty, .none: return false
            case .mine: return true
            }
        }.count
    }

    var mineGridPoints: Set<GridPoint> {
        let gridPoints = self.filter { _, value in
            switch value {
            case .empty: return false
            case .mine: return true
            }
        }.keys
        return Set(gridPoints)
    }
}

private extension GridPoint {
    var surroundingGridPoints: Set<GridPoint> {
        let minColumn = x - 1
        let maxColumn = x + 1
        let minRow = y - 1
        let maxRow = y + 1
        var surroundingGridPoints = Set<GridPoint>(
            width: minColumn...maxColumn,
            height: minRow...maxRow)
        surroundingGridPoints.remove(self)
        return surroundingGridPoints
    }
}

One of my first things I built when learning SwiftUI was an implementation of Minesweeper. I've done a major refactor of the game every year as more SwiftUI features have been added, and I've learned more about working in SwiftUI.

I'm starting the process again this year, and as I complete the implementation I'll write blog posts covering any interesting points that I've learned.

My goal for features this year is:

• Use the new Multiplatform app design and support iPad + Mac
• Settings and high scores persisted via AppStorage
• Minesweeper gameplay including
  • Revealing mines
  • Flagging mines
  • Revealing all of the mines if the user taps a numbered square

Out of the list, the one that is the most fiddly is flagging mines, because SwiftUI doesn't natively support two finger taps or right clicks. I've worked around that in the past by supporting option click, but I'll take another swing at improving it.

I have what I think is a good version of the data model for the game board itself set up, so I'll make an attempt to refine that as well but I don't need to build that from the ground up.

On the long list of interesting new things to check out from WWDC this year, the first one that I wanted to take a look at was the new NavigationStack, as the limitations in the previous NavigationView led to my previous project using UIKit to back navigation in a SwiftUI first project.

After a couple minutes playing around with the docs, I came up with:

A root view:

struct NewNavigationView: View {
    private let numbers = [1, 2, 3]
    private let strings = ["a", "b", "c"]
    @State private var navigationPath = NavigationPath()

    var body: some View {
        NavigationStack(path: $navigationPath) {
            List {
                Section("Numbers") {
                    ForEach(numbers, id: \.self) {
                        NavigationLink("\($0)", value: $0)
                    }
                }
                Section("Strings") {
                    ForEach(strings, id: \.self) {
                        NavigationLink($0, value: $0)
                    }
                }
            }
            .navigationDestination(for: Int.self) { int in
                NumberView(selection: int, navigationPath: $navigationPath)
            }
            .navigationDestination(for: String.self) { string in
                StringView(selection: string, navigationPath: $navigationPath)
            }
            .navigationTitle("Root")
        }
    }
}

A view that displays details for a number:

struct NumberView: View{
    private let numbers = [1, 2, 3, 4, 5]
    let selection: Int
    @Binding var navigationPath: NavigationPath

    var body: some View {
        List {
            Section("Numbers") {
                ForEach(numbers, id: \.self) {
                    NavigationLink("\($0)", value: $0)
                }
            }
            Button("Pop to root") {
                navigationPath = NavigationPath()
            }
        }
        .navigationTitle("Detail \(selection)")
    }
}

And a view that displays details for a string:

struct StringView: View {
    private let strings = ["a", "b", "c", "d", "e"]
    let selection: String
    @Binding var navigationPath: NavigationPath

    var body: some View {
        List {
            Section("Strings") {
                ForEach(strings, id: \.self) {
                    NavigationLink("\($0)", value: $0)
                }
            }
            Button("Pop to root") {
                navigationPath = NavigationPath()
            }
        }
        .navigationTitle("Detail \(selection)")
    }
}

With just this code, I could:

• Keep pushing new views to the stack from the inner navigation links
• Pop to the root of the stack from within any view

It's particularly nice that you only need to add the navigationDestination modifiers at the top level of the navigation hierarchy and any child views that have a navigation link will find that destination and use it to push onto the stack.

The only caveat that I ran into in my experimenting is that if you add a second navigationDestination for the same type that another destination has claimed on a child node inside the NavigationStack it's undefined behavior and so things break in interesting ways.

My personal ritual every WWDC is to try to watch as many session videos as I can, with a focus on having a general list of interesting things to do more research into later. This approach has been a lot easier in the online-first WWDC format, because there have been more videos, but they're shorter and more focused, which makes it easier to focus on the things I'm most interested in.

This year I decided it's time to try to improve my miniature painting skills again and picked up entry level airbrushing gear, so I'll be attempting to paint a few kits while taking in WWDC sessions.

Drinking from the firehose

Since I'm trying to be as broad as possible, my strategy is to favorite all of the session videos from WWDC, and then attack them with a bit of a strategy:

• Keynote & Platforms State of the Union
• What's new in…
• New tooling and language features
• Videos about SwiftUI
• Videos about iOS development
• Anything else as it catches my eye

That list is just a general guideline, if something looks interesting I'll watch it. Last year I managed to watch somewhere between 1/2 and 2/3 of the session videos, and picked up some really useful details. I'm hoping to do hit a similar ratio by the end of summer, and I'll post about anything interesting that I find.

So after far too long, I've managed to rebuild my blog in a format I'm at least sort of happy with, and am ready to start posting again.

The site is now built using:

• Hugo with a custom theme for generating the content.
• Tailwind for all of the styling.
• GitHub Pages is hosting the content.
• Google Fonts serving the fonts.
• Font Awesome for SVG icons.