All Posts

Use named SwiftUI previews, seeded debug states, simctl screenshots, temporary tuning controls, and narrow snapshot checks to make agent-assisted UI work repeatable instead of vibes-based.

Use SwiftUI layer effects, stitchable Metal shaders, TimelineView, maxSampleOffset, and transcript layout state to build a now-playing screen that still has production boundaries.

Build a small agentic SwiftUI feature, profile it with the Foundation Models Instrument, and use the trace to fix prompt bloat, repeated tool calls, latency, and unsafe debugging data.

Build a practical SwiftUI image analysis flow with Foundation Models vision attachments, structured output, token budgeting, optional OCR and barcode tools, and a careful Private Cloud Compute fallback.

Audit SwiftUI screens for resizable iPhone apps by replacing size-class-as-width assumptions with container geometry, useful layout thresholds, Dynamic Type checks, and realistic Xcode 27 testing.

AsyncImage now participates in HTTP caching, accepts URLRequest, and can use a custom URLSession on iOS 27 and the other OS 27 Apple platforms. Here is how to use the new behavior in real SwiftUI apps without overbuilding your image pipeline.

Use App Intents and Visual Intelligence to return ranked app content from screenshots and camera captures, with AppEntity models, SemanticContentDescriptor queries, Vision feature prints, OpenIntent routing, privacy, and testing.

Move a CXProvider-style VoIP app to LiveCommunicationKit with ConversationManager, stable handles, PushKit incoming calls, outgoing actions, group updates, and Recents and Siri caveats.

Replace polling with a generated gRPC Swift 2 client for a live order tracker, using a unary bootstrap call, streaming updates, SwiftUI state, and lifecycle-aware reconnects.

Run a tiny Swift backend in a persistent local Linux environment, point Xcode tests at it, and keep Docker and CI for the jobs they still do best.

Extend a system UITextView from SwiftUI with TextKit 2 hooks for line numbers, foldable sections, and reusable inline attachment views without writing a custom editor from scratch.

Refactor a crowded SwiftUI editor toolbar for resizable iPhone apps with visibility priorities, overflow menus, pinned actions, size classes, and Xcode 27 Live Preview resizing.

Build a Foundation Models router that preserves drafts, chooses local or Private Cloud Compute intentionally, and exposes quota and availability in SwiftUI.

Diagnose custom SwiftUI feed jank with stable identity, data-level filtering, bounded nested lazy stacks, and modern scroll visibility APIs before falling back to List.

Build a Swift-native Xcode automation CLI that streams xcodebuild output, handles failures, and writes a useful CI summary.

Use Xcode 27 agents as a human-checked SwiftUI workflow for planning, previewing, testing, and reviewing a small feature before you keep the diff.

Use HealthKit workout zones to build post-workout time-in-zone charts, live heart-rate coaching, preferred and custom zones, privacy-aware summaries, and practical training features.

Make an AVFoundation camera feel ready sooner by splitting preview-critical launch work from deferred output initialization, keeping capture responsive, and testing pressure on real hardware.

Use Apple's Now Playing framework to publish Swift media sessions across the Lock Screen, Control Center, CarPlay, and remote playback surfaces.

Use App Attest to verify genuine app instances before trusting sensitive server requests.

Use Apple's public Lookup API to check whether a newer App Store version is available, compare it safely, and send users to the App Store from SwiftUI.

Build one ActivityKit model that adapts to compact Dynamic Island width, StandBy, Apple Watch, CarPlay, and real-time push update strategies.

Use StoreKit's monthly billing plan for yearly subscriptions, show the commitment honestly, purchase the monthly plan, and track entitlement versus commitment progress.

Use AVFoundation to add manual aspect-ratio controls, smart photo framing, recording safeguards, and Center Stage behavior for video calls.

Move large optional app and game content out of your bundle, deliver it when needed, and localize asset packs without making users download every language.

Use WWDC26 App Intents APIs to share structured entities, suggest relevant content, scale bulk actions, sync IDs across devices, run long work, and route execution to the right process.

Build a field-performance loop with MetricKit reports from real devices, app-state grouping, JSON ingestion, and Instruments traces that reproduce and verify the fix.

Use the new Music Understanding framework to analyze tempo, key, structure, instruments, and loudness in Swift apps.

Use Device Hub, devicectl, Organizer metrics, and Instruments to reproduce real-device bugs without losing the thread.

Use SwiftUI's new snapshot-based document APIs to save native package documents and export PNG or PDF files.

Build a release gate for Foundation Models features with evaluations, tool trajectory checks, and layered security mitigations.

WWDC26 adds sectioned queries, codable attributes, ResultsObserver, and HistoryObserver so SwiftData apps can react to store changes without hand-rolling array diffs.

Use AppIntentsTesting to verify intents, entity queries, Spotlight indexing, and SwiftUI view annotations before debugging the same behavior through Siri.

Use Core Spotlight as the retrieval layer for a Foundation Models chat feature, with item donation, delegate hydration, batched search results, query tokens, and retrieval evaluation.

Trust Insights helps iOS apps recognize when a legitimate user action may be coerced. Here is how to place it in sensitive flows without turning a trust signal into a blunt block button.

Foundation Models Dynamic Profiles let one LanguageModelSession switch instructions, tools, models, and reasoning level as app state changes. That is the missing shape for agentic Swift features.

SwiftUI's new reordering and drag container APIs finally make it practical to move ordered content outside List, including multi-item drags and move-only drops.

App Intents are the foundation for Siri AI, but App Schemas are what make your app's content and actions understandable. Here is the shape of a useful integration.

Core AI gives Swift apps a new path for running custom on-device models. Here is how I would structure a small private AI feature without turning model loading into the user experience.

Wrap PaperKit's markup controller in SwiftUI, persist PaperMarkup data, and choose the feature set your editor actually supports.

Use GRDB, SQLite FTS5, and a small SwiftUI view model to build fast local search that still feels native.

Use BGContinuedProcessingTask for visible, user-initiated work that may need more time after your app leaves the foreground.

Use Swift Testing exit tests to verify deliberate process exits without crashing the whole suite, including fatalError and preconditionFailure paths.

Record screenshots, JSON payloads, and plain-text diagnostics from Swift Testing so a failed test tells you what actually happened.

Use Instruments' SwiftUI instrument to connect an expensive body update back to the state mutation that caused it, then fix the view instead of guessing.

Teach an on-device Foundation Models session to call a small Swift tool, validate the arguments, and return app data without turning your SwiftUI view into an AI grab bag.

Use Foundation Models streaming APIs to update SwiftUI as an on-device response is generated, with cancellation, availability checks, and a production-shaped view model.

Swift 6.2 makes concurrency feel more natural for app code, but it is still easy to accidentally leave expensive work on the main actor. Here is the mental model I use for SwiftUI apps...

Foundation Models lets Swift apps ask the on-device language model for structured output. Here is a small SwiftUI search suggestion model using availability checks, @Generable, and @Guide...

Swift Charts can plot real three-dimensional data with Chart3D. Here is a compact SwiftUI example using PointMark, Z-axis values, species styling, and Chart3DPose...

SpeechAnalyzer and SpeechTranscriber bring a modern async speech-to-text API to Apple platforms. Here is a small file transcription example that returns an AttributedString.

App Intents are not just for Shortcuts. Here is a small foreground intent that opens your app and routes into a SwiftUI screen from system surfaces...

SwiftUI's TextEditor can edit AttributedString directly on the newest Apple platforms. Here is a small rich text editor with selection-aware formatting controls...

SwiftUI finally has a native WebView through WebKit. Let's replace the old WKWebView wrapper with WebView, then use WebPage when we need loading progress, page titles, and find-in-page...

Use the Translation framework from SwiftUI with language availability checks, TranslationSession.Configuration, .translationTask, and batch translation.

iOS 18 controls let users run app actions from Control Center, the Lock Screen, and the Action button on supported devices. Build a WidgetKit control toggle that stays in sync with app state.

Swift 6 migration is easier when you turn on strict concurrency checking before flipping the language mode. Walk through a module-by-module checklist.

Convert a realistic XCTestCase into Swift Testing with @Suite, @Test, #expect, #require, async tests, parameterized tests, tags, and coexistence notes.

SwiftData's iOS 18 schema macros can add indexes and uniqueness rules. Use them carefully for fast fetches and duplicate prevention.

SwiftData history lets you ask what changed since a saved token, which is useful for widgets, sync, badges, and background work.

Swift Charts gained function plotting APIs so you can draw smooth math curves without precomputing every point yourself. Build a normal distribution chart and compare it with sampled LineMark data.

Replace preference-key scroll tracking with onScrollGeometryChange, visibility modifiers, and ScrollPosition for feeds, pagination, and scroll-aware controls.

Build a modern SwiftUI TabView that stays a tab bar on compact screens and adapts into a sidebar on iPad and Mac.

TextRenderer lets SwiftUI apps draw custom text effects while keeping text as text. Build a small highlight/reveal renderer with accessibility and reduced-motion notes.

Use SwiftUI's iOS 18 zoom navigation transition to connect a grid cell to a detail screen with stable IDs, a namespace, and an iOS 17 fallback.

SwiftUI's MeshGradient gives you animated, art-directed gradients without hand-building a Metal shader. Build a small reusable background and keep reduced motion in mind.

An LRU cache is a perfect little systems problem: a dictionary for O(1) lookup plus a linked list for recency. Let's build one in Swift, test it, and talk about when OrderedDictionary is the simpler app-level choice.

Binary search is less scary when you commit to one invariant. Let's implement lowerBound, upperBound, exact search, and insertion index in Swift using half-open ranges and test cases that catch the usual mistakes.

Flow layouts are one of those UI details that look easy until Dynamic Type, spacing, and reuse show up. Let's build a reusable SwiftUI Layout that wraps chips across rows without GeometryReader hacks.

Privacy manifests are easier to handle when you treat them like a small audit instead of a mysterious Xcode file. Let's walk through required reason APIs, third-party SDK manifests, and a practical PrivacyInfo.xcprivacy checklist.

A chat screen is where SwiftUI keyboard handling, scroll behavior, focus, and safe areas all meet. Let's build a practical message list with a growing composer that stays attached to the keyboard.

PhotosPicker examples often stop at loading a UIImage. Let's build the production version: Transferable loading, cancellation, downsampling, file persistence, limited-library behavior, and a UI that can survive iCloud delays.

Universal Links are simple when every moving part is correct, and maddening when one file, entitlement, path, or redirect is wrong. Here's a practical SwiftUI debugging checklist from apple-app-site-association to onOpenURL routing.

StoreKit 2 gives us two important transaction sequences: one for reading what the customer owns now and one for listening to changes. Let's build a tiny entitlement store that uses both without accidentally missing purchases.

AsyncImage is great for simple remote images, but production lists usually need memory caching, predictable cancellation, placeholders, retries, and downsampling. Let's build a small SwiftUI image loader and talk about when to use Nuke or Kingfisher instead.

NavigationStack works best when your app owns its route model. Let's build an enum-based SwiftUI router that handles pushes, sheets, deep links, and state restoration without scattering navigation code everywhere.

The sliding window maximum problem is a great example of why the right data structure matters. Let's solve it in Swift with a monotonic deque and get the runtime down to O(n)...

I have this pet peeve where I don’t like to type out .compactMap { $0 } every time I want to remove nils from a publisher. Today I finally took some time to find a good alternative & I really like how ...

Last time we talked about how to refactor a callback based network call into an async/await based call. In that case, we had access to the underlying networking code & updated the entire chain of method calls to use async/await...

Recently I’ve refactored a few callback based network requests to use Swift’s new Async / Await syntax. Let’s take a look at how we can take a conventional callback based API method and improve its readability and simplicity...

Let’s learn how to add a slick app download banner to your website! Apple officially calls this a Smart App Banner, because it changes its wording based on if the user has the app installed. If the app isn’t installed, the...

Another SwiftUI post coming your way! This time we’ll take a look at Divider and how we can change its color. As nice as it would be to change the divider color with tint or foregroundColor, we can’t do it that way 😭...

SwiftUI is the best thing since sliced bread, but I often come across simple problems that take longer than expected to sort out. Take for example an alert where I want to style the buttons. In my specific case it was a confirm...

If you’re a Swift blogger like me, you probably have to come up with some easy way to highlight code syntax on the web. After some searching I came across Splash which was created by the relatively famous John Sundell (he uses...

I was recently working on some XCUITests and attempting to get them working inside a CI/CD pipeline (Bitrise). It turns out that the virtual machines on Bitrise are a bit underpowered, so many things like building a project ...

Let’s take a look at how to change all of your targets’ build numbers and marketing versions in a single place. I was surprised to find that a lot of developers don’t know this simple trick & manually change their build numbers...

Every once in a while you’ll probably make some changes to your launch screen, and I’ve run into a few headaches while doing it. Most recently I had trouble with an image not updating as expected. Let’s walk through what I did...

I was recently working on my Wordie app & needed some confetti to celebrate a victory when the user guesses the correct word. I built the app completely in SwiftUI so I started searching for a confetti library I could drop in...

Solve LeetCode problem 21 in Swift by merging two sorted linked lists iteratively and recursively, with the tradeoffs of each approach.

Solve longest substring without repeating characters in Swift using a sliding window and a dictionary of character indexes.

Going along with my previous post about auto incrementing build numbers in Xcode, I thought it might be useful to share how I debugged Xcode scheme pre & post actions. Normally these actions don’t show error messages...

If you're like me you probably get tired of manually incrementing your app build number in Xcode. After a few hours of testing I finally nailed down a simple solution that works on Xcode 13.2.1. Let's dive right in...

In step 1 we created the widget extension target & got it running on the simulator. Now let’s look at the basic parts of a widget. You’ll notice that Apple created a folder with your widget name & made a template file for you...

It was pretty cool when Apple gave us widgets with iOS 14. Finally we could customize our home screens with something more than just app icons! This is a simple walkthrough of how to add a widget to your app & what to put in...

The first time I heard of a DispatchGroup was a few years into my iOS career - my teammate mentioned that he used it in his pull request code. He said this DispatchGroup made it easy to wait for multiple async callbacks...