Create with Swift is brought to you by imaginary institute, a creative design and tech consultancy, bringing imagination and innovation to the visionaries and shapers of tomorrow. We are powerful collective of developers, designers, transformers and imaginative thinkers. We work at the intersection of technology, design, education & innovation.

Small Choices, Big Impact: The Environmental Cost of Mobile Design Decisions

Explores how small mobile app design choices accumulate into significant environmental impacts at scale. Covers sustainability 'in' vs 'through' design, emphasizing energy-efficient practices like OLED dark mode optimization, image compression, and intelligent background tasks. Discusses iOS tools like Instruments for energy diagnostics, AI's environmental costs, and the need to treat sustainability as a first-class design concern alongside performance and UX.

Creating overlays on a map in a SwiftUI app in iOS 26

Shows how to add MapKit overlays in SwiftUI's Map using MapContent: MapPolygon, MapPolyline, and MapCircle. Build from CLLocationCoordinate2D/MKMapPoint/MKPolygon-MKPolyline, style with foregroundStyle and stroke, and plot MKDirections routes as polylines (useful for geofences and ranges).

Custom Parameters and Animation with Metal Shaders

Pass custom parameters from SwiftUI to Metal shaders and animate them. Implement a chessboard shader taking tileSize and fillColor via .float()/.color() (order matters; Color → half4). Use TimelineView to feed time and create smooth sine‑wave RGB animation.

Creating Maps in SwiftUI apps with MapKit

Integrate MapKit in SwiftUI with the Map view: set an initial camera via MapCameraPosition/MKMapCamera, bind camera for dynamic control, and constrain interaction with MapCameraBounds, interactionModes, and scope. Build tailored map UIs.

Taking First Steps into Metal Shaders

Beginner guide to Metal shaders in SwiftUI. Covers GPU pixel-based rendering, MSL [[ stitchable ]] functions, half4(position,currentColor), and Xcode’s auto-generated ShaderLibrary. Shows basicColor and a normalized position-based gradient applied via .colorEffect(); recommends passing view size instead of hardcoding.

Call for Applications at the Apple Developer Academy 2026

Applications are open for the 2026/27 Apple Developer Academy in Naples. A 9‑month, English-language program on app development, design, and marketing in Apple’s ecosystem. Open to anyone with a high school diploma. Visit the official site for details and to apply.

Beyond the Human: Designing with Non-Human Personas in Mobile Apps

Advocates non‑human personas to design for environmental impact. Prefer predictable fetch over push, mute threads, cache on device, and reduce rendering to cut energy/water/CO₂. Use credible ecological data. Takeaway: embed sustainability in networking, notifications, background work.

Solid Interfaces for visionOS: Widgets and Cognitive Space in Spatial Computing

Introduces the Proxemic Scaling Framework (PSF) and Cognitive Tensegrity model for designing visionOS spatial widgets. Presents K.I.T.E. UX, a WebXR tool for real-time ergonomic validation of spatial layouts using seven proxemic zones (Z1-Z7) and three tension types. Covers distance/scale relationships, persistent widget placement, allocentric vs egocentric cognition, and neuroergonomic design principles. Addresses neurodiversity considerations and cultural spatial differences. Demonstrates how spatial interfaces require grammars rather than patterns, moving from episodic UI to persistent cognitive environments.

Branding with AI: Superpowers for Indie Creators

AI’s value for indie iOS devs is branding, not just speed: use tools (e.g., Xcode AI) to mine reviews, localize tone, and keep copy/UX consistent across touchpoints and App Store assets. Encode brand in SwiftUI. Humans set values; AI scales coherence.

Sharing content among apps using AppEntity and Transferable protocol

Learn to share app data across apps by making an AppIntents AppEntity conform to CoreTransferable's Transferable. Define transferRepresentation with ProxyRepresentation exporting a String and optional visibility(.all). Validate via Shortcuts using Open Book + Share with Apps to Notes.

K.I.T.E. UX: The First Spatial Ergonomics Benchmark for XR

K.I.T.E. UX is a web-based prototyping tool for spatial computing that bridges the gap between 2D design mockups and 3D implementation. It allows designers to benchmark spatial ergonomics, create wireframes for visionOS, and validate layouts before coding. The tool addresses the problem of uncomfortable layouts that feel balanced in 2D but become intrusive in 3D space, providing feedback on distance, field of view, posture, and scale. Key features include spatial UI composition, ergonomic warnings, XR preview via WebXR, and JSON export for SwiftUI implementation.

Managing simultaneous, in sequence and exclusive gestures

How to compose SwiftUI gestures: chain LongPress → Drag with SequenceGesture (.sequenced) and manage state via @GestureState + .updating/.onChanged; run Drag and Rotate together with .simultaneously(with:); make Tap vs LongPress exclusive with ExclusiveGesture. Apply via .offset, .rotationEffect, .scaleEffect.

Providing access to premium features with StoreKit 2

Build tiered subscriptions (Individual/Family) in SwiftUI with StoreKit 2. Create a StoreKit config, map levelOfService to tiers, finish transactions, observe Transaction.updates, show SubscriptionStoreView, and use manageSubscriptionsSheet. Tip: monthly/yearly share a level.

Crafting document-based apps in SwiftUI

How to build document‑based apps in SwiftUI with DocumentGroup: implement FileDocument (or ReferenceFileDocument for snapshot/class models), define UTType via UniformTypeIdentifiers, and mirror them in Info.plist (CFBundleDocumentTypes, UTExported/Imported). Match IDs; rely on system browsing/saving.

Creating reminder lists with EventKit from your app

Create Reminders lists with EventKit: request full access via EKEventStore, load calendars(for: .reminder) and sources, create/save an EKCalendar with a valid EKSource (local/CalDAV or default), then add EKReminder with dueDateComponents. SwiftUI Picker/DatePicker UI. Include Reminders Full Access usage description.

Understanding gesture hierarchy

Manage gesture precedence in SwiftUI: use GestureMask with gesture(_:including:) to control scope (.all, .gesture, .subviews, .none); use highPriorityGesture to override other gestures; use defersSystemGestures(on:) to defer edge gestures. Priority is per view.

Understanding Spring Animations in SwiftUI

Guide to SwiftUI spring animations for responsive UI. Shows .spring() defaults, tuning response and dampingFraction, choosing withAnimation vs .animation(_:value:), and using .interactiveSpring() for gestures. Examples: expanding box, draggable card, custom toggle. Use springs for user-driven motion; not for loaders.

Contact Management: Working with the Contact Picker View Controller

Integrate CNContactPickerViewController (ContactsUI) into SwiftUI using UIViewControllerRepresentable and a Coordinator conforming to CNContactPickerDelegate. Add the Contacts usage description to Info.plist, request CNContactStore access, present via .sheet, and send selected name/phone to a ViewModel.

Implementing Consumable In-App Purchases with StoreKit 2

Consumable IAP with StoreKit 2 in SwiftUI: use ProductView(id:) and onInAppPurchaseCompletion, verify then finish transactions. Test via StoreKit config (scheme), then create the product in App Store Connect. Caveat: not refundable in transaction manager.

Implementing subscriptions In-App Purchases with StoreKit 2

Implement auto‑renewable subscriptions with StoreKit 2 in SwiftUI: create a StoreKit config (don’t sync), add a group with monthly/yearly products, present SubscriptionStoreView, select the config in Edit Scheme, test on device and reset via Manage Transactions, then mirror setup in App Store Connect (IDs, duration, pricing, localization).

Understanding scenes for your macOS app

Guide to SwiftUI scenes on macOS: WindowGroup (basic and data-driven; openWindow(value:) with one-window-per-value/state restoration), Window (single-instance via id), UtilityWindow for panels, DocumentGroup+FileDocument (sandbox file entitlements), Settings, and MenuBarExtra (.menu/.window).

The power of ethics in mobile design

Ethical mobile design: be transparent with permissions, minimize attention grabs, and design inclusive, accessible UIs (SwiftUI accessibilityLabel). Optimize energy/network use, audit AI bias/data, and treat community and environment as stakeholders.

Designing with people: Creating applications for reality

Apps often fail by designing for individuals, not communities. The article promotes co-design: engage, gather, understand, implement, test—design with people to uncover real needs. Use shared language, gestures/vibration, and calm visuals to cut cognitive load; iterate with communities for adoption.

Creating Contacts with SwiftUI

Create contacts in a SwiftUI app with the Contacts framework: build a CNMutableContact, set fields (name, phone via CNLabeledValue/CNPhoneNumber), then save using CNSaveRequest and CNContactStore. Handle permission with requestAccess (async/await). Test on Simulator/device; Xcode Preview isn’t supported.

Implementing Non-Consumable In-App Purchases with StoreKit 2

Implement a non‑consumable IAP with StoreKit 2 in SwiftUI: create a StoreKit config, add a product, show it with ProductView, select the config in Scheme, test and refund in Debug > StoreKit > Manage Transactions. Then create it in App Store Connect and test with TestFlight. Don’t sync the config; tests don’t charge.

Enabling drag-and-drop and clipboard operations with the Transferable protocol

Enable copy/paste and drag & drop by making your model Transferable. Define transferRepresentation with DataRepresentation(.plainText) + ProxyRepresentation, use UIPasteboard for clipboard, and SwiftUI .draggable/.dropDestination(for:) to move NoteItem values.

Understanding the Transferable Protocol in Swift

How to use Core Transferable’s Transferable to make models shareable via drag/drop, PasteButton, and ShareLink. Define transferRepresentation using Codable/Data/File, use ProxyRepresentation, and declare UTType for custom types. Shows a DataRepresentation example mapping Post.text to Data.

Responding to gestures: Rotating

Handle two-finger rotation in SwiftUI using RotateGesture. Set a minimum activation threshold with minimumAngleDelta (default 1°). Update state in onChanged (e.g., currentAngle = value.rotation), attach with .gesture, and apply rotationEffect to rotate the view.

Managing In-App Purchases in your apps

Overview of App Store monetization with StoreKit 2: set up IAPs in App Store Connect; choose between Non‑Consumable/Consumable and Non‑renewing/Auto‑renewable subscriptions; pricing and MRR tradeoffs; pointers to WWDC sessions for SwiftUI integration.

Designing Humanist Data Visualization for Mobile

How to design human-centered data visualization on mobile: map data types to user goals, prefer simple charts (bars, pie, rings), use tap/scroll (no hover), high contrast, screen reader and color‑independent cues, fast loads. Test with real data, edge cases, localization/RTL, devices. Be ethical and transparent; use AI to surface patterns—not write the story.

Building Peer-to-Peer Sessions: Sending and Receiving Data with Multipeer Connectivity

Send/receive data with Multipeer Connectivity: set up MCPeerID and MCSession (.required encryption), send UTF‑8 Data to session.connectedPeers via send(..., .reliable). Implement MCSessionDelegate to observe state and handle didReceive on the main thread; invite peers using MCNearbyServiceBrowser.

Building Peer-to-Peer Sessions: Advertising and Browsing Devices

Guide to discover/connect peers with Multipeer Connectivity. Add NSLocalNetworkUsageDescription and NSBonjourServices. Build PeerSessionManager with MCPeerID, MCSession(.required), MCNearbyServiceAdvertiser/Browser and delegates; track discovered/connected peers; start/stop; auto-accept invites.

Prompting users to review your app

How to prompt App Store reviews with StoreKit 2’s RequestReviewAction in SwiftUI. Use @Environment(\.requestReview), delay with Task.sleep, and track per‑version prompts via UserDefaults. Follow timing best practices; iOS may disable requests; Apple limits to 3 prompts/365 days.

Tracking workouts with HealthKit in iOS apps

Build an iOS HealthKit workout tracker (iOS 26): set Info.plist + request auth; configure HKWorkoutConfiguration/Session and HKLiveWorkoutBuilder/DataSource; update metrics (HR, kcal, distance); manage start/pause/resume/end in SwiftUI; save via finishWorkout(). Device-only.

Creating Ornaments in visionOS

Guide to visionOS ornaments: keep important controls/info attached to a window. Prefer system TabView tab bars and toolbars (.toolbar, .bottomOrnament). Covers SwiftUI ornament(visibility:attachmentAnchor:contentAlignment:), UnitPoint/UnitPoint3D, scene/parent anchors, and design tips (glass, borderless buttons, sizing).

Creative Coding: Randomness and Noise

Shows generative art in SwiftUI using randomness and noise. Draw/animate with Canvas, Path, TimelineView; define a NoiseGenerator protocol (Uniform/Non‑Uniform) to distort paths. Notes Perlin/Simplex/Worley and sensors for organic, controllable motion.

Making Apps More Personal with Language Discovery

iOS 26’s Language Discovery infers user languages on-device and exposes rich Locale data via Locale.preferredLocales. Sample SwiftUI managers/picker match exact or language-code, prioritize user locales, and display RTL, calendar, numbering, and currency for culturally aware UX.

Create with Swift at Pragma Conference 2025

Recap of a Pragma 2025 session on creative coding with Swift, SwiftUI, and Xcode—no new tools needed. Covers a workflow of drawing simple shapes, animating them, and adding randomness/noise. Includes links to intro articles and a GitHub repo with SwiftUI examples.

Liquid Glass: Redefining design through Hierarchy, Harmony and Consistency

Apple’s Liquid Glass (iOS 26 HIG) shifts to content‑ and interaction‑driven UIs: dynamic hierarchy (adaptive tab/toolbar, grouped actions), harmony via glass materials aligned to hardware, and cross‑device consistency. Guidance: prioritize clarity, think in systems, use materials/motion purposefully.

Text Effects using TextRenderer in SwiftUI

Guide to SwiftUI’s iOS 18 TextRenderer: implement draw(layout:in:) using Text.Layout and GraphicsContext to control text. Build line fades, line pulse (Animatable + scaling), per‑glyph bounce via TextAttribute with optional blur, and run-level floating. Tips: copy context to isolate; transform/filter order matters.

Exploring Widgets: Crafting glanceable experiences

Guide to crafting widgets as glanceable, persistent, snapshot-based surfaces (vs notifications/Live Activities). Reduce cognitive load: single task, clear hierarchy, proven layouts, brand consistency, personalization. For visionOS: spatial persistence, legibility, Paper/Glass, proximity-aware views.

Integrating Device Camera in SwiftUI Apps

SwiftUI lacks a camera API. This guide bridges AVFoundation via UIKit: build a CameraManager (AVCaptureSession, AVCapturePhotoOutput, AVCaptureVideoPreviewLayer), a UIViewRepresentable preview, and SwiftUI views using @ObservedObject/@State and a capture delegate. Covers begin/commit config, cleanup, and fullScreenCover.

Using rich text in the TextEditor with SwiftUI

Use SwiftUI TextEditor with AttributedString for rich text. Covers Markdown parsing, composing text, selections via AttributedTextSelection, reading typingAttributes, and transformAttributes(in:&selection) for normalized updates. Toolbar example uses fontResolutionContext to toggle bold.

Getting Started with Multipeer Connectivity in Swift

Starter guide to Multipeer Connectivity for nearby peer-to-peer networking without internet. Sets Info.plist keys (NSLocalNetworkUsageDescription, NSBonjourServices), creates MCPeerID and serviceID, MCSession (.required encryption), MCAdvertiserAssistant, MCBrowserViewController, delegates, plus a PeerHandler example.

Image caching in SwiftUI

AsyncImage doesn’t cache between views. This adds a SwiftUI CachedAsyncImage using NSCache: load from cache on appear, save after first load via URLSession. Thread-safe with limits, MainActor UI updates for smooth, faster repeats.

Building for Love: Creating Authentic Connections

Apps win by evoking emotion, not just working. Apply Emotional Design (visceral, behavioral, reflective), focus on a clear core feature, cut cognitive load, add forgiving flows (undo/autosave), respectful timing/personalization, and small delights to build trust and retention.

Taking control of your navigation in SwiftUI with NavigationPath

Shows how to take programmatic control of SwiftUI navigation using NavigationStack(path:root:) with a bound path. Use a typed [T] path for simple, type-safe stacks, or a type-erased NavigationPath for multiple types. Push via path.append, pop via removeAll/removeLast. Define navigationDestination(for:) per type or you’ll get an empty view.

Performing search with SwiftData in a SwiftUI app

Connect SwiftUI’s searchable(text:placement:prompt:) to SwiftData by building a dynamic @Query with #Predicate. Pass searchText into a separate ItemListView so the query reinitializes, filters at the DB level (using localizedStandardContains), sorts by name, and shows empty/result states.

Programmatic navigation with navigation destination in SwiftUI

SwiftUI programmatic navigation with NavigationStack: navigationDestination(isPresented:) for boolean triggers; navigationDestination(item:) for Hashable selections; .navigationDestination(for:) + NavigationPath/NavigationLink(value:) for type‑driven flows.

Implementing draw animations for SF Symbols in SwiftUI

How to use SF Symbols 7 draw animations in SwiftUI (iOS 26) via .symbolEffect(.drawOn/.drawOff, options:isActive:). Choose .wholeSymbol, .byLayer (default), or .individually. Customize with .nonRepeating, .speed(_), .repeat(.continuous). Control with state-bound isActive to trigger animations.

Presenting critical information in SwiftUI with alerts

How to present critical information in SwiftUI with .alert: boolean-driven alerts, optional message, item-specific alerts using presenting, and error alerts using LocalizedError with recoverySuggestion. Includes guidance on clear actions, roles (.destructive/.cancel), minimal choices, and using alerts sparingly.

Implementing drag and drop with the SwiftUI modifiers

Guide to implementing drag and drop in SwiftUI using onDrag and onDrop. Uses NSItemProvider + UniformTypeIdentifiers to transfer data, encoding custom models to JSON (Codable) and decoding on drop. Handles isTargeted feedback, async loading to main thread, and covers preview and delegate options.

Playback controls for video in a SwiftUI app

Implement custom video controls in SwiftUI with AVKit’s VideoPlayer: play/pause via isPlaying, stop using pause() + seek(.zero), 10‑sec skip/back using currentTime, CMTime(preferredTimescale: 600) and max/min clamping, plus a Slider bound to currentTime/duration that seeks after editing.

Playing a video in a SwiftUI app

Beginner tutorial showing how to play a local video in SwiftUI with AVKit. Initialize an @State AVPlayer from a bundled mp4 and pass it to VideoPlayer for native playback controls. Style with SwiftUI modifiers and layer over a card layout via ZStack/VStack.

Listing contacts with the Contacts framework

Fetch contacts with Contacts: select CNKeyDescriptor keys (given/family names, phone numbers), create CNContactFetchRequest (optional predicate), and enumerate via CNContactStore.enumerateContacts to build results. Access requires user authorization.

Getting started with the Contacts framework

Intro to Contacts on iOS: add Privacy - Contacts Usage Description, use CNContactStore to requestAccess(for: .contacts) and read authorizationStatus(for:). A SwiftUI ViewModel (@MainActor, ObservableObject) uses async/await to request permission and show CNAuthorizationStatus in the UI.

Creating custom layouts with SwiftUI

Create custom SwiftUI layouts with the Layout protocol by implementing sizeThatFits and placeSubviews using ProposedViewSize and Subviews. Example FixedSpacer shows fixed spacing and vertical centering—yielding precise, reusable control and better performance than GeometryReader.

Understanding Live Activities: visual micro-storytelling

Explains how to design Live Activities for Lock Screen, Dynamic Island, StandBy, and the Watch Smart Stack. Covers four use cases—Tracking, Timer, Phases, Updates—when not to use them, and key design rules: hierarchy, brand restraint, contextual visuals, progressive disclosure, respectful persistence.

Displaying web content in SwiftUI

WWDC25 brings SwiftUI’s native WebView (WebKit) for iOS 26+. Use WebView(url:) for quick loads or WebView(_:) with WebPage for granular control, observable state, and async JavaScript via callJavaScript. Configure with SwiftUI modifiers (navigation, zoom, previews). No UIKit bridge; better memory/state sync.

Lazy-loading views with LazyVStack in SwiftUI

Why VStack struggles with large lists and how LazyVStack fixes it by lazily creating rows only when visible. Use it inside ScrollView with ForEach and stable IDs. Avoid storing critical state in cells; prefer @StateObject/@ObservableObject/@Observable (~80–90% less RAM).

Exploring Concentricity in SwiftUI

Explains Apple’s concentricity design principle and how to build concentric UI in SwiftUI using the new ConcentricRectangle (iOS 26). Shows fill/padding, choosing corners with .concentric(minimum:), isUniform for sheets/popovers, and inheriting a container’s corner radius.

Adapting your widgets for visionOS

Guide to adapting widgets for visionOS: add the new systemExtraLargePortrait to supportedFamilies, use tinting, and choose placement with supportedMountingStyles (.elevated, .recessed). Select Paper or Glass via widgetTexture. Widgets appear only in AR, not full immersion.

Enhancing the tab bar with a bottom accessory

Shows how to add a persistent control above a TabView using tabViewBottomAccessory(_:), introduced with iOS 26’s Liquid Glass. Enable integration on scroll with tabBarMinimizeBehavior(.onScrollDown). Explains expanded vs inline placements. Note: placement detection is flaky in iOS 26 beta.

Design as brand: The power of choice and belief

Brand is shaped by your iOS app’s interactions. Lean on HIG and express values via icon, splash, onboarding, haptics, and notifications. Co-create with the community, use A/B tests and analytics without flattening identity, avoid deceptive patterns, and choose bold authenticity.

Making the tab bar collapse while scrolling

The new SwiftUI tabBarMinimizeBehavior modifier in iOS 26 lets TabView’s tab bar collapse on scroll, aligning with Liquid Glass’s content-first design. Covers .automatic/.never and iPhone-only .onScrollDown/.onScrollUp, plus pairing with TabRole (e.g., .search).

Adapting toolbar elements to the Liquid Glass Design System

SwiftUI toolbars for iOS 26’s Liquid Glass: symbol‑first overlay. Use ToolbarItem confirmation/cancellation placements, .glassProminent for full‑surface tint, and structure with ToolbarItemGroup and ToolbarSpacer. Group by role; avoid mixing text with symbols.

Checking and editing the details of a calendar event

Integrates EventKitUI with SwiftUI to view, create, and edit Calendar events. ViewModel uses EKEventStore with async permission and predicate-based fetch, plus template events. Wraps EventKit UI controllers via UIViewControllerRepresentable and delegates; refreshes on dismiss.

Setting alarms for calendar events

How to add EventKit alarms to calendar events. Create EKAlarm with absoluteDate or relativeOffset (negative = before start), attach via event.addAlarm(_:), and save. Events can hold multiple alarms. Requires calendar access. Mentions geofenced alarms and macOS alarm types.

Fetching events from the user’s calendar

Retrieve calendar events with EventKit: initialize EKEventStore, request access via requestFullAccessToEvents(), create a date-range predicate with predicateForEvents(withStart:end:calendars:), fetch using events(matching:), sort by startDate, and update state on MainActor. User consent required.

Creating and saving calendar events

Guide to creating/saving Calendar events in SwiftUI with EventKit: add NSCalendarsFullAccessUsageDescription, reuse a single EKEventStore, requestFullAccessToEvents (iOS 17+, async), create EKEvent, set title/start/end/defaultCalendarForNewEvents, save via save(_:span:).

Getting access to the user’s calendar

How to request and manage access to a user’s Calendar and Reminders with EventKit. Add Info.plist usage strings, use EKEventStore to requestFullAccessToEvents/Reminders or write-only events, check authorizationStatus(for:). Provides a SwiftUI view model to track/request permissions. Test on device/Simulator.

Designing custom AlarmKit interfaces in SwiftUI

Design AlarmKit UIs in SwiftUI: set Stop/Secondary buttons via AlarmPresentation.Alert; pick secondaryButtonBehavior (.countdown/.custom); apply tint with AlarmAttributes.tintColor; attach AlarmMetadata (Codable/Hashable/Sendable; Color unsupported).

Scheduling and Managing Alarms in SwiftUI with AlarmKit

How to schedule alarms with AlarmKit in SwiftUI: add NSAlarmKitUsageDescription, request/check authorization via AlarmManager.shared, build AlarmPresentation.Alert and AlarmAttributes, then schedule a .timer(duration:) via .schedule(id:configuration:). Demo uses a button and TimelineView; alert fires with screen off.

Exploring the Foundation Models framework

Hands-on tour of iOS 26’s Foundation Models for on-device Apple Intelligence: obtain SystemLanguageModel, build LanguageModelSession, use respond and streamResponse; generate typed output with @Generable/@Guide; define Tool calls; tune GenerationOptions. Check availability/guardrails. Beta API; may change.

Implementing advanced speech-to-text in your SwiftUI app

Implement real-time speech-to-text in SwiftUI with Apple’s SpeechAnalyzer. Capture mic audio via AVAudioEngine (.measurement, .duckOthers), convert with AVAudioConverter, and feed AsyncStream to SpeechTranscriber. Manage SFSpeech/mic permissions, handle volatile results, and add Microphone/Speech Recognition capabilities.