Snapp iOS Weekly

A reusable SwiftUI skill for coding agents is exactly the sort of thing that starts sounding optional, right up until the third generated view ships with stale onChange patterns and confused state ownership. Version 5.0.0 adds verified Xcode 27 and SDK 27 guidance, with focused references for layout, accessibility, animation, state, lists, toolbars, WebKit, and more. The nice part is the shape: a compact skill file that pulls in deeper notes only when relevant, instead of stuffing every rule into one giant prompt. Our codebase gets better results, and our context window does not become a landfill.

UI/UX

How SwiftUI animation works

OpenSwiftUI Project

SwiftUI animation is easy to use and weirdly easy to misunderstand, especially once “async” and Core Animation show up in the same conversation. This deep dive follows OpenSwiftUI’s iOS 18 animation model and makes the boundary clearer: SwiftUI samples animation values in the app process, then submits presentation updates; Core Animation still composites, but it is not necessarily owning the spring’s clock. That distinction matters when we’re chasing hitches in our apps. Don’t just blame “the animation” — trace state, graph updates, sampling, layer updates, and compositing like separate suspects.

Diagnosing ForEach performance issues in SwiftUI lazy containers

There’s a tiny launch argument here that deserves a spot in every SwiftUI performance debugging checklist: -LogForEachSlowPath YES. It catches ForEach content inside lazy containers when SwiftUI can’t know the number of views per element without evaluating offscreen rows, which is exactly the kind of invisible work that makes lists feel haunted. The fix is not always “wrap it in a VStack”; sometimes we should filter the collection before ForEach, and sometimes grouping is the right move because the element still exists. Small detail, big payoff. Our lists are only lazy if we stop making SwiftUI guess.

SPM

Managing Multi-Repository Enterprise iOS Ecosystems at Scale

Flaregun-dev

Large iOS codebases rarely stay neat, and this piece walks through the mess without pretending one repo strategy solves everything. Swift Package Manager is the center of gravity now, with private registries, binary XCFramework targets, CI tokens, automated version bumps, and the occasional Xcode workspace still doing useful work at the edges. The practical thread is consistency: exact versions, repeatable builds, shared compiler settings, and dependency updates that move through PRs instead of folklore. If our apps depend on a dozen internal libraries, “it builds on my machine” is not a process. It’s a warning sign.

Utils

Homebrew/BrewUI

Homebrew

BrewUI is Homebrew’s official macOS GUI, built in SwiftUI, and I’m happy it exists for a simple reason: not everyone wants package management to start in Terminal. The project is careful about transparency, showing what Homebrew is doing rather than turning installs and upgrades into a mystery button. It also has a very pragmatic environment model — clean zsh launch, explicit brew.env files, and a Configuration tab to explain what the app sees. A native SwiftUI app around a beloved command-line tool? That is a nice little macOS story, and maybe a useful reference for our own developer-facing utilities.

iOS Newsletter Issue 109

2026-09-11T00:00:00+00:00

Hi folks,

Swift keeps refusing to stay in the neat little Apple-platform box, and honestly, good.

This week we’ve got Swift on the web, SwiftUI picking up the boring-but-needed pieces we used to wrap ourselves, foldable iPhone prep landing in real developer checklists, and on-device foundation models doing actual app work instead of demo magic.

The thread is simple: our apps are being asked to stretch — across screens, runtimes, toolbars, tests, messages, and AI workflows — and the best tools here are the ones that delete ceremony without pretending the edge cases disappeared.

Articles

Swift

What’s new in Swift: August 2026 Edition

Simon Leeb, Dave Lester

Swift’s August roundup is very much a “look how far outside Xcode this language is wandering now” moment. Elementary and ElementaryUI push Swift deeper into web UI work, SwiftTUI brings state and animation ideas into terminal apps, and the Windows story keeps getting less theoretical. If our mental model of Swift is still mostly “the language we use for iOS screens,” this digest is a useful shove. The ecosystem is getting wider, messier, and more interesting — as it should.

UI / UX

iPhone Duo: First Developer Good-to-Knows

Jordan Morgan

The foldable iPhone conversation is no longer just gadget gossip; it’s a layout problem with a hinge in the middle of it. The useful bits here are practical: trust size classes over device assumptions, test asymmetric safe areas, let system containers manage bars, and don’t hide core features behind some cute folded pose. I like the warning baked into all of this — if our app only works because we guessed the shape of the device, we’re already late. Duo support sounds flashy, but most of the work is just honest adaptive design.

Adaptive SwiftUI toolbars in iOS 27

SwiftUI toolbars are getting a vocabulary for the thing we’ve all been faking: what matters when space runs out. visibilityPriority, ToolbarOverflowMenu, pinned trailing items, and minimization behavior give us knobs instead of hoping the framework guesses our hierarchy of actions correctly. That matters more now with resizable windows, search taking over chrome, and devices that may change shape mid-session. Who doesn’t like deleting a weird custom “more” button and letting the system carry the overflow story properly?

SwiftUI has a native WebView in iOS 26

Sarun W.

The little UIViewRepresentable WebView wrapper we’ve all copied between projects can start packing its bags. iOS 26 gives SwiftUI a native WebView, and WebPage covers the bits real apps need: title, loading state, progress, history, secure-content state, and async JavaScript. The catch is small but easy to miss — import both SwiftUI and WebKit, because this arrives through a cross-import overlay. Keep the old wrapper for older deployment targets, sure, but new code gets pleasantly boring here.

Testing

Swift Testing explained with code examples

Swift Testing is settling in as the default path, and the migration story is getting clearer: @Test, #expect, #require, parameterized tests, attachments, and exit tests where the platform allows them. The big win is not just fewer assertion names to remember; failure output is closer to the expression we actually wrote, which helps when CI is yelling and coffee has not kicked in yet. XCTest still has a place for UI automation and performance work, so no need for a dramatic rewrite. But for most unit tests in our codebase, the modern shape is hard to argue against.

Utils

SQLiteData

PointFree.co

SQLiteData feels like SwiftData for teams who still want the database to be real. You get familiar wrappers like @Table, @FetchAll, and @FetchOne, but underneath it’s SQLite, GRDB, type-safe queries, and CloudKit sync without pretending schema design doesn’t exist. I like that tradeoff: a little more upfront database thinking, a lot more control when our apps grow past the toy phase.

Video

043 - RCS

Lucas Fischer

RCS has been easy to ignore if most of your world lives inside iMessage, but cross-platform messaging is finally less awful on iPhone. The real-world test here — texting friends in Germany for a month and checking whether it stayed free — is more useful than another feature checklist. iOS 26 adding end-to-end encryption makes the story feel less like a grudging compatibility layer and more like something users may actually trust. Not glamorous, no, but our apps live in the same user expectations soup as Messages does.

Building a Plant Identifier with Foundation Models

Mohammad Azam

A plant identifier is a nice excuse to see Foundation Models image attachments doing something concrete: pass an image, generate a structured plant name, then keep the conversation going with follow-up questions. The smart part is not re-analyzing the image every time; caching the identified plant keeps the UX from feeling like it is paying the same expensive bill again and again. There are rough edges, including model weirdness and real-device requirements on iOS 27, but that’s useful honesty. This is the kind of AI demo that maps cleanly to our own apps: identify once, ask many times, stream the answer when it gets longer.

iOS Newsletter Issue 108

2026-09-04T00:00:00+00:00

Hi folks,

We’ve got a very “system edges are getting interesting again” issue this week. App Intents are moving from cute demos into actual routes through Spotlight, Siri, and our app data. Swift Charts keeps proving it can do the weird product-polish stuff if we’re willing to understand the marks. And off to the side, Swift on Wasm, local AI engines, and SwiftUI in Final Cut Pro are all quietly saying the same thing: Swift is leaking into more places than our old mental model allowed.

Enjoy!

Articles

Swift

Swift for Wasm August 2026 Updates

Max Desiatov

Swift for WebAssembly had one of those months where the changelog looks small until you notice the shape of it: WasmKit running a WASI guest and GDB stub on an ESP32, BridgeJS getting cleaner module imports and generic imported functions, ElementaryUI tightening up its SwiftPM/Vite story. That’s not “hello world in the browser” territory anymore. It’s Swift being pushed into edge workers, embedded targets, and frontend experiments with fewer apologies. Still rough in places, sure, but if our idea of Swift stops at apps and server binaries, we’re missing where the interesting pressure is building.

AI/ML

Building AI features using Foundation Models. Multimodal input.

Foundation Models get much more real once the prompt can include an image, and the plate-scanner example makes the point without overcooking it. Define a Generable result type, pass instructions plus an Attachment into LanguageModelSession, and get structured output back that the UI can actually use. No giant cloud pipeline, no “AI strategy” meeting, just a feature-sized loop: image in, typed result out. That’s the kind of AI API surface I want in our apps — small enough to trust, useful enough to ship.

UI/UX

Teaching Siri to talk about your favorite walks in Walk Mate

A practical walk through making Siri understand app data, not just launch a shortcut and wave vaguely at the app. Walk Mate’s favorite routes become App Entities with readable properties, Spotlight indexing, Shortcuts search, and a Maps handoff, which is exactly the kind of plumbing our apps need if we want Apple Intelligence to feel useful instead of decorative. I like how grounded this is: one saved walk, one name Siri can say, one route that opens where the user expects. App Intents can get abstract fast; this keeps the work close to something a person would actually ask for.

Making app entities available in Spotlight

Apple Documentation

Apple’s guide lays out the official path for getting AppEntity types into Spotlight, with IndexedEntity doing a lot of the connective work. The big bit for our codebase is that Spotlight is no longer just a bag of searchable strings; it can carry structured app entities that Siri and other system experiences can reason about. That means the boring indexing layer suddenly matters a lot more. If our app has user-created objects, saved places, documents, workouts, recipes, whatever, this is the place to start making them visible to the system.

Building a sunburst diagram in Swift Charts

Swift Charts can build a proper sunburst diagram, but the fun is in the details: SectorMark rings, radius ratios, angular insets, grouped data layout, and accessibility labels that don’t get treated as an afterthought. The result is a multi-level donut chart where the outer rings still line up with their parent categories, which sounds simple until you try to fake it by hand. Who doesn’t like a chart that looks custom without becoming a pile of custom drawing code? This is a good reminder that Charts has more range than the usual bar-and-line dashboard screenshots suggest.

Area chart with a dimming layer up to the current point in time

A nice little Swift Charts recipe inspired by the iOS Weather UV chart: gradient area, matching line, current-time marker, and a dimming layer over the part of the day that has already passed. The technique is useful because it’s not just prettier data, it tells the user what’s behind them and what’s still ahead at a glance. Our apps often need exactly this kind of visual hint, the small layer that makes a chart feel alive instead of pasted in. Bonus points for keeping accessibility in the conversation when the area and line represent the same data.

093 - SwiftUI in FCP

Lucas Fischer

SwiftUI views rendered as Final Cut Pro effects is the sort of sentence that makes you stop and check you read it right. Using SwiftUIFX, the experiment builds SwiftUI components and renders them frame by frame onto video footage, which is not the usual plugin path most of us have in our heads. It’s scrappy and exploratory in the best way. Even if our day job never touches Final Cut Pro, seeing SwiftUI escape the app window is a healthy reminder that our UI tools are more portable than we tend to assume.

Utils

NobodyWho

NobodyWho is pitching local AI inference across devices, with text, vision, speech-to-text, and text-to-speech models loaded from places like Hugging Face and called from Swift, React Native, Kotlin, Dart, Python, and more. The Swift sample is refreshingly direct: load a GGUF model, ask it something, await the completed response. For mobile teams, the appeal is obvious — private, offline-capable AI features without sending every user interaction across the network. Of course we still need to care about model size, latency, and battery, but this is the kind of tool that makes local-first AI feel less like a research project.

iOS Newsletter Issue 107

2026-08-28T00:00:00+00:00

Hi folks,

This week’s issue is about giving the system more useful ways into our apps without giving up control of the hard parts. We have Swift’s newly unified documentation, a pragmatic App Intents baseline for Siri and Spotlight, custom on-device models with Core AI, and the less glamorous work of background scheduling and EventKit permissions. Then we get properly hands-on: non-destructive Photo Editing extensions, an accessible Swift Charts calendar, and a few Xcode shortcuts that make routine refactoring just annoying enough less.

We hope you like it!

Articles

Swift

Swift’s New Documentation Site

Joseph Heck

Swift finally has one hosted home for The Swift Programming Language, standard library APIs, Swift Testing, toolchain material, and platform guidance, built nightly with DocC. The useful bit is the split between latest release documentation and main development docs, with real versioning and a switcher still being worked out; Foundation is notably missing for now.

AI/ML

Run Custom Models On Device With Core AI

Trevor Whittingham

Core AI fills the awkward space between Apple’s Foundation Models and traditional Core ML: bring a task-specific model, convert it to .aimodel, and keep inference on device. The architecture advice is the real keeper—compose small vision and language models, hide tensor plumbing behind narrow types, and treat download plus first-run specialization as product states rather than surprising the user with a spinner.

UI/UX

App Intents for iOS 27: The Indie Playbook for the New Siri and Spotlight

Aurélien Weiss

App Intents are not some magical replacement for ASO, and treating them that way misses the point. For most indie apps, one open intent, one search intent, and one create intent behind an AppShortcutsProvider is enough to make the app genuinely usable from Siri, Spotlight, and Shortcuts—small work with a surprisingly broad system footprint.

Background tasks in SwiftUI

SwiftUI’s backgroundTask modifier makes BGTaskScheduler feel far less bolted on, especially now that handlers can use async/await and cooperative cancellation. The system still decides when work runs, though, so schedule from lifecycle transitions, use background URLSession for long transfers, and learn the debugger commands that simulate launch and expiration—or enjoy waiting indefinitely for iOS to cooperate.

Photo Extensions

Sam Davies

Photo Editing extensions are a neat example of designing for non-destructive work: render a display-sized preview, persist the recipe as PHAdjustmentData, then apply it to the full-resolution asset only when the user commits. The old APIs show their age, but the constraints have not—share code carefully with the container app, avoid wasteful image buffers, and assume memory pressure will expose every lazy choice.

Developing iOS Apps with EventKit and Calendar Integration

Arthur C.

EventKit integration is mostly straightforward CRUD until permissions, recurrence, multiple calendars, and outside changes enter the room. A long-lived EKEventStore, explicit authorization handling, stable event identifiers, and observation of EKEventStoreChanged turn the usual pile of snippets into something our codebase can actually rely on.

Building an accessible calendar chart with Swift Charts

A calendar heat map looks simple until dates from later weeks form a staircase and VoiceOver groups every Monday into one inaccessible column. Normalizing weekdays into a reference week fixes the geometry; replacing the plot’s accessibility children with a matching synthetic grid restores day-by-day navigation and month headings without throwing away Swift Charts’ date-based model.

Tips

Xcode Key Bindings to Make Refactoring Less Painful

Alexander Sandberg, Dave Lester

Xcode refactoring is unreliable enough that digging through its menus trains us to stop trying. Binding Rename, Extract All Occurrences, and Extract to Method to memorable shortcuts flips that cost: try instantly, move on instantly if Xcode says no, and stay in flow on the rare happy path when it works.

iOS Newsletter Issue 106

2026-08-21T00:00:00+00:00

Hello again.

Package infrastructure, hybrid AI, critical thinking, launch profiling, adaptive layout, testable navigation, and even custom operators all land in this issue. The common thread is control: knowing where SwiftPM gets its code, choosing deliberately between Apple Foundation Models and Gemini, checking what AI produces, measuring launch work instead of guessing, and keeping SwiftUI decisions small enough to test. There’s also a focused skill for Liquid Glass—useful, provided we treat agent instructions like code rather than magic.

Have fun!

Articles

Swift

What is a package registry?

— Dave Verwer

SwiftPM resolves dependencies, the Swift Package Index helps us find them, but a package registry does the less glamorous job of serving verified, immutable source archives. That distinction matters once our builds need more than a Git URL and crossed fingers—and the nice part is we can try a registry today rather than waiting for the ecosystem to catch up.

Custom Operators in Swift

— Wesley de Groot

Custom operators can make a mathematical type or domain-specific language feel wonderfully natural, right up until nobody else can read the code. The useful bit here is the mechanics—prefix, postfix, infix, precedence groups, assignment, pattern matching, and function composition—paired with the reminder I’d enforce in review: if a named function is clearer, use the named function.

AI/ML

Apple Foundation Models: Hybrid AI with Dynamic Profiles

— Peter Friese

On-device Apple Foundation Models are private and free, but an 8K context window, limited reasoning, and mobile thermals are real constraints, not footnotes. Dynamic Profiles make the hybrid approach clean: count tokens up front, keep suitable work on device, and route larger or harder prompts to Gemini through the same LanguageModelSession API. I like this far more than “try local and catch the failure”—users shouldn’t pay for our routing logic with battery and latency.

Using AI while exercising your critical thinking

— Bruno Rocha

“Cognitive surrender” is a better name for blindly forwarding AI output than the industry’s uglier medicalized label. The practical discipline is unexciting but sound: supervise complex work, demand evidence, open the cited links, and read generated code line by line. AI-assisted development still needs an engineer in the loop; otherwise we’re just an expensive meat proxy with commit access.

UI/UX

Measure App Launch Time with Instruments

— Mark Szymczyk

If app launch feels slow, stop poking at random initialization code and measure it. Instruments’ App Launch template and the App Lifecycle pane show each launch phase with its duration, giving us a concrete place to start instead of another round of “it seems faster on my phone.”

Responding to geometry changes in SwiftUI

— Natalia Panferova

Resizable iPad windows and iPhone apps running on larger surfaces have made device-based layout assumptions properly obsolete. onGeometryChange() lets a view derive a small Equatable value—say, whether a card should switch orientation—from the space it actually receives, and only updates state when that value changes. Return the smallest signal you need and keep it independent from the measured layout, or you’ll build a feedback loop that thrashes during resizing.

Testing

— Azam Sharp

Navigation stops being “just UI” the moment the destination depends on role, account state, or permissions. Representing destinations as Route values and moving those decisions into a router—or a feature coordinator once the router starts becoming a junk drawer—turns them into fast Swift Testing assertions instead of brittle UI tests. That seam is small, but it pays off every time a product rule changes.

Utils

FWC SwiftUI Skills

— Florian Schweizer

This focused Cursor Agent Skill packages modern SwiftUI guidance for implementing and reviewing Liquid Glass with native iOS 26 APIs. Installation is straightforward through npx skills add, and the narrow scope is the selling point: one well-maintained skill with concrete pitfalls beats a giant prompt that pretends to know every corner of SwiftUI.

iOS Newsletter Issue 105

2026-08-14T00:00:00+00:00

Hi folks!

A lot of this week’s issue is about making the invisible parts of our apps a little less mysterious. The compiler path from Swift text to WebAssembly, SwiftUI’s type-checking speedups, concurrency runtime changes, lifecycle callbacks — none of that is glamorous in the screenshot sense. But it is the stuff that decides whether our codebase feels fast, testable, and sane six months from now.

There’s also a nice thread of “tell the system what you mean.” Give SwiftUI real toolbar priorities. Give tests their own launch path. Give observable state a persistence story that fits the model we already use. Less fighting defaults, more shaping intent. I’ll take that trade any week.

Enjoy!

Articles

Swift

What’s new in Swift: July 2026 Edition

July’s Swift roundup has a nice mix of “big machinery moving under our feet” and small tooling wins we’ll actually feel in our codebase. Task Stealers landing in the concurrency runtime is the one to keep an eye on if our apps or services lean hard on async work, while SwiftPM’s package registry implementation nudges self-hosted package infrastructure closer to something boring and usable. I also like the reminder that contributing to Swift does not have to mean compiler archaeology; docs, website work, testing, tooling, all of it counts. Open source is healthier when the front door is not guarded by LLVM dragons.

What Happens When You Hit Run

Ugur Toprakdeviren

A compiler walkthrough that does the rare thing: it explains lexing, parsing, semantic analysis, IR, native code, WebAssembly, and runtime support without turning into a wall of compiler jargon. MiniSwift’s trick is especially fun because the browser path is not fake Swift on a server somewhere; the compiler itself runs as WebAssembly in the tab, then compiles your Swift to WebAssembly too. That makes the whole thing feel less like magic and more like a very careful assembly line. For anyone who has ever pressed Run and vaguely trusted the universe, this is a good peek behind the curtain.

UI/UX

App Lifecycle Management in iOS

Lifecycle code is one of those things we ignore until our apps lose state, leak work in the background, or come back from interruption looking half-alive. This is a practical pass through UIKit delegates, scene-based lifecycle, SwiftUI’s scenePhase, view callbacks, background tasks, restoration, and memory warnings. Some of it is familiar, sure, but having the map in one place is useful when our app has a mix of old UIKit corners and newer SwiftUI screens. Save early, cancel deliberately, test the ugly transitions. Boring advice, still true.

Adaptive SwiftUI toolbars in iOS 27

SwiftUI toolbars are getting more honest about the world our apps live in now: resizable windows, cramped layouts, search taking over the top bar, and actions that do not all deserve equal billing. The new iOS 27 APIs let us assign visibility priorities, keep secondary commands in overflow, pin a key action to the trailing edge, and tune how navigation bars minimize while scrolling. I like this direction because it lets us describe intent instead of fighting layout after the fact. Not every button is precious; our toolbar code should be able to say that out loud.

Content transition in SwiftUI

Content transitions are a small API with a very visible payoff: the view stays put, but the stuff inside it changes with animation instead of snapping like a cheap prototype. The examples show contentTransition(.interpolate), .opacity, and the especially handy .numericText() for counters, scores, and health-style readings where only part of the number changes. There’s also a useful note that the transition travels through the environment, which matters if we build custom rendering views. It is not a giant feature, but who doesn’t like deleting a pile of custom animation code?

ContentBuilder Explained - The Secret Behind SwiftUI’s Type-Checking Speedup

ContentBuilder looks almost suspiciously boring at first — in Xcode 27 it is a typealias to ViewBuilder — and then the real story turns out to be the API shape around it. The interesting bit is SwiftUI moving shared containers like Group, ForEach, and Section toward one structural construction path, with domain meaning proven later through conditional conformance. That cuts down the compiler’s old “which builder overload is this?” guessing game at every nesting level, which explains the dramatic type-checking wins Apple has been talking about. There are caveats, especially where relaxed constraints make overloads ambiguous, but the design lesson is sharp: build the structure first, prove the capability after.

Testing

How to Bypass SwiftUI App Launch During Unit Testing

Unit tests should not pay for our whole app launch ritual: persistence, analytics, network calls, first-screen setup, all the stuff that makes test feedback slow and weird. The SwiftUI lifecycle needs a slightly different escape hatch than old AppDelegate swapping, and the post lays out both a tiny conditional approach and a more explicit MainEntryPoint that chooses ProductionApp or TestApp. I’m partial to the simple version when it fits, because fewer moving parts means fewer excuses. But if launch code has real side effects, giving tests their own empty app shell is the cleaner boundary.

Utils

ObservablePersistency

Daniel Saidi

@Observable is lovely until we miss the convenience of @AppStorage and @SceneStorage, and this package steps into exactly that gap. By adopting ObservablePersisted, an observable class can define persisted keys and read/write values with less boilerplate than hand-rolling UserDefaults glue everywhere. It is a small library, not a new architecture, which is part of the appeal. If our state model already lives in observable types, persistence should not force us back into older patterns just to store a boolean.

iOS Newsletter Issue 104

2026-08-07T00:00:00+00:00

Hi folks!

A lot of this week is about choosing the right constraint before it chooses us. Actor isolation, alignment guides, sheet detents, StoreKit paywalls, even UIKit’s Liquid Glass bruises — same story in different clothes. The platform gives us powerful defaults, but our apps get better when we understand where those defaults stop being kind and start being baggage.

There’s also a nice tools thread here: Foundation Models hooks, Xogot’s Swift support and Pi inside the editor. Less ceremony, more context, fewer little bridges we have to maintain by hand. I’ll take that bargain most weeks.

Have fun!

Articles

Swift

An Even Closer Look at Protocols and Global Actors

Matt Massicotte

Protocols and actor isolation keep looking simple right up until our APIs start leaking constraints everywhere. The useful bit here is the distinction between whole-protocol @MainActor, per-requirement isolation, and sometimes no isolation at all now that Swift 6.2 gives us better tools. We like the push to ask what the protocol really needs before stamping @MainActor on everything, because once that constraint lands in our codebase, it tends to stick.

AI/ML

Swift: Hooks for Foundation Models. A Little Cleaner Way!

Itsuki Kamizuru

Foundation Models hooks feel like one of those small APIs that saves a surprising amount of glue code. Instead of posting notifications around every tool call, a LanguageModelSession.DynamicProfile can observe prompts, responses, activation, tool calls, and tool output in one place. For our apps, that means human-in-the-loop approval, logging, and guardrails can live near the model session instead of getting scattered through every tool implementation. Much cleaner. Also much harder to accidentally forget.

UI/UX

Making a SwiftUI sheet automatically size to fit its content

Daniel Saidi

SwiftUI sheets still make us choose from detents that are close enough, which is annoying when the content has an obvious natural height. The trick here is nicely boring: measure the sheet content with onGeometryChange, feed that height back into a .height(...) detent, and wrap it behind a small custom modifier. It is the kind of fix we want in a shared UI package, because nobody wants every sheet in our apps wasting half the screen for a tiny confirmation view.

Alignment guides in SwiftUI

Alignment guides are one of SwiftUI’s best “stop fighting the layout system” tools, and yes, most of us still reach for offsets too quickly. The walkthrough moves from built-in baselines to custom guides that let a parent align around a meaningful point buried inside a child view. That matters in real interfaces: icons next to text, timeline rows, custom artwork, all the small places where our apps look just a bit off unless we give SwiftUI the right reference point.

Tracking value sources to prevent recursive SwiftUI updates

Here is a sharp little pattern for wrapped UIKit and AppKit controls: track where a binding update came from instead of comparing huge values over and over. A custom transaction value can mark the originating UITextView, then updateUIView can skip applying the same value back to the view that just produced it. It is tiny, but the payoff is real — fewer pointless text resets, less layout churn, and no cursor jumps while someone is typing into our beautifully wrapped legacy control.

Liquid Glass - A Field Guide to UIKit Compatibility Pitfalls

Megabits Studio

Liquid Glass brought the shine, but UIKit teams got the bill. This field report is full of the ugly, practical stuff: UIBarButtonItem custom views losing sizing and color behavior, badges that sometimes refuse to update, tab bars getting weird around controller replacement, and WKWebView content needing proper safe-area CSS. The uncomfortable lesson is a good one for our apps: test every supported iOS version, especially around navigation, and the further we wander from Apple’s patterns, the more strange little caves we may fall into.

Mastering StoreKit 2. SubscriptionStoreView in SwiftUI.

SubscriptionStoreView is Apple doing the thing we keep asking for: taking a miserable purchase flow and making the default path pretty reasonable. Drop in a group ID or product IDs, then let StoreKit handle loading, purchasing, upgrades, downgrades, and the current subscription state. The customization hooks are the part worth lingering on — marketing content, backgrounds, control styles, and button labels give our paywalls room to feel like our apps instead of a gray system receipt stapled to the screen. There’s also a handy gallery with all of the initializer options for your needs at Explore SwiftUI

Tools

.NET, Swift, Git and AI land in Xogot for Mac

Miguel de Icaza

Xogot for Mac Beta 3 is turning into a very Apple-native answer to “what if Godot felt like it belonged on this machine?” Swift and C# get first-class editing and debugging, Git and LFS are built in, and Pi shows up as an integrated coding assistant instead of yet another external tool to wire together. I am especially interested in the Swift side: sourcekit-lsp, LLDB, Swift Packages, and Swift scripts attached to Godot nodes is exactly the sort of weird-but-useful bridge our corner of the community tends to enjoy.

iOS Newsletter Issue 103

2026-07-31T00:00:00+00:00

Hi folks!

The thread this week is control. Not the dramatic kind — the small, boring control that keeps our apps from wobbling: stable environment defaults, optionals handled honestly, reusable views with APIs that do not fight SwiftUI, accessibility semantics that actually say what the UI means.

And then AI keeps barging into the room. Foundation Models gets a cleaner architecture story with Dynamic Profiles, Xcode cleanup becomes agent-assisted but still approval-first, and Starling shows what happens when one person points agents at a job we used to measure in teams and years. Exciting? Yes. A little unsettling? Also yes. Which is probably the right mood for 2026.

Enjoy!

Articles

Swift

Advanced Swift: Optionals

Okan Orkun

Optionals are one of those Swift features we all use daily, then occasionally misuse in ways that make our codebase feel haunted. A solid walk through if let, guard let, chaining, map, flatMap, compactMap, and the newer Swift 6.2 string interpolation default gives the whole thing some needed shape. We especially like the blunt line on force-unwrapping: use ! only when crashing is the correct answer, not because we got tired of thinking. Good refresher, and probably worth sending to that teammate who still treats nil like a shrug.

AI/ML

Build Agentic Swift Apps With Dynamic Profiles

Trevor Whittingham

Dynamic Profiles in Foundation Models feel like one of those APIs that exists because the first wave of demos created a very real mess. Instead of rebuilding LanguageModelSessions, carrying transcripts around by hand, and stuffing every tool into one giant prompt, our apps can describe the current AI mode from state: analysis now, brainstorming later, maybe Private Cloud Compute only when it earns the trip. That is a cleaner shape for agentic Swift features, but the warning is fair too: model switches mean privacy, cost, and capability decisions, not just a fancier initializer. Nice architecture piece for anyone trying to move past “chat box with tools bolted on.”

How to free up Xcode disk space safely with an AI Agent

Xcode has always eaten disk space, but agentic development makes the problem louder: worktrees, Derived Data everywhere, old runtimes, archives we are scared to delete, the whole circus. This Xcode Disk Cleanup Agent Skill takes a refreshingly conservative route by auditing first, explaining candidates, and deleting only the exact items we approve. We’re into that, because “just rm -rf DerivedData” is the kind of advice that looks efficient right up until our next build, symbolication, or simulator state matters. Practical automation, with enough brakes attached to trust it.

UI/UX

The hidden cost of unstable SwiftUI environment defaults

A tiny SwiftUI default value can accidentally become a little invalidation machine, and yes, that is exactly the sort of bug that makes us blame the framework first. Creating a class instance directly inside an @Entry default means every fallback lookup can return a fresh reference, so views that only read that environment value may re-evaluate when unrelated environment values change. The fix is boring in the best way: store the default reference somewhere stable, or make the dependency optional and inject it explicitly from the app. File this under “small code, weird performance bill.”

Semantic Accessibility in SwiftUI

SwiftUI gives us a decent accessibility baseline, but semantics are where our apps start feeling built for real people instead of merely passing a quick audit. Labels, hints, values, grouping, decorative hiding, custom actions, traits, sort priority — it is all the stuff that makes VoiceOver navigation understandable rather than noisy. The useful bit here is how concrete the examples are, especially the rating control with an adjustable action. Accessibility is not polish at the end; it is part of the control’s API, same as its binding or label.

The Anatomy of a Reusable SwiftUI View

Alexander Weiss

Reusable SwiftUI views go bad fast when we design them like private helper functions instead of tiny platform citizens. The strongest point here is to start with semantics and data flow before reaching for visuals: is the component semantic or prescriptive, does it own state, should it use a Binding, and what invalid states should be impossible? The examples around Card, Tag, and a stylable Rating control show how far we can get by copying Apple’s API instincts — LocalizedStringResource, ShapeStyle, environment values, custom styles, and accessibility baked in. Especially now that agents can spray a bad component API across our codebase in minutes, designing the call site first feels less optional than ever.

Utils

SwiftStash

Tomasz Klocek

SwiftStash is a young package, but the pitch is easy to understand: property-wrapper persistence that covers UserDefaults, Keychain, SwiftUI bindings, Codable values, observation, and stricter Swift 6 behavior without dragging in third-party dependencies. It reads like @AppStorage where that makes sense, then keeps going into places @AppStorage was never meant to handle: non-SwiftUI code, secrets, typed updates, and “was this ever set?” checks. I like that the README also says the quiet part out loud — if @AppStorage already solves the job, keep it. For apps with both settings and credentials scattered around, though, one syntax for both stores could clean up a lot of little persistence corners.

Interesting

Starling — the first real desktop written by AI

Starling

Starling is not iOS development, exactly, but it is too weird and too Swift-adjacent to ignore: a real Linux desktop, written in Swift/C/C++, directed by one person with AI doing a huge amount of the building. The interesting claim is not the headline; it is the bar they set for “real” — drives the GPU through DRM/KMS, speaks Wayland and X11, and runs Chrome, Slack, Zoom, and other apps it did not write. Whether or not Starling becomes something people daily-drive, the labor collapse is the part worth staring at. If one person can push a desktop this far in six months, our assumptions about what agentic coding can produce are already stale.

iOS Newsletter Issue 102

2026-07-24T00:00:00+00:00

Hi again!

Sometimes it feels like we’re just skimming the surface. “It works” is fine for a prototype, but it’s a nightmare for a production app, especially when we’re fighting iOS 27’s new layout quirks or trying to stop our state from becoming a tangled mess.

This week, we’re digging in. Really digging in. We’ve got everything from the internal machinery of SwiftUI’s attribute graph to local STT running on Metal. It’s time to stop just using the facade and actually start owning our codebase.

Let’s go!

Articles

Swift

Typealias Usage in Swift

Typealiases aren’t just for fancy-looking signatures; they’re about making the codebase actually speak the language of the business. Using them for things like currency or complex completion handlers cleans up the noise. It’s a small win, but those are the ones that keep a project from feeling like a chore to read.

How did Apple cut launch time by 30% in iOS 27?

Jacob Bartlett

Apple claims a 30% boost in launch times for iOS 27, and the Instruments traces mostly back it up. But let’s be real: no amount of OS-level magic fixes the bloat from ten different marketing SDKs. We still have to do the hard work of profiling our own critical path.

UI/UX

Mastering the Model Layer: Iron-Clad State Management in Model-Driven Apps

Lucas van D

Let’s be honest, we’ve seen devs that just shoehorn state into ViewModels and hope for the best until the app becomes a tangled mess of “bucket-brigade” updates. The real way out is to treat State as the absolute center of the universe—model it, test the hell out of its mutations, and then build the UI. It’s a bit more legwork upfront, but getting those iron-clad business rules in place means we stop playing whack-a-mole with bugs in our production apps.

Geometry, Compositing and Drawing Groups in SwiftUI

Ever wondered why your SwiftUI animation looks like it’s falling apart? It’s usually a geometry or compositing boundary issue. Getting a handle on when to use geometryGroup versus drawingGroup is the difference between a “good enough” UI and one that actually feels polished.

With the new resizability requirements in iOS 27, the old sheet APIs just don’t cut it for landscape on iPhone. Building a custom overlay-based panel is a bit of a trek, but it’s the only way to keep our maps interactive while showing details. It’s a great example of when to stop fighting the system and just build the tool we need.

SwiftUI Is One Graph, Over 40+ Years of Engineering

Mihaela Jakić

Stop thinking of SwiftUI as a view tree; it’s a demand-driven attribute graph. Once you realize it’s just a giant set of rules and cached values, the “magic” of @State and identity actually makes sense. If we just use the facade, we’re just users, not developers.

Data

Syncing SwiftData With A Custom Backend Using HistoryObserver

Mohammad Azam

Syncing SwiftData to a custom backend used to be a nightmare of manual tracking. HistoryObserver in iOS 27 finally gives us a centralized way to watch the ledger. The trick is using soft deletes and author tags to avoid those lovely infinite sync loops we’ve all accidentally built.

Utils

transcribe.cpp

CJ Pais

Local speech-to-text that actually runs fast on Apple Silicon is a game changer. This library brings a massive range of models to the Metal backend via ggml. If we’re looking to add robust transcription to our apps without sending audio to a cloud API, this is the way to go.

iOS Newsletter Issue 101

2026-07-17T00:00:00+00:00

Hi folks,

It’s a very practical issue this week: less “look at the shiny thing,” more “how do we keep our apps from wobbling when real users, real devices, and real shipping pipelines get involved?” SwiftUI is still growing into the Mac, Observation still has sharp performance edges, and agentic coding is clearly moving past loose prompts into repeatable workflows. I like that mix. It feels like where our codebases actually live: half platform nuance, half tooling discipline, and a bunch of tiny decisions that either save us later or make future-us deeply annoyed.

Enjoy!

Articles

Swift

Task alive duration when device is locked

Apple Developer Forums

A crisp reminder that a Swift Task is not a magic background execution coupon. If iOS suspends our process, the worker threads stop, URLSession work can get defuncted, servers may time out, and the app might never be resumed before termination. The practical menu is familiar but worth repeating: prevent suspension where allowed, cancel before backgrounding, tolerate failure, or use background URLSession when that’s the job.

AI/ML

User Diagnostics Reports: Solving app bugs faster with AI Agents

Diagnostics reports are one of those boring-sounding features that become gold the first time a user says “it doesn’t work” and gives you nothing else. The pitch here is simple: collect app version, device context, relevant state, and logs in a structured way so support and AI agents can reason from facts instead of guesswork. I’m very into this direction, because our debugging loop should not start with three emails asking for information the app already knows.

Building and Shipping Mac and iOS Apps Without Ever Opening Xcode

Scott Willsey

Xcode still needs to be installed, yes, but it does not need to be the room we live in. The workflow here is delightfully blunt: use XcodeGen, xcodebuild, notarytool, stapler, devicectl, and a checked-in release script so an agent can build, sign, notarize, install, and deploy without clicking through Organizer. There’s setup pain once — certificates, keychain credentials, team IDs — but after that, our shipping path becomes a command the agent can actually run and verify.

Spec Kit (Spec-Driven Development) in an iOS Project

Spec-driven development feels like the needed backlash to “prompt, pray, accept diff.” The walkthrough puts GitHub’s Spec Kit into a real SwiftUI + TCA project, then drives a Favorites sort and search feature through constitution, spec, clarify, plan, tasks, analyze, and implementation. The best part is not the tooling glamour; it’s that architecture rules, localization requirements, and test-first reducer logic become artifacts the agent has to keep looking at instead of tribal knowledge buried in our heads.

UI/UX

A WWDC 26 Update on Building a Mac-assed App with SwiftUI

Paulo Andrade

A good follow-up for anyone trying to make SwiftUI feel properly Mac-like instead of “iOS app wearing a menu bar.” The useful bits are small but real: backgroundProminence can stand in for custom selection emphasis in some cases, .onDragSessionUpdated looks like the drag-and-drop hook we’ve been missing, and .reorderable may finally make the common case less annoying. Still, the bigger point lands harder: these gaps are rarely dramatic by themselves, but pile enough of them into our apps and suddenly we’re back to reimplementing platform behavior by hand.

The power of previews in Xcode

Previews keep getting better, and the newer pieces are more than convenience sugar. @Previewable cuts out those throwaway wrapper views we keep making just to hold @State, while PreviewModifier gives us reusable preview environments for things like in-memory SwiftData containers or app stores. Who doesn’t like less preview boilerplate, especially when it also makes our component states easier to actually inspect?

Rotating Liquid Glass in SwiftUI without breaking the shape

Liquid Glass makes a simple rotation suddenly less simple, because the effect is tied to bounds and geometry in a way a plain background is not. The workaround leans on a GeometryEffect plus ignoredByLayout() so the rotation stays visual instead of leaking into layout calculations. I’d be careful with the underscored _RotationEffect, but the lesson is bigger and useful: SwiftUI layout geometry and rendered geometry are not the same thing, and sometimes our UI only behaves once we treat them separately.

Equatable properties in @Observable classes

A neat performance detail hiding inside Observation: whether an assignment invalidates dependent SwiftUI views can depend on Equatable. Custom value types stored in @Observable classes notify on every assignment unless Swift can compare the old and new values, so unchanged data from polling, async streams, or framework callbacks can still cause redraws. Adding Equatable to those small model structs is not glamorous, but it can keep our views quiet when nothing actually changed.

iOS Newsletter Issue 100

2026-07-10T00:00:00+00:00

Hi folks,

This week marks our 100th edition and is all about stopping the fight with SwiftUI. Whether it’s finally getting a handle on those annoying re-renders by swapping closure bindings for subscripts, or actually following Apple’s advice to split views into structs instead of computed properties, we’re moving toward a world where our code actually matches how the framework thinks. Throw in some Swift 6 concurrency fixes for our tests and a proper way to stream observation changes, and we’ve got a lot of ground to cover to keep our apps snappy and our builds warning-free.

Have fun!

Articles

Swift

Streaming changes with Observations

The new Observations bit lets us turn observable models into async streams. No more manually triggering recursive observation or fighting with the Swift Concurrency world. It’s a clean bridge between reactive updates and for await loops that makes our UI code feel way less clunky.

UI/UX

Custom bindings in SwiftUI: closures vs subscripts

We’ve all used Binding(get:set:) and wondered why our views are re-rendering for no reason. Turns out, creating these closures in the body is a performance trap. Switching to labeled subscripts in the model gives SwiftUI a stable dependency to track and keeps our rows from flickering during unrelated state updates.

Splitting Large SwiftUI Views in the Apple’s way

Apple’s latest guidance is clear: stop using computed properties to split your views. While @ViewBuilder is great for tiny local branches, it doesn’t create a new invalidation boundary. Moving heavy sections into their own private view structs is the only real way to stop wasteful re-evaluations and actually gain some performance.

A Custom Pull-to-Refresh in SwiftUI

Sometimes .refreshable just isn’t enough when the designers want a branded, animated experience. This entry shows an approach that treats the refresh lifecycle as a state machine, giving us total control over the indicator’s progress and animations. It’s a solid blueprint for anyone who’s tired of the generic system spinner.

Little SwiftUI Tip: Get & Set & Watch Interface Orientation & Orientation Lock

Itsuki

Tracking interface orientation in SwiftUI is surprisingly annoying since it’s not in the environment. Using KVO on effectiveGeometry is the way to go to keep our UI in sync. It’s a bit of a workaround, but it’s the most reliable way to handle orientation locks and rotations without fighting the framework.

How to mark content as private using privacySensitive()

With privacySensitive(), we can finally tell SwiftUI which parts of our views should be hidden on the lock screen or in widgets. Pair it with .redacted(reason: .privacy) to easily mask out credit card numbers or personal info. It’s a small but essential tool for keeping our users’ data safe by default.

Testing

XCTest Meets @MainActor: How to Fix Strict Concurrency Warnings

Flipping the switch to Strict Concurrency in Swift 6 turns our test suites into a sea of warnings. The fix is simpler than it looks: mark the test class as @MainActor and switch to the async throws versions of setUp and tearDown. It’s the quickest path to a clean build without abandoning XCTest.

Talk

SwiftUI is functional

Manuel Chakravarty

A deep dive into why SwiftUI’s declarative nature is actually a functional programming win. It’s not just about the syntax; it’s about how the render tree and observation framework reconcile state. For those of us coming from a more OO background, it’s a great reminder of why the MVU pattern scales so much better for modern UIs.

iOS Newsletter Issue 99

2026-07-03T00:00:00+00:00

Hi folks,

Swift is in a strange, high-gear phase right now. Between the deep-dive into actor internals and the humbling realization that SwiftUI performance is mostly just a game of ‘spot the difference’ for the compiler, it feels like we’re finally peeling back the curtain on the machinery. And seeing millions of lines of Swift actually humming along in a browser via Wasm? That’s the kind of ‘future is now’ win that makes the struggle with ghosty animation bugs worth it. From Swift 6.4’s quality-of-life wins to Apple swallowing our favorite prototyping tools, this week is all about power gains and the growing pains that come with them.

Enjoy the mix!

Articles

News

Apple Acquires Award-Winning App ‘Play’

The Daily Tech Feed

Apple officially announced their acquisition of Play, that clever SwiftUI prototyping tool. It’s off the App Store now, so we can only hope its best bits end up in Xcode soon. Who doesn’t want a more fluid way to iterate on our apps?

Swift

Bringing Goodnotes to the web with Swift and WebAssembly

Yuta Saito

Goodnotes just proved that we can actually run millions of lines of Swift in a browser using Wasm without sacrificing that 60 FPS ink feel. They shared a ton about using WASI threads and custom actor executors to keep things snappy. It’s a massive win for those of us wanting a truly shared codebase across iOS and the web.

Swift 6.4: What’s New in Concurrency

Swift 6.4 is sneaking in some really practical quality-of-life bits. Async defer is a godsend for cleanup, and cancellation shields finally let us finish critical work without being cut off. Also, those new warnings for ignored throwing tasks will save us from a lot of “why did this fail silently” debugging sessions.

Swift 6.4 Brings New Language Features and Swift Testing/XCTest Interop

Sergio De Simone

Beyond concurrency, Swift 6.4 is cleaning up the edges with weak let and ~Sendable for when we need to be explicit about thread-safety. The interoperability between Swift Testing and XCTest is the real headline here, making the migration path a lot less painful. Plus, anyAppleOS is a nice touch to stop the boilerplate from piling up in our availability checks.

Actors in Swift: The Problem They Solve and How it Works

Omar Elsayed

A deep dive into the “aha” moment of actor isolation. It cuts through the mystery of why we use them and warns us about the reentrancy trap—where the world changes under our feet during an await. If you’ve ever wondered why your actor state felt unstable, this is the read you need.

UI/UX

Debugging Notes on Two SwiftUI Animation Bugs

Ted Kremenek, Dave Verwer, Sven A. Schmidt

A raw look at chasing those ghosty SwiftUI animation bugs that only show up on specific iOS versions. One’s a lesson in why implicit animations are safer than withAnimation for complex trees, and the other is a weird case where if/else beats a ternary for identity reasons. It’s a reminder that sometimes a bit of “comment-it-out” intuition is all we’ve got.

SwiftUI Performance Is Not About Views. It Is About Diffing

Maxim Egorov

Performance in SwiftUI isn’t about the number of views—it’s about whether the framework can actually tell what changed. The real culprits are usually non-diffable closures and lazy computed properties masquerading as views. The fix is to be explicit with Equatable and create real diffing boundaries by extracting actual view structs.

Tools

ATProtoKit

Christopher Jr Riley

A solid Swift library for anyone looking to build on Bluesky or the AT Protocol. It wraps the complex xrpc and api logic into something that feels native to our language. It’s still unstable, but it’s the quickest way to get a bot or a client running without fighting the protocol from scratch.

iOS Newsletter Issue 98

2026-06-26T00:00:00+00:00

Hi folks,

Swift is finally hitting the metal in a big way. Between Apple’s KernelKit slipping into the kernel and a full-blown Swift-based OS, the ‘it’s just for apps’ era is officially over. On the UI front, iOS 27 finally fixes some of the most annoying parts of SwiftUI toolbars and reordering, so we can stop fighting the framework for five minutes. We’ve also got a cautionary tale on SwiftData migrations that’ll save you from a few launch-day crashes, plus some native IoT tooling from AWS and a new Swift-powered container tool from Apple.

A lot to chew on this week. Enjoy!

Articles

Swift

Swift Package Index joins Apple

Swift Package Index finally joined Apple, and honestly, it’s a win for all of us. We can still rely on it for package discovery and those crucial compatibility checks without worrying about it disappearing into a corporate black hole. It’s staying open source, and they’re promising new stuff like package signing, so our project dependencies might actually get a bit more secure.

Apple Internals: Swift in the Kernel

Josh Maine

Apple is moving Swift into the kernel with this new KernelKit thing. We’re seeing the Embedded Swift runtime pop up in macOS 27’s pthread kext, though the core of XNU is still stuck in C/C++. It looks like they’re just laying the plumbing for now, which is exactly how you avoid breaking everything at once.

AWS IoT Device SDK for Swift is now generally available

AWS

AWS gave us a native Swift SDK for IoT at last. No more wrestling with wrappers when we want to build secure device fleets on iOS or macOS. It’s got the usual suspects—Device Shadow, Jobs, and TLS 1.3 support—so we can actually build production-ready IoT apps without the headache.

swift-os — a real operating system, written in Swift

Andrey Sapunov

Someone actually went and (vibe?) wrote a whole OS in Swift. It’s not just a “hello world” kernel; we’re talking a native TCP/IP stack, an HTTP server, and even an AI inference server, all running on Embedded Swift. It’s experimental, sure, but it’s a hell of a way to prove that Swift can live comfortably at the metal.

UI/UX

New SwiftUI APIs for reordering and drag and drop on iOS 27

We can do proper reordering in LazyVStack and LazyVGrid without writing a mountain of custom coordination code now. iOS 27 gives us .reorderable() and .reorderContainer(), which basically means the system handles the animations and placeholders while we just update our model. It’s about time these APIs hit iPhone and iPad.

Toolbars in SwiftUI can be a nightmare of “where did my button go?” on different platforms. The new .visibilityPriority and ToolbarOverflowMenu give us a way to actually control what stays visible and what gets hidden. Plus, .toolbarMinimizeBehavior is a nice touch for those of us who want the navigation bar to get out of the way when the user scrolls.

Data

Adopting SwiftData for a Core Data app

Moving from Core Data to SwiftData sounds like a dream until you hit your first schema mismatch crash. Emre shares a practical “room by room” migration strategy, highlighting the critical need to match the legacy SQLite schema exactly on the first pass. It’s a great reminder that “cleaning up” the model while migrating is a one-way ticket to a fatal error.

VM

container

Apple

Apple just open-sourced a tool called container that lets you run Linux containers as lightweight VMs on Apple Silicon. It’s written in Swift, OCI-compatible, and requires macOS 26. Finally, a way to handle containers on Mac that doesn’t feel like a hack.

iOS Newsletter Issue 97

2026-06-19T00:00:00+00:00

Hi folks,

This week, we’re diving into some serious performance gains as Apple swaps C for Swift in their TrueType hinting interpreter, and exploring a new frontier with Anthropic’s Claude integration for the Foundation Models framework. We’ve got some essential SwiftUI polishing tips on measurement units and a reality check on the new .prominent tabs in iOS 27 — remember, tabs are for destinations, not actions. We’re also rethinking our layout strategies for the resizable iPhone era, stealing a BCP 47 trick for dynamic text, and leveling up our Swift Testing game with better custom assertions. And for the “tweak-and-run” addicts, Tinkerble is here to save us from a thousand recompiles.

Enjoy!

Articles

Swift

Swift at Apple: Migrating the TrueType Hinting Interpreter

Scott Perry

Apple finally swapped out their C-based TrueType hinting interpreter for a memory-safe Swift version in the Fall 2025 releases. Not only did they kill off a major security attack surface, but they actually managed to make it 13% faster. They used a bunch of cool Swift 6 features like ~Copyable types and Span to keep performance high without sacrificing readability.

AI / ML

Apple Foundation Models - Claude API Docs

Claude APIDocs

Anthropic just dropped a Swift package that lets us plug Claude directly into Apple’s Foundation Models framework. It basically lets you swap between the on-device model and Claude using the same LanguageModelSession API, which is a huge win for consistency. It’s currently targeting the OS 27 betas, so we’re looking at a future where switching from local to frontier models is just a one-liner.

UI / UX

Styling measurement unit fonts in SwiftUI

Ever get annoyed that SwiftUI treats measurement values and units as one big blob of text? We’ve all been there. Natalia shows us how to use AttributedString and transformingAttributes to target just the unit, letting us downscale it with a .caption font while keeping the value bold. It’s one of those small details that makes our apps look way more polished.

From Size Class to Available Space - Is horizontalSizeClass Still Reliable?

With iPhone Mirroring and resizable iPhone apps in iOS 26, horizontalSizeClass isn’t the width sensor we thought it was. Fatbobman explains that Apple is decoupling “host semantics” from “geometric space,” meaning a wide iPhone window doesn’t automatically trigger a .regular size class. If we want our layouts to actually adapt to the space available, we need to stop relying on idioms and start looking at the actual geometry of the view or scene. It’s time to stop thinking about “devices” and start thinking about “space.”

Dynamic Text in SwiftUI – Robb Böhnke

Robb Böhnke

Here’s a clever hack for handling app-wide preferences, like choosing between a full name and a display name, without littering every Text view with if statements. The author uses a custom FormatStyle and hijacks the Locale’s BCP 47 private use subtags to propagate preferences through the environment. It’s a bit of a workaround, but it makes the dynamic behavior feel like a native part of SwiftUI’s late-binding system. Who doesn’t love a good “hidden” feature of BCP 47?

SwiftUI’s New .prominent Tab in iOS 27 Is Not a Floating Action Button

Sagar Unagar

This one gives us a much-needed reality check on the new .prominent tab role in iOS 27. It’s tempting to use it as a Floating Action Button for “Add” or “Create” actions, but Sagar argues that’s a huge mistake. Tabs are for destinations, not actions. If tapping it doesn’t take the user somewhere, it shouldn’t be a prominent tab. Let’s not ruin our UX just because a new API makes it easy.

Testing

How to Make Custom Test Assertions in Swift Testing

The article dives into the “Swift Testing” framework and explains why we still need custom assertions even though #expect is way more informative than XCTest’s old assertions. The big tip here is using SourceLocation to make sure failures are reported at the call site in your test, not inside your helper function. If we’re doing complex validation with if statements, Issue.record is the way to go for clean, readable failures.

Utils

Tinkerble

Edward Sanchez

This is a cool debug companion system for SwiftUI. Instead of recompiling every time you want to tweak a padding value or a color, you register them with @TinkerbleState and edit them live from a macOS companion app. It even supports logging live values and triggering app-side actions. It’s a huge productivity boost for those of us who spend half our day in the “tweak-and-run” loop.

iOS Newsletter Issue 96

2026-06-12T00:00:00+00:00

Hello again!

Apple are shaking things up with @State macros and a new way to export Xcode’s official agent skills to our favorite IDEs, while the fm CLI finally lets us script on-device models from the terminal. We’ve got a bit of everything this week: from the magic of AI-generated function bodies in AgenticSwift to a much-needed deep dive into SwiftUI’s lazy stack internals and macOS inspector design. Plus, if you’re feeling overwhelmed by WWDC26, there’s a perfect “too long; didn’t watch” cheat sheet to get you up to speed without the fatigue.

Let’s dive in!

Articles

Swift

Initializing @Observable classes with the @State macro in Xcode 27

@State is now a macro in Xcode 27, and it finally brings lazy evaluation to @Observable classes. No more wasted cycles initializing models every time a view struct is recreated—it just works. We can finally stop using those clunky optional workarounds in task modifiers for simple state setup.

Installing simulator runtimes from the command line

Donny Wals

Xcode 27’s runtime downloader is acting up again, leaving some of us staring at a “fetching download information” dialog forever. The fix is to jump into the terminal and use xcodebuild -downloadPlatform. Just a heads-up: you might need to specify -architectureVariant arm64 if it can’t find the universal runtime, because that’s where the real magic happens.

AI / ML

Using Xcode 27’s Agent Skills in Claude, Codex, and Cursor

Apple’s finally giving us official agent skills in Xcode 27, and the best part is we can actually export them for use in Cursor or Claude. Just run xcrun agent skills export and you’ve got a set of authoritative instructions for things like SwiftUI modernization and test migration in your favorite IDE. Some of them need Xcode to actually run, but for the source-code stuff, it’s a total game changer for our workflow.

AgenticSwift

Miguel de Icaza

Imagine a world where you don’t even have to write the function body—you just describe it in a macro and let Codex handle the rest. That’s exactly what AgenticSwift does with its @ai macro. It’s a bit wild to have code generated at expansion time, but for the boilerplate-heavy parts of our apps, this kind of automation may be exactly where we’re heading.

Foundation Models from Python: the fm CLI

Blake Crosley

macOS 27 just ripped down the wall between Swift and LLMs with the new fm CLI and a Python SDK. We can finally script the on-device model directly from the terminal or a Jupyter notebook without needing a full Xcode project. Whether it’s sorting files with JSON schemas or running evaluation pipelines with Pandas, the loop from “idea” to “evidence” just got a whole lot shorter.

UI / UX

Inspector Guidelines

Mario A Guzman

If you’re building for macOS 26 and your app is starting to feel cluttered, it might be time to move those auxiliary controls into an Inspector. Whether you go with a floating panel or the modern sidebar approach, the key is density and context. Just remember to keep your widths between 225 and 400 pts, or you’ll end up with a UI that feels “off” to Mac users.

WWDC26

Jacob’s WWDC26 tl;dw

Jacob Bartlett

Who has time to watch every single WWDC session? These “too long; didn’t watch” notes are a lifesaver, distilling the chaos of WWDC26 into a clean, filterable list. From the state of the union to the nitty-gritty of agentic app experiences, it’s the perfect cheat sheet for catching up on everything Apple just dropped without spending 100 hours in the video player.

Video

Dive into lazy stacks and scrolling with SwiftUI

Rens Breur

Ever wonder why your LazyVStack occasionally hitches or why your scroll position jumps? This deep dive pulls back the curtain on how SwiftUI estimates sizes and prefetches content. The big takeaway: stop doing heavy setup in onAppear and filter your data at the query level, not in the view body. If you want buttery-smooth scrolling in your apps, you’ve got to play by the lazy stack’s rules.

iOS Newsletter Issue 95

2026-06-05T00:00:00+00:00

Welcome to this week’s edition!

We celebrate the pinnacle of design with the 2026 Apple Design Awards and dive deep into the cutting edge of the Swift language. Just a few days before WWDC 2026, we’ll explore significant performance boosts in the Swift 6.4 type checker and the elegance of custom DSLs via Result Builders. For those focused on high-performance backend and AI, we have a thrilling Swift vs. Rust Lambda showdown and a look at running OpenAI-compatible local models with apfel. Finally, we’ll refine our apps’ polish with a guide to SwiftUI animation timing and discover how to modernize Core Data state management using the Observation framework.

Let’s dive in!

Articles

Design

Apple Design Awards - 2026 winners and finalists

Apple

As we all know, the Apple Design Awards are the gold standard for celebrating excellence in app design and user experience. This year’s winners showcase an incredible range of innovation, from whimsical Neolithic grunts in grug to the immersive spatial storytelling of D-Day. We can draw inspiration from these masterpieces of simplicity and accessibility to create more delightful experiences for our users.

Swift

What’s new in Swift: May 2026 Edition

Dave Lester

Who doesn’t like a good monthly digest of everything happening in the Swift ecosystem? From the exciting progress in Swift and WebAssembly to the new Bedrock library for AI agents, there’s plenty to keep us inspired. We should also keep an eye on the recent Swift Evolution proposals like the new Ref and MutableRef types, which promise to make our references safer and more performant.

Recent improvements to the type checker

Slava Pestov

Waiting for the compiler to finish type-checking can be the bane of our productivity. The author shares some fantastic improvements coming in Swift 6.4, including disjunction pruning and better binding inference, which significantly speed up complex expressions. We can look forward to faster build times and more responsive diagnostics, making the development loop feel much snappier.

Result Builders in Swift

We all like to create clean, declarative APIs that make our code easier to maintain. Wesley de Groot provides a fantastic deep dive into Result Builders, the magic that powers SwiftUI, and shows us how to build our own custom DSLs for things like URL construction or HTML generation. By mastering this advanced feature, we can bring that same elegance to other parts of our apps, reducing boilerplate and improving readability.

Swift on Server

Can Swift Match Rust on a Lambda Micro-Benchmark? Almost.

Sébastien Stormacq

Who doesn’t like a good performance showdown? Sébastien Stormacq puts Swift head-to-head against Rust in a demanding S3 archiving Lambda benchmark, and the results are impressively close. By opting for the Soto SDK and leveraging ByteBuffer for zero-copy efficiency, he proves that Swift is not just viable, but highly competitive for high-throughput serverless workloads. It’s a great reminder of the power we have in our hands when we profile and optimize with intention.

UI / UX

SwiftUI animation timing

As we all know, the difference between a clunky and a polished app often comes down to the details of motion. This entry is a comprehensive guide to animation timing in SwiftUI, from classic easing curves to the physics-based behavior of spring animations. By understanding how to use CustomAnimation and animation modifiers in our apps, we can create interfaces that feel intuitive and alive, bringing a professional touch to our user experiences.

Data

Core Data + Observation - From Property-Level Reactivity to a Freer Mental Model

We’ve often felt the friction of Core Data’s coarse-grained observation, forcing us to split views just to avoid unnecessary refreshes, aren’t we? This post explores a way to bring property-level reactivity to NSManagedObject via the Observation framework, bridging the gap between the stable Core Data ecosystem and the natural developer experience of SwiftData. This approach lets us organize our state according to business logic rather than observation constraints, a win for any developer maintaining a complex persistence layer.

AI / ML

The serve mode and the OpenAI protocol

David Krcek

Remember apfel, the command-line access to Apple FoundationModels on macOS that we wrote about in issue #87? In this article we can see how apfel turns a local Foundation Model into an OpenAI-compatible HTTP server. By decoupling the agent logic from the framework and using a protocol we all recognize, it becomes a breeze to swap models, run smoke tests with curl, and maintain a clean architecture in our codebase.

iOS Newsletter Issue 94

2026-05-29T00:00:00+00:00

Hi folks,

This week’s issue is a deep dive into both the philosophy and technical mastery of iOS development. From Paul Hudson’s timeless advice on resilience and lifelong learning to advanced SwiftUI techniques like TimelineView and custom layouts for perfectly smooth List row animations, we cover a broad spectrum of growth. We also explore the AI integration with a local documentation system, the technical brilliance of MiniSwift’s browser-based compiler, and the quirky delight of “Check ‘em” for 2FA pattern spotting. Finally, we touch on essential security with the Keychain Services API and the practical art of writing custom XCTest assertions to streamline our debugging.

Enjoy!

Articles

Programming

8 Things I Wish I Knew When I Started Programming

As we all know, the tech landscape shifts rapidly, and it’s crucial not to get tied down to a single language or framework. Embracing a lifelong learning mindset and building resilience against those inevitable “impostor syndrome” moments helps us grow in our apps’ development journeys. We also find that soft skills and a foundational grasp of computer science often matter as much as the code itself.

Swift

Working with the Keychain in iOS

Natascha Fadeeva

When we need to store sensitive data like passwords or tokens, the Keychain Services API is the go-to solution for keeping our apps’ data encrypted. Understanding the query-based structure allows us to efficiently save, retrieve, and update items, even if the C-based API feels slightly dated. It’s a fundamental part of iOS security that we should all master to protect our users’ privacy.

The 2FA app that tells you when you get `314159`

Jacob Bartlett

For those of us who love spotting patterns, “Check ‘em” brings the joy of “GETs” to multi-factor authentication. By pre-computing codes and scheduling push notifications, the app alerts us when rare sequences appear in our 2FA codes. It’s a delightful example of how an indie project can combine cryptographic utility with a touch of geeky fun in our apps.

UI / UX

Refreshing and animating views using TimelineView in SwiftUI

We’ve all wanted to create a clock or a smooth animation in our apps without cluttering our state with timers. TimelineView in SwiftUI offers a streamlined way to reevaluate views periodically or continuously, effortlessly driving visual effects and animations. Learning how to leverage different schedules allows us to build more dynamic interfaces while respecting the system’s update cadence.

Taming Row Height and Spacing Jumps in SwiftUI List with a Custom Layout

This one tackles a familiar SwiftUI pain point: jumpy row-height and spacing transitions inside List when dynamic content appears or disappears. It proposes a native SwiftUI architecture using Animatable, custom Layout, LayoutValueKey, and state decoupling to animate height smoothly without visual squeezing artifacts. It also introduces a custom vertical stack strategy to keep spacing synchronized with collapse progress, solving the subtle “last-frame jump” many of us see in production UIs. For teams polishing interaction quality in our apps, this is an advanced and very practical animation deep dive.

AI / ML

🍎📚Cupertino

Mihaela Mihaljevic

To keep our AI agents grounded and prevent those pesky hallucinations, Cupertino provides a local, structured documentation system. By indexing hundreds of thousands of Apple API pages into a searchable database, it serves accurate context via the Model Context Protocol. It’s a powerful utility that ensures the AI we use in our apps’ development is actually speaking the latest language of the platforms.

Testing

How to Make Custom Test Assertions in XCTest

The author shows how to build custom XCTest assertions in Swift that preserve accurate failure locations using #filePath and #line. He starts from tuple-testing pain points and demonstrates how a focused helper can produce much clearer diagnostics than generic assertions. In our apps, this pattern helps us keep test code expressive while reducing repetitive boilerplate and improving debugging speed. As we all like to keep feedback loops tight, this is a small technique with outsized value for test quality.

Tools

MiniSwift — Swift Compiler for the Web

Uğur Toprakdeviren

Imagine having a full Swift and SwiftUI pipeline running entirely in your browser—no LLVM, no React, just pure C compiled to WASM. MiniSwift makes this a reality, allowing us to experiment with Swift code and Metal shaders in real-time without leaving a tab. It’s a stunning technical achievement that brings the power of Swift development to the web, as we all know how much we value instant feedback.

iOS Newsletter Issue 93

2026-05-22T00:00:00+00:00

Hi folks,

In this week’s issue, we dive deep into high-performance Swift, from achieving Tflop/s speeds in LLM matrix multiplications to mastering the kinds of concise array sorting that make our code feel more elegant. We also tackle those subtle concurrency pitfalls, like unexpected main-thread hopping, that can quietly impact the responsiveness of our apps. Beyond the code, we explore the evolving landscape of developer tools with agent-native version control for AI-driven workflows and Xogot’s first-class native Mac experience for Godot. We’ve also included practical tips on maintaining a professional codebase using availability annotations to prune dead code, a comprehensive guide to streamlined persistence with SwiftData, and a comparison of how to manage concurrent tasks as we all strive for more structured concurrency. It’s a packed edition designed to help us make our apps faster, cleaner, and more robust.

Enjoy!

Articles

Swift

Sorting arrays in Swift using comparison operators as closures

This article explains how to make sorting arrays in Swift more concise and readable by using comparison operators as closures. By passing operators like < or > directly into the sorted(by:) method, we can write more expressive code. This technique leverages Swift’s functional programming capabilities to simplify collection management in our apps.

Unexpected Task suspension points in Swift Concurrency

Antoine van der Lee explores a subtle but impactful performance issue in Swift Concurrency where tasks unexpectedly start on the Main Actor, causing “main-thread hopping.” This happens when a Task inherits isolation from its surrounding context, even if the first operation is an await call to a different domain. By explicitly using @concurrent and MainActor.run, developers can avoid these unnecessary suspension points and improve the responsiveness of their apps.

What do you do when you want to get notified when a bunch of async tasks have finished?

Let’s compare the legacy DispatchGroup approach with the modern TaskGroup in Swift Concurrency for handling multiple parallel asynchronous tasks. This article demonstrates how TaskGroup simplifies code by replacing manual counter tracking (enter/leave) and callbacks with structured concurrency and async/await. This transition makes managing concurrent operations in our apps more intuitive and less prone to the errors associated with manual group management.

Deprecating your own convenience API

Miguel de Icaza, Joseph Hill

Majid explains a strategy for managing codebase cleanliness when supporting multiple iOS versions. By creating custom convenience wrappers for newer APIs and then using @available annotations with deprecated and obsoleted parameters, developers can leverage the compiler to identify and remove dead code once the minimum platform version is bumped. This approach helps in maintaining a professional codebase in our apps without accumulating unnecessary technical debt as the OS evolves.

AI / ML

Git for AI Agents: Version Control Built for LLM Coding Workflows

Owen Marshall

This entry explores the gap in traditional version control when using AI agents, where the “why” behind changes is often lost in ephemeral chat transcripts. It introduces the concept of agent-native version control, such as re_gent, which records reasoning, prompts, and plans alongside the diff. This approach allows developers to bisect decisions rather than just lines of code, greatly improving observability in agentic coding workflows.

Training an LLM in Swift, Part 1: Taking matrix multiplication from Gflop/s to Tflop/s

Matt Gallagher

In this detailed exploration, Matt Gallagher takes a handwritten matrix multiplication implementation in Swift and optimizes it from a slow baseline to over 1 Tflop/s. He walks through various techniques, including using MutableSpan to avoid COW overhead, leveraging the Numerics library for fused-multiply-add, and employing InlineArray for stack allocation. The journey culminates in the use of Apple Silicon’s AMX unit and Metal GPU kernels, demonstrating that Swift can match or even exceed C’s performance for high-compute tasks in our apps.

Data

SwiftData Tutorial: Swift Data Storage for iOS Apps

Aleix Ventayol

This tutorial introduces SwiftData, Apple’s Swift-native persistence framework, highlighting its ability to replace the boilerplate of Core Data with a declarative @Model approach. The guide covers essential CRUD operations, advanced querying with predicates, and managing relational data, while providing a comparison with other storage options like SQLite and Realm. By integrating tightly with SwiftUI, SwiftData allows developers to focus on feature delivery rather than persistence plumbing in our apps.

Tools

Xogot on Mac

Xogot is bringing its SwiftUI-based shell for the Godot game engine to the Mac, aiming to provide a first-class native experience that follows Apple’s Human Interface Guidelines. By integrating features like a Report Navigator and a Command Palette, Xogot seeks to make Apple platform deployment and debugging more approachable for Godot developers, reducing the friction often associated with Xcode. This tool allows developers to focus on game creation while enjoying the professional feel of a native Mac creative application in our apps.

iOS Newsletter Issue 92

2026-05-15T00:00:00+00:00

Hi again,

This week’s issue is packed with valuable insights to enhance your development workflow. We dive into the latest stability updates with Swift 6.3.2 and explore the intricacies of memory management with an evolution of Swift’s ARC. For those focused on UI, we’ve got practical guides on mastering SwiftUI’s layout with .fixedSize and creating visually striking area charts with dimming layers. We also venture into the third dimension with RealityKit mesh extrusion and expand our platform reach with KeyringAccess for secure secret storage on Linux.

Enjoy!

Articles

Swift

Announcing Swift 6.3.2

Mishal Shah

Swift 6.3.2 is a maintenance release that provides critical bug fixes and stability improvements following the major 6.3 release. It ensures that the toolchain remains reliable for developers building across Apple’s platforms and other supported environments. This update is recommended for all developers to ensure the best performance and correctness of their Swift code.

Unavailable from async attribute

This entry explains the noasync attribute introduced in Swift 5.7, which allows developers to mark types and functions as unavailable in asynchronous contexts. This is particularly useful for avoiding risks associated with thread-local storage, locks, or semaphores. While it provides a layer of protection, the author notes that it can be bypassed by nesting calls in synchronous functions.

Swift ARC: From Zombie Objects to Side Tables

This in-depth article explores the evolution of Swift’s Automatic Reference Counting (ARC) from early “zombie objects” to the modern “side tables” approach. It explains how side tables allow for more efficient memory management by decoupling the lifetime of the object from its weak reference bookkeeping. The author also provides detailed comparisons between strong, weak, and unowned references, highlighting their performance and memory trade-offs.

AI / ML

Install These Skills Before Codex Touches Your Xcode Project

Paul Solt

The author shares five specialized skill packs and tools designed to make AI agents more reliable when building iOS and macOS applications. The list features expert contributions and covers a wide range of topics from modern SwiftUI patterns to rules-based architectures. Additionally, he introduces his own AppCreator tool as a critical resource for establishing agent-friendly build systems that reduce common compiler errors and verbose output.

UI/UX

Area chart with a dimming layer up to the current point in time

This article provides a step-by-step guide on creating a sophisticated area chart in SwiftUI, inspired by the iOS Weather app’s UV index chart. It covers the use of AreaMark and LineMark with linear gradients and cardinal interpolation for smooth visuals. A key highlight is the implementation of a dimming layer using a RectangleMark and a custom mask to subtly indicate past time.

Finally found a use case for .fixedSize 😅

Omar Elsayed

In this practical layout guide, Omar Elsayed shares a common SwiftUI challenge: making all items in a horizontal scroll view match the height of the tallest card. He demonstrates how combining .frame(maxHeight: .infinity) with .fixedSize(horizontal: false, vertical: true) solves this problem by forcing the HStack to shrink to its ideal height. The article encourages developers not to avoid modifiers based on assumptions, as each one serves a specific purpose in SwiftUI’s layout engine.

3D

RealityKit Basics: Extruding Meshes

Joseph Simpson

This tutorial demonstrates how to create 3D shapes in RealityKit by extruding 2D Swift Path data. It explains the use of MeshResource.ShapeExtrusionOptions to define linear depth and chamfer radii, as well as how to assign materials to different faces of the extruded mesh. The provided example creates and animates a rotating 3D star, illustrating a powerful way to bridge 2D vectors and 3D entities.

Tools

KeyringAccess

MiaKoring

KeyringAccess is a pure Swift implementation of the Secret Service API for Linux, providing both high-level and low-level APIs for secure secret storage. It eliminates the need for system development headers by communicating directly via DBus and fully supports async/await. The library simplifies secret management with features like automatic collection discovery and a convenient subscript-based API for storing and retrieving secrets.

iOS Newsletter Issue 91

2026-05-08T00:00:00+00:00

Hi again,

This week, we dive deep into the nuances of Swift Concurrency and synchronization, with insights on avoiding unexpected suspension points and a comprehensive guide on choosing between Actors, queues, and locks. We explore the possibilities of SwiftUI with accelerometer-driven UI effects and an introduction to the new WebKit for SwiftUI API, while also focusing on accessibility with a guide to audio descriptions. Additionally, Natalia Panferova helps us master background app refreshes, and we discover MacFansControl for native macOS thermal management.

Enjoy!

Articles

Swift

Unexpected Task suspension points in Swift Concurrency

Ever wondered how unexpected suspension points in Swift Concurrency can negatively impact app performance by causing unnecessary main-thread hopping? Antoine demonstrates how inheriting @MainActor isolation in a Task can block the main thread and delay UI updates. The article provides a solution using @concurrent to ensure tasks start on a different isolation domain and use MainActor.run for UI updates.

Synchronization in Swift: Actors vs Queues vs Locks

This entry provides a comprehensive comparison of synchronization tools in Swift, ranging from high-level Actors to low-level Locks, Mutexes, and Atomics. It explains the trade-offs between safety, performance, and API design, highlighting how Actors encode isolation in the type system while Locks offer minimal overhead for synchronous paths. It also concludes with practical guidance on choosing the right mechanism based on the component’s requirements and the surrounding environment.

Accessibility

Audio Descriptions

Here’s a detailed guide on implementing audio descriptions in SwiftUI apps to make video content accessible for blind and low-vision users. The article explains how to detect user preferences and use AVFoundation to manage and select descriptive audio tracks. It also outlines the process of creating these tracks and shares a set of best practices for writing objective and concise descriptions.

UI/UX

Scheduling and handling background app refresh in SwiftUI

This article explains how to implement background app refreshes in SwiftUI apps using the Background Tasks framework. It covers the essential setup steps, including adding background capabilities in Xcode and registering task identifiers in the Info.plist. It also demonstrates how to schedule tasks using BGAppRefreshTaskRequest and handle them with the .backgroundTask modifier, while also providing a method for testing these tasks via the Xcode debugger.

Controlling views using the accelerometer