Learn - Develop - Deploy Hey Everyone! Kavsoft is a channel where I focus on making tutorials on Swift and SwiftUI that makes working with it fun, simple and easy. Here I try making concepts more understandable. My goal is to make complex codes simple and extend unreached benefits of SwiftUI. For more information reach out to us. Website : https://kavsoft.dev/ Instagram : https://www.instagram.com/_kavsoft/ Twitter : https://twitter.com/_Kavsoft
Recreate the App Store “App of the Day” hero (shared element) transition in SwiftUI. Build a card-to-detail animation using matchedGeometryEffect with a shared Namespace, custom timing, zIndex and clipping for a seamless morph, integrated with navigation. Notes on stable IDs/namespaces to prevent glitches.
Learn to recreate the iOS 26 Fitness app–style custom tab bar in SwiftUI, including an expandable layout and a custom search bar. The video demonstrates composing the UI, handling tab selection with state/bindings, and adding smooth expansion animations—practical patterns for bespoke navigation components.
Create an Apple Music–style dynamic background in SwiftUI by extracting key colors from a UIImage and using them to build a gradient. Covers deriving dominant/average colors, converting to SwiftUI Color, and composing a Linear/RadialGradient. Note: bridge UIKit to SwiftUI and perform color analysis off the main thread for smooth UI.
Tutorial shows how to build a macOS first-time onboarding animation using SwiftUI in Xcode 26. It demonstrates composing complex animations to create a polished onboarding flow and teaches practical SwiftUI animation techniques for crafting engaging first-run experiences on macOS.
Build an Apple-style 2D positional slider like the Photos app Tone Picker using SwiftUI. The video creates a custom control that tracks x/y drag to drive two values, updates state via bindings, clamps movement within bounds, and maps position to normalized output using DragGesture for smooth, responsive interaction.
Recreates a YouTube Shorts–style bottom sheet in SwiftUI. Shows how to build a collapsible view that resizes while dragging using DragGesture, track translation in @State, clamp to min/max detents, and snap with spring animations. Discusses layout and safe-area handling. Takeaway: implement smooth, interactive, gesture-driven sheets.
Build an iOS Photos–style hero transition in SwiftUI: tap a grid image to smoothly zoom into a full‑screen detail view and back. Uses SwiftUI animations and transitions (e.g., matchedGeometryEffect with a shared Namespace), state‑driven view swapping, and layout coordination to create seamless, complex UI motion.
Create an iOS-style permission onboarding interaction in SwiftUI using keyframe-based animations. Learn how to structure views and state, sequence keyframes for transitions and timing, and refine with easing/delays to mimic system sheets. Takeaway: orchestrate complex, smooth onboarding using SwiftUI Keyframes/KeyframeAnimator in Xcode.
Walkthrough to recreate iOS 26 first‑launch onboarding animation in SwiftUI. Builds a multi-step, state-driven UI with animated transitions to mirror Apple’s effect, showing how to compose complex sequences and tune timing for smooth performance. Useful patterns for onboarding flows you can adapt in Xcode 26 projects.
Build a custom SwiftUI “Liquid Glass” tab bar that morphs and expands smoothly. The video demonstrates creating a bespoke, animated navigation control in SwiftUI with state-driven transitions, emphasizing a polished, fluid UX. Takeaway: implement an expandable, visually rich tab bar in Xcode using SwiftUI animations.
Tutorial recreates Xcode 26.3’s new animated onboarding in SwiftUI. It composes multi-step views and uses state-driven animations and transitions to replicate the effect, focusing on view structure, timing, and smooth page changes. Includes practical tips to keep motion fluid and adaptable across screen sizes—useful for polished onboarding flows.
Tutorial recreates BlueNote’s 3D animated paywall using SwiftUI, combining layered views with 3D transforms and animation to achieve depth and motion. Focuses on structuring the layout, managing state and timing for smooth effects, and practical considerations for performance. Takeaway: craft polished 3D UI entirely in SwiftUI.
Build a custom Dynamic Island–based QR code scanner in SwiftUI. The video designs a Live Activity/Dynamic Island UI and connects it to a scanner view, manages camera permission, and displays results in the island. Takeaway: combine SwiftUI and Live Activities to surface glanceable scan feedback.
Build a sortable grid in SwiftUI with custom drag & drop to reorder items. Learn how to attach gestures to grid cells, manage drag state and item indices, update your data model as items move, and animate position changes. Takeaway: implement a smooth, reorderable grid purely in SwiftUI.
Learn to deter screenshots of a specific SwiftUI view by marking it as sensitive. The video applies the SwiftUI .privacySensitive() modifier to hide/redact content in screenshots and recordings. Caveat: iOS can’t fully block screenshots—only obscure content. Takeaway: protect sensitive views with privacySensitive.
Tutorial on recreating Apple Books’ hero transition in SwiftUI using matchedGeometryEffect. Implements synchronized scrolling and coordinated animations to build a complex UI in Xcode. Covers linking elements across views, managing animation state, and achieving smooth, responsive transitions.
Tutorial recreates Apple Stocks’ auto-scrolling ticker in SwiftUI. Builds a looping ScrollView that continuously scrolls items with smooth animation and automatic advancement, achieving an infinite cycle. Useful pattern for tickers/carousels in SwiftUI. Uses Xcode 26.
Learn to recreate the iOS Calendar app’s complex infinite scrolling interaction in SwiftUI using ScrollView. The tutorial covers structuring content to feel endless, managing state and scroll behavior for smooth continuity, and building a polished calendar-style UI. Takeaway: implement infinite scrolling UIs in SwiftUI.
Build a custom messaging app bottom bar in SwiftUI featuring recorder microinteractions with keyframe animations (e.g., KeyframeAnimator). Covers view structure, state-driven transitions, and composing reusable components for smooth, polished UI. Takeaway: use SwiftUI keyframes to craft rich, responsive controls.
Build custom SwiftUI toasts styled around the Dynamic Island. The video demonstrates a reusable toast view presented at the top with show/hide animations, timing, and dismissal, focusing on positioning and safe-area considerations near the Island. Takeaway: a simple SwiftUI pattern to add ephemeral, Dynamic‑Island–like toasts in your app.
Explains how to spot and reduce unnecessary SwiftUI view redraws to improve app performance. Focuses on recognizing when state changes trigger body recomputation and limiting updates to only affected subviews, helping keep rendering efficient and smooth.
Build a draggable floating window panel on macOS with SwiftUI that supports drag & drop. The video shows setting up a floating window, enabling user drag to move it, and wiring drag/drop targets via SwiftUI APIs. Notes on window z-order and interaction/hit-testing ensure smooth behavior and usability.
Build a custom SwiftUI carousel that animates a page‑curl effect using Metal shaders. It shows wiring SwiftUI state/drag offset to shader parameters to drive the curl and rendering efficiently in Xcode 26. Highlights device support and performance to keep 60fps. Takeaway: combine SwiftUI with Metal for bespoke, smooth UI effects.
Build an Apple‑style horizontal wheel picker for iOS 18+ in Xcode. The tutorial shows how to create a reusable custom picker component for selecting values like height or weight, with horizontal scrolling and centered selection to mimic the wheel look. A practical pattern for polished custom input controls across your app.
Build an App Store–style collapsing toolbar/header scroll effect using native SwiftUI. The video demonstrates wiring scroll behavior with SwiftUI toolbar APIs and modifiers to update the header as you scroll—no UIKit needed. Takeaway: craft responsive toolbars purely in SwiftUI.
Demonstrates adding animated SF Symbol Effects to the default SwiftUI TabView tab bar. Places Image/Label in tabItem and applies .symbolEffect(...) bound to the selected tab (value: selection) to trigger animations like .bounce/.pulse on selection. Requires iOS 17+ and SF Symbols that support effects; no custom tab bar needed.
Build a SwiftUI toolbar that morphs its items based on the active context. Uses SwiftUI toolbar APIs with state-driven ToolbarItem groups and conditional content, applying animated transitions for smooth swaps. Highlights placements and structuring for adaptive toolbars, plus keeping item identities stable to avoid jank.
Tutorial on building a Liquid Glass Text View in SwiftUI. It converts Text into a shape to drive masking/clipping and styles it for a glass-like effect in Xcode. Focus is on composing a custom view and turning text into a drawable shape for sleek UI results.
Build an animated splash screen for a SwiftUI app in Xcode. The tutorial walks through setting up SwiftUI views and applying basic animation to create a branded intro that transitions into the main content. Focuses on simple SwiftUI animation techniques suitable for beginners.
Create an animated location-permission onboarding screen in SwiftUI for iOS 17+. The video builds a polished UI with smooth transitions, then triggers the permission flow using Core Location (e.g., CLLocationManager/requestWhenInUseAuthorization), wiring state to control animations and the prompt timing to guide users before the system alert.
Build a custom confirmation dialog with a ‘hero’ effect in SwiftUI (iOS 17+). The video shows structuring a reusable dialog view, presenting/dismissing it with smooth animations, customizing actions and styling, and integrating it into app flows. Takeaway: craft polished, animated dialogs beyond the built‑in ConfirmationDialog.
Recreate X app’s Scroll + Sheet interaction in Xcode: implement a custom bottom sheet linked to scrolling with gesture handling and animations. Learn to sync scroll offsets with sheet position, apply snapping/thresholds, and manage gesture conflicts for a smooth, responsive UI.
Learn to build a SwiftUI alert that shows a ProgressView (loading spinner) in Xcode 26. The video demonstrates presenting the alert via state bindings, configuring ProgressView, styling the alert, and disabling background interaction—ideal for indicating in‑progress work.
Build an iMessage‑style photo picker in SwiftUI, tied to a SwiftUI TextField. The video shows creating a custom picker UI to browse and select photos and present it inline like Messages using SwiftUI state, bindings, and layout—great practice for composing custom controls.
Overview of five handy SwiftUI views/modifiers in Xcode 26. Shows how to apply and combine them to address common UI needs and polish layouts and styling. Practical, code-focused tips you can reuse to streamline everyday SwiftUI screens.
Build resizable floating sheets in SwiftUI: use iOS 16.4+ sheet detents where available, and a custom backport for older iOS. On 16.4+ rely on presentationDetents and drag indicator; earlier versions mimic snapping sizes via a draggable sheet. Covers availability checks and safe-area insets. Takeaway: consistent sheet UX across OSes.
Shows how to trigger the App Store rating prompt in a SwiftUI app only when a specific condition is met. Likely uses SKStoreReviewController to request a review from a suitable view/scene with simple gating logic. Caveats: Apple decides if/when to show and rate-limits requests; trigger after positive user actions for best results.
Create a SwiftUI drawing app using PencilKit: wrap PKCanvasView with UIViewRepresentable, show the tool picker, and enable drawing, image insertion, and editable text overlays. The video focuses on bridging UIKit PencilKit into SwiftUI and managing the canvas and user interactions.
Create a SwiftUI update checker for iOS 16+ that detects a newer App Store version and presents an Update page either as an optional prompt or a mandatory (blocking) screen. It compares the current app version to the latest available and opens the App Store to update. Takeaway: integrate an app-wide update gate in SwiftUI.
Learn to present full-screen sheets in SwiftUI using .fullScreenCover and build simple custom sheets. Covers toggling with @State/@Binding, presenting/dismissing, passing data, and basic Xcode setup. Takeaway: prefer .fullScreenCover for true full-screen modals; .sheet for standard card-style presentations.
Build a SwiftUI custom tab bar that mimics the native iOS 26 style and adds a central action button. The video shows creating a reusable bar view, managing tab selection with state, wiring the action button, and integrating it across screens in Xcode 26. Takeaway: implement a polished, native-like tab bar entirely in SwiftUI.
Convert SwiftUI views into a multi‑page PDF on iOS 17+. The video builds a PDF maker that renders SwiftUI screens into page-sized outputs and assembles them with PDFKit (PDFDocument/PDFPage), then exports a PDF file. Covers pagination, page sizing, and saving/sharing, with notes on memory and layout accuracy.
Create a custom animated menu in SwiftUI using state-driven animations. Uses @State to toggle visibility and applies withAnimation/animation plus modifiers like transition, offset, scale, and rotation within stacks and buttons. Takeaway: how to build and animate a SwiftUI menu in Xcode.
Build a custom animated toolbar in SwiftUI that mimics the iOS 26 Mail app’s toolbar. The video covers composing SwiftUI views, managing state, and applying animation/transition modifiers to produce smooth button interactions and show/hide behavior, resulting in a reusable toolbar component built in Xcode.
Tutorial on building a custom SwiftUI list with a header that stretches when pulled and remains sticky while scrolling. Demonstrates implementing scroll-dependent header behavior in a List/ScrollView, covering layout setup and state handling to achieve a polished, modern list UI.
Learn to recreate the iOS 26 Lock Screen carousel slider in SwiftUI, complete with a reflection effect. The tutorial builds a custom carousel component with SwiftUI views and animations to achieve a polished, lock-screen-style look. Takeaway: patterns to create reusable, animated carousels in SwiftUI.
Create a SwiftUI login UI for phone OTP with Firebase. Configure Firebase, send SMS via PhoneAuthProvider.provider().verifyPhoneNumber, collect the code, create a credential with credential(withVerificationID:verificationCode:), then Auth.auth().signIn(with:). Covers auth flow and caveats: using test numbers and reCAPTCHA/APNs prerequisites.
Integrate Firebase Email/Password authentication with a SwiftUI login screen. The video wires UI fields and actions to Firebase Auth, performs sign-in (and possibly sign-up), validates input, shows error messages, and updates auth state to navigate after login. Uses Firebase Auth email/password APIs. Good starter for SwiftUI + Firebase.
Build a SwiftUI login page using Firebase Authentication with email/password and verification. Covers Firebase setup in Xcode, creating sign-in/sign-up UI, sending verification emails, checking verification state, plus basic validation and error handling. Takeaway: connect Firebase Auth to SwiftUI for a secure email login flow.
Learn to build a fluid, natural zoom transition in SwiftUI using a “Liquid Glass” effect. The video demonstrates crafting a custom transition and tuning animations (timing and curves) to enhance polish and perceived depth for zooming UI, useful for image detail views or navigation flows.
Walkthrough of macOS Tahoe’s new multi‑item drag & drop API in SwiftUI using Xcode 26. Explains setting up views as drag sources and drop targets, handling multiple items, and updating app state on drop. Practical guidance to add rich drag & drop interactions to macOS SwiftUI apps.
Walkthrough of creating app icons with Xcode’s new Icon Composer and integrating them into an iOS app. Covers setting up AppIcon assets, configuring alternate icons via Info.plist (CFBundleIcons/CFBundleAlternateIcons), and switching at runtime using UIApplication.shared.setAlternateIconName(_:). Notes: iOS 10.3+, provide all sizes, no transparency, names must match.
Overview of the new SwiftUI Toolbar and Navigation Bar APIs in iOS 26 with Xcode 26. Demonstrates configuring toolbars, placing items, customizing titles and appearance, and handling navigation actions using updated modifiers and roles. Includes notes on API availability and migrating from older approaches.
Learn to build a custom animated user onboarding/tutorial screen in SwiftUI using Xcode. The video shows how to structure the onboarding UI and apply SwiftUI animations for smooth, polished transitions. Takeaway: leverage SwiftUI’s animation tools to create engaging onboarding flows.
Build a custom “liquid glass” morphing menu on iOS. The video shows how to design a glassy menu that smoothly morphs as it opens/closes by combining shape morphing, blur/translucency, masks, layered drawing, and animations. Takeaway: practical techniques to craft polished custom UI effects and menus.
Create a liquid glass morphing effect in SwiftUI, styled like iOS 26. The video demonstrates building fluid, animated shape transitions and glossy glass visuals using SwiftUI view composition and animation techniques, helping you add modern, eye‑catching UI elements to your app.
Build a SwiftUI ScrollView with a resizable header that shrinks/expands as you scroll. The tutorial covers two use cases, showing how to drive header size from scroll state, apply smooth animations, and handle safe-area/layout. Takeaway: a reusable pattern for dynamic headers in SwiftUI.
Build a SwiftUI permission onboarding sheet for iOS 17+. The video shows how to design a reusable sheet that lists required permissions and lets users grant them, wiring buttons to the appropriate system authorization requests and updating UI state—creating a polished, user-friendly permissions flow for onboarding.
Demonstrates SwiftUI’s new draw-based SF Symbol effects in iOS 26 and how to use them to build an onboarding animation. Shows applying symbol effects to SF Symbols, configuring them, and integrating animated icons into onboarding views. Requires Xcode 26/iOS 26.
Build a custom SwiftUI tab bar mimicking the new iOS 26 design with an expandable search bar, compatible with iOS 16.4+ and implemented without the Liquid Glass effect. Shows composing a custom tab interface in SwiftUI and handling search expansion/interaction. Takeaway: deliver a modern tab UI on older OS versions.
Build an Apple‑style onboarding screen in SwiftUI with animated transitions. The video covers structuring pages, managing state, and applying SwiftUI animation and transition modifiers to achieve smooth, polished effects. Ideal for adding a modern onboarding flow to your app.
Recreate the iOS Camera app’s custom segmented control in SwiftUI. The video builds a reusable control with segment layout, selection handling, and smooth animated indicator transitions. Useful for adding polished, system-like segmented switches to your app.
Build an Apple Maps–style bottom sheet interaction in SwiftUI over a map. Covers setting up a draggable sheet with snap points/detents, smooth spring animations, and integrating it with Map content. Key ideas: DragGesture, state-driven offsets, overlays. Notes: manage safe areas and gesture conflicts with the map. Takeaway: polished, interactive sheet UI.
Recreate the Family app’s morphing floating action button (FAB) menu in SwiftUI for iOS 17+. Build a custom control that morphs from a single FAB to an expanded menu using state-driven layout, transitions, and spring animations, with tap/drag gestures for interaction. Takeaway: craft polished, interactive SwiftUI menus with smooth animations.
Tutorial shows how to recreate Apple Music’s bottom bar in SwiftUI using new iOS 18 APIs (in Xcode 26), targeting iOS 26/18. It covers building the UI as a reusable component, managing state and styling, and adding basic animations. Takeaway: implement a modern bottom bar in SwiftUI.
Tutorial on creating interactive Snippets for App Intents with new APIs in iOS 26/Xcode 26. Covers defining intents and parameters, wiring results to a SwiftUI snippet UI, enabling interactivity, and running it. Notes version requirements and setup. Takeaway: add rich, actionable UIs to App Intents.
Demonstrates building a SwiftUI gradient generator that uses the new FoundationModel APIs to run Apple Intelligence on‑device in Xcode. Shows how to invoke the model and map results into UI. Notes local inference benefits (privacy, low latency). Takeaway: add on‑device AI to your apps.
Overview of what's new in SwiftUI from WWDC 2025 for iOS 26. Walks through newly introduced APIs and view modifiers with practical examples, showing how to integrate them into UIs. Takeaway: understand and adopt the latest SwiftUI capabilities to modernize your app.
Shows how to build a SwiftUI TextField that restricts input (e.g., allowed characters or max length). Uses a bound String with onChange to validate/sanitize and update the text, optionally via regex/CharacterSet, to block disallowed input. Notes that keyboardType is only a hint—always validate. Result: a reusable RestrictedTextField view.
Overview of SwiftUI window scene types and when to use them. Demonstrates declaring scenes in the App/@main using Scene, WindowGroup for primary UI, DocumentGroup for document-based apps, Settings for preferences, and MenuBarExtra (macOS). Notes platform availability and tips for choosing the right scene.
Overview of six handy SwiftUI modifiers (and related views) in Xcode 16. Shows what each does, how to apply and chain them, and when they’re useful, with simple examples and previews. Notes that modifier order affects results and promotes reusable view composition. A practical toolbox boost for everyday SwiftUI work.
Walkthrough of building an iMessage‑style morphing menu in SwiftUI. Demonstrates creating a complex custom UI with state-driven transitions and animations to morph between menu states, producing a polished interactive effect. Useful for learning custom controls and animation patterns in SwiftUI.
Build a custom paywall in SwiftUI by tailoring StoreKit’s SubscriptionStoreView. Demonstrates wiring native StoreKit APIs to surface subscription products, trigger purchases, and present subscription details within a custom UI. Takeaway: leverage built‑in StoreKit views for a polished, compliant paywall in Xcode.
Overview of SwiftUI’s newer animation APIs: PhaseAnimator and Keyframe-based animations. Learn to define phases bound to state, sequence keyframes with precise timing/easing, and compose multi‑stage effects. Covers when to use each and how to integrate them cleanly in views to build smooth, maintainable animations.
Build a custom inline toast in SwiftUI using Xcode 16. The video shows creating a reusable component to present brief, non-blocking messages within your view hierarchy and control its show/hide behavior the SwiftUI way. Takeaway: add simple, customizable in-line feedback to your apps without intrusive overlays.
Learn to use SwiftUI’s redacted modifier to build an animated skeleton loading state. Covers applying and removing redaction, driving the animation with state, and integrating it across common views. Takeaway: create a simple, reusable loading UX in SwiftUI with minimal code.
Build a custom, reusable skeleton loading view in SwiftUI for iOS 16+. The video shows how to create animated placeholders tied to a loading state and apply SwiftUI animation to convey progress until real content appears. Focus is on component design and integration. Takeaway: improve perceived performance with lightweight, reusable skeletons. Requires iOS 16+.
Build a Slack-style expandable hero header in SwiftUI (Xcode 16). The video recreates the collapsible/expandable header with smooth hero-like animation, showing how to structure layout and state to animate size and content on scroll—useful for custom animated headers in SwiftUI apps.
Build a 'Slide to Confirm' micro-interaction in SwiftUI. Create a reusable button/component with a sliding handle using SwiftUI state, gestures, and animations in Xcode 16, providing visual progress and completion handling. Takeaway: use subtle micro-interactions to deliver polished, intentional confirmations in your apps.
Shows how to stop users from interactively dismissing the SwiftUI navigation zoom transition in Xcode 16 by creating a reusable ViewModifier. It ties into NavigationStack/NavigationLink and temporarily disables the interactive pop/drag gesture during the zoom transition, then re-enables it. Useful to avoid accidental cancels; behavior may vary across OS updates.
Learn to recreate Family app–style confirmation dialogs in SwiftUI (iOS 17+). Build a custom overlay with ZStack, @State bindings, materials, and spring animations for show/dismiss, plus a dim/blur backdrop and tap-to-dismiss. Covers transitions, safe-area insets, and hit-testing, with notes on accessibility and Reduce Motion behavior.
Build a custom SwiftUI container that staggers item animations, delaying each subview based on its index. Uses ForEach with per-item .animation(.easeInOut.delay(...), value:) and .transition effects. Covers triggering with withAnimation, making it reusable, and tips to avoid repeat triggers and keep effects light for smooth performance (Xcode 16).
Build a Voice Memos–style waveform audio scrubber in SwiftUI (Xcode 16). The video shows creating a waveform view and wiring gesture-driven scrubbing to control seek/progress, yielding an interactive audio visualization. Takeaway: implement a custom SwiftUI control for waveform display and precise scrubbing.
Learn to build a VisionOS‑style menu for iOS using SwiftUI in Xcode 16. The video shows how to create a custom menu component, compose views and modifiers to match the VisionOS look, and wire basic interactions. Takeaway: craft polished, platform‑inspired UI using SwiftUI custom views.
Build a responsive, resizable Chips selection view (checkbox-like) in SwiftUI using the iOS 16+ Layout API. Implement a custom Layout to wrap chips across lines, handle selection state, and style chips. Works in Xcode 16. Takeaway: create reusable SwiftUI control for multi/select chips.
Tutorial on adding App Shortcuts to a SwiftUI app using the AppIntents framework so they appear in the Shortcuts app. Shows defining AppIntent types, exposing them via AppShortcuts/AppShortcutsProvider, configuring actions and parameters, and testing in Xcode 16. Takeaway: wire up intents for quick user actions accessible from Shortcuts.
Tutorial recreates the Apple Books app’s scroll animation in SwiftUI using Xcode 16. It demonstrates building a complex, scroll-driven UI and tying animations to scrolling with SwiftUI’s animation tools. Takeaway: implement smooth, Apple-like scroll effects and polish using a pure SwiftUI workflow.
Learn how to use the new SwiftUI Scroll APIs in iOS 18 (Xcode 16) to build a sleek custom scroll indicator. The video shows mapping scroll position/progress to a bespoke indicator using SwiftUI-only system APIs, enabling polished feedback for lists and feeds. Targets iOS 18 and focuses on UI customization rather than UIKit workarounds.
Learn to build a custom ripple transition in SwiftUI (Xcode 16). The video shows defining a reusable transition, applying it to views, and tuning animation parameters for smooth effects. Key idea: combine SwiftUI transitions with animations to create bespoke visual changes. Takeaway: implement polished, reusable motion in SwiftUI.
Build a custom number pad in SwiftUI (Xcode 16) with animated text effects as digits are entered. Covers laying out keys, managing input state, and applying SwiftUI animation/transition modifiers to create smooth, reusable UI components—perfect for polishing PIN/OTP entry screens.
Recreate Apple’s Invites app onboarding in SwiftUI by combining an infinite ScrollView (looping pages), Text rendering for styled copy, and smooth animations. Uses SwiftUI ScrollView, Text, and animation modifiers to achieve an Apple-like flow, with guidance on state handling to keep interactions smooth when looping.
Build custom swipe actions for items in a SwiftUI ScrollView (Xcode 16). Implement a DragGesture to reveal action buttons by changing offsets with animated state. Notes handling conflicts with vertical scrolling and resetting item state. Useful when .swipeActions isn’t available.
Walkthrough to build a custom animated OTP verification TextField in SwiftUI. Uses PhaseAnimator to drive state-based animations during code entry and a custom TextField layout. Takeaway: learn to create a reusable, polished OTP input control for SwiftUI apps.
Build sectioned lists with custom DisclosureGroup headers and enable drag-and-drop to reorder cards and move them between sections in SwiftUI. Persist ordering with Core Data via a sortIndex, updating it on drop and saving the context. Uses @FetchRequest/sections and avoids index glitches with stable IDs.
Shows how to programmatically control and lock orientation in SwiftUI, updating device orientation to force portrait/landscape for specific views. Covers setting orientation at runtime and managing an orientation lock. Takeaway: explicitly manage view orientation behavior within SwiftUI apps.
Build a macOS screen recorder with SwiftUI using ScreenCaptureKit. Set up capture of displays/windows, wire start/stop controls, preview, and save to file. Notes Screen Recording permission and macOS-only API. Takeaway: use ScreenCaptureKit to ship a simple, complete recorder in SwiftUI.
How to handle remote push notifications in SwiftUI and deep link users to specific views. Demonstrates registering for notifications, handling tap actions via UNUserNotificationCenter delegate, parsing userInfo to pick a route, and driving NavigationStack-based navigation. Notes routing considerations across app states (foreground/background/cold start).
Build a full SwiftUI document scanner: use VisionKit to capture/scan pages, persist scans with SwiftData and implement CRUD on documents, secure access with a biometric lock, and add UI polish with animations. Covers data modeling, storage, and camera permissions to ship a practical scanner app.
Walkthrough of new macOS 15 SwiftUI window APIs to build floating and utility windows. Demonstrates configuring window styles/levels, presenting separate utility panels, and controlling behaviors like always‑on‑top. Uses scene/window modifiers and WindowGroup, with macOS 15 availability checks. Takeaway: native panels without AppKit boilerplate.
Create a complete Habit Tracker in SwiftUI: model and persist habits with SwiftData using CRUD operations, schedule local reminders via UserNotifications, and enhance interactions with SwiftUI animations. Includes setting up data flow and handling notification permissions for a smooth, responsive app experience.