Swift

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.

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 the new Music Understanding framework to analyze tempo, key, structure, instruments, and loudness in Swift apps.

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

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

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.

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.

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...

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.

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...

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 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...

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...