Post-WWDC 2025 Recap: Everything-ish you need to know

A presentation I gave in our local monday.com meetup about some highlights from WWDC 2025.

Transcript

1. Everything !"# you need to know -ish
2. Sta! iOS Engineer @ monday.com Open Source ❤ Hackathon fan and winner of some International Speaker About Me @freak4pc
3. Author & Editor of Several Books and Publications about Swift & iOS @freak4pc About Me
4. Disclaimer This is supposed to be an eagle’s-eye view of things I personally find important and cool to know There is wayyyy too much content to cover in-depth in a single presentation, so check out the sessions! %
5. Before we get into the tech stuff, Let’s get it out of the way…
7. Liquid Glass Liquid Glass is the most drastic UI shift from Apple since iOS 7’s Flat Design All system components have been migrated to glass, and you can migrate your custom components SwiftUI glassEffect() UIKit UIGlassEffect()
8. Liquid Glass Migrating is expected to take a while, so Apple have provided an opt-out feature Simply set UIDesignRequiresCompatibility to YES in your Info.plist, and all Glass Effect is gone. Note: Apple claims this will only work for Xcode 26, which gives us about a year to migrate UIDesignRequiresCompatibility = NO UIDesignRequiresCompatibility = YES
9. Xcode
10. Multiple Semantic Word Search
11. #Playground macro Like #Preview But for non-UI code (Think Jupyter Notebook, If you’re a Python/AI Person)
12. #Playground macro
13. Icon Composer & Glass Icons In iOS 26, App Icons change their appearance based on the movement of the device, applying a dynamic light source There’s also a new “Glass” style
14. Icon Composer & Glass Icons A tool to create a unified .icon format that works for all appearances & tints Simply drag & drop into your app, and you’re good to go
15. Icon Composer & Glass Icons
16. Apple Intelligence We didn’t get a ton of AI features, But Xcode gets its own “Cursor-like” AI Coding Assistant Comes built-in with ChatGPT Free Limits P.S. macOS Tahoe and up only &
17. Apple Intelligence Auto “fix it” suggestions based on Apple Intelligence, and refactor tools
18. Apple Intelligence We can also ask for fully-fledged views/pieces of code
19. Apple Intelligence
20. Apple Intelligence Unfortunately, it’s still not all great The editing capabilities are still limited, there is no updates knowledge and no real RAG We can only hope for great updates coming in upcoming Xcode 26 betas &'
21. Apple Intelligence
22. Apple Intelligence
23. Apple Intelligence P.S. You can connect your own Anthropic Claude account which highly improves the answers, but still not the general abilities of the editor
24. Apple Intelligence P.S. You can connect your own Anthropic Claude account which highly improves the answers, but still not the general abilities of the editor
25. Swift Concurrency Debugging Debugging of asynchronous functions is much more stable, and let’s you step into async functions, and exposes each Task in the inspector as if it was a thread (
26. Swift Concurrency Debugging We can also give names to detached tasks, and they’ll show up during debugging in the inspector & breakpoint itself
27. Swift Concurrency Debugging Generally, Swift’s understanding of the Concurrency-centric model is much stronger, which also includes some new LLDB commands to debug current task contexts
28. Capability Improvements When missing private resource description, we finally won’t crash with random warnings, but get an actual actionable error You can also directly add the missing description, without having to fiddle with plist files!
29. Capability Improvements Which brings another great improvements - these messages are now regular capabilities in Xcode, so-long manual Info.plist editing!
30. Capability Improvements Which brings another great improvements - these messages are now regular capabilities in Xcode, so-long manual Info.plist editing!
31. SwiftUI Instrumentation There’s a new SwiftUI Instrument (works only on device) which helps us track amount of updates and render passes in our views easily
32. SwiftUI Instrumentation There’s a new SwiftUI Instrument (works only on device) which helps us track amount of updates and render passes in our views easily
33. SwiftUI Instrumentation If you want to dig in to a single issue, you can switch to the Cause and Effect graph which can show you what causes excessive renders
34. Explicit Build Modules Explicit build modules are now on for all builds by default. Before, code and modules were built on the fly as the build system discovered them. Now, the build system creates a full graph and is aware of each module - able to better plan and coordinate the build process Build Modules Build Source Scan
35. Explicit Build Modules This joins another happy occasion - Apple open sourced its build system, and will move to a unified build system for Xcode, SPM & More This is an awesome step for using IDE(s) as well with great build speed (Hello cursor )) https://github.com/swiftlang/swift-build !
36. UI Testing Improvements UI Test Recording is better than ever. Simply press record, navigate through your app, and the UI Test will “write itself”
37. UI Testing Improvements And you can use the improved Recording Inspector to track issue and see a step-by- step run of your test on failure
38. Swift
39. Pre-Built Swift-Syntax! A huge pain point of Swift Macros was the expensive build time, which could add minutes to an app’s build process Starting with Swift 6.2, swift-syntax is available as a prebuilt dependency, which eliminates this build step and speeds things up substantially!
40. Pre-Built Swift-Syntax! A huge pain point of Swift Macros was the expensive build time, which could add minutes to an app’s build process Starting with Swift 6.2, swift-syntax is available as a prebuilt dependency, which eliminates this build step and speeds things up substantially!
41. Improved Debugging Performance Remember Explicit Build Modules? Now that modules are pre-defined, Xcode and the Debugger itself (LLDB) reuse the same modules, which makes debugging substantially more stable, and faster, too!
42. Strictly-typed notification payloads Starting with Swift 6.2, NotificationCenter notifications finally have type-safe, actor-safe variants, so no more need to cast random keys into types
43. Strictly-typed notification payloads Starting with Swift 6.2, NotificationCenter notifications finally have type-safe, actor-safe variants, so no more need to cast random keys into types
44. Observations improvements A new type called Observations allows introducing a scope of computation which re-computed upon value changes (on an @Observable class)
45. Observations improvements Another cool thing is that Observations conforms to AsyncSequence, so you could observe these computations in real-time
46. Observations improvements This works great for UIKit too, and works automatically to invalidate and update the UI as state changes Best of all, it is back deployable to iOS 18!
47. Observations improvements Unfortunately, as of Xcode 26 beta 2, it’s still not available &' It won’t surprise me if syntax or capabilities change, so stay tuned …
48. Raw Identifiers You can now basically create whatever identifiers you want as long as they’re wrapped in backticks (`) This is kinda icky (IMO), but useful for tests and other narrow use cases. From the bottom of my heart, please don’t abuse this &
49. Fixed-sized array A new InlineArray allows for creating more efficient arrays limited to a specific amount of items Since the array has a fixed type, you can’t use append, remove, etc on them, but you can mutate them in-place (specific index) Unlike a regular Array - it doesn’t conform to Sequence/Collection, so you must iterate over it by its indices
50. Testing for Fatality ☠ Swift Testing got a lot of shiny updates this year, but a long-requested one is the ability to assert if a piece of code could cause a process exist * Unfortunately only available on macOS, Linux and Windows
51. Concurrency Changes & Updates There are a lot …
52. Concurrency Changes & Updates Concurrency is about where and when work executes
53. Concurrency Changes & Updates Swift shifted its concurrency vision towards a world where adoption becomes a more gradual process 1. Start with sequential, single-threaded code 2. Write asynchronous code without any data-race issues 3. Introduce parallelism to improve performance This is aimed to make Swift more approachable for engineers, and lets you introduce complexity just as you need it as a developer / team https://github.com/swiftlang/swift-evolution/blob/main/visions/approachable-concurrency.md Vision document:
54. Concurrency Changes & Updates Apple introduced a new opt-in Approachable Concurrency model which follows this approach, and starts off with all code running on a single thread, letting you introduce parallelism and concurrency when you need it
55. Concurrency Changes & Updates With Approachable Concurrency, async functions will continue running from the actor they were called from, instead of offloading to a different actor
56. Concurrency Changes & Updates With Approachable Concurrency, async functions will continue running from the actor they were called from, instead of offloading to a different actor doImportantWork runs on same actor as doViewModelyStuff
57. Concurrency Changes & Updates To introduce parallelism, you can annotate your work/ method with @concurrent, to indicate Swift should offload work to a background thread / actor
58. Concurrency Changes & Updates To let the consumer of a method choose which actor it runs on, use nonisolated
59. Concurrency Changes & Updates It’s now possible to isolate your protocol conformances to a specific actor, using Isolated Conformance The conformance of ImageResizing will be isolated to the MainActor
60. Concurrency Changes & Updates You can also specify Default Actor Isolation to a specific actor, most notably - @MainActor. This is extremely helpful for most UI apps/ modules, as most code runs on that actor This is the default on new projects created with Xcode 26
61. Isolated deinit Deinitializers are notoriously known for being run in a “global actor” and not isolated to their containing type. With Swift 6.2, you can mark those as isolated to guarantee same- actor execution.
62. UIApplication lifecycle deprecation Usage of Scenes has been the recommended way to work for a while, but now Apple is officially deprecating many UIApplication-centric methods & delegate
63. UIKit Scene Bridging Which is part of the reason Apple lets us create SwiftUI Scenes in our existing UIKit, using the new UIHostingSceneDelegate protocol
64. UIKit Scene Bridging This finally opens up the opportunity to add an Immersive visionOS scene next to your standard-app scene
65. UIKit Scene Bridging Once it’s configured, simply set it as the delegateClass when your application scene is connecting
66. Concurrency Changes & Updates There are many other changes worth noting here, check out these two recommended sessions: https://developer.apple.com/videos/play/wwdc2025/266/ https://developer.apple.com/videos/play/wwdc2025/268/
67. SwiftUI
68. List Performance iOS 26 introduces a new UI scheduling mechanism which is supposed to provide significant Speed-ups to Lists, especially large one (up to 6x for loading and 16x for updates) Overall, you should expect a smoother scrolling experience and less dropped frames.
69. @Animatable macro The new @Animatable macro automatically makes all available properties of a Shape animatable, making custom shape animations super simple
70. Rich Text Editor TextEditor now supports binding to an AttributedString, providing you with a very capable built-in rich text editor @State private var text = try! AttributedString( markdown: """ Let's talk about some of the **changes** in rich text editing, which might be _helpful_ or ~nice~ in your day to day """ ) var body: some View { TextEditor(text: $text) }
71. WebView There’s a new SwiftUI-first WebView, that plays along with a WebPage which defines the loaded content and behavior TextEditor
72. WebView You can also provide custom configuration and navigation decider, similarly to WKWebView (which is probably wrapped under the hood)
73. Section Index Labels SwiftUI List(s) get the ability to add sectioned index labels using the new sectionIndexLabel modifier
74. Foundation Models
75. Foundation Models Foundation Models let you tap into Apple Intelligence from your own app and leverage the on-device models for your benefit Offline, local, free Erez will have a full session on this right after me, so not going to dive into it +
76. Shai Mishali freak4pc Thanks!