Ios Application Dev

iOS Application Development Guide

A practical guide for building iOS applications using UIKit, SnapKit, and SwiftUI. Focuses on proven patterns and Apple platform conventions.

Quick Reference

UIKit

SwiftUI

Core Principles

Layout

• Touch targets >= 44pt
• Content within safe areas (SwiftUI respects by default, use .ignoresSafeArea() only for backgrounds)
• Use 8pt spacing increments (8, 16, 24, 32, 40, 48)
• Primary actions in thumb zone
• Support all screen sizes (iPhone SE 375pt to Pro Max 430pt)

Typography

• UIKit: preferredFont(forTextStyle:) + adjustsFontForContentSizeCategory = true
• SwiftUI: semantic text styles .headline, .body, .caption
• Custom fonts: UIFontMetrics / Font.custom(_:size:relativeTo:)
• Adapt layout at accessibility sizes (minimum 11pt)

Colors

• Use semantic system colors (.systemBackground, .label, .primary, .secondary)
• Asset catalog variants for custom colors (Any/Dark Appearance)
• No color-only information (pair with icons or text)
• Contrast ratio >= 4.5:1 for normal text, 3:1 for large text

Accessibility

• Labels on icon buttons (.accessibilityLabel())
• Reduce motion respected (@Environment(\.accessibilityReduceMotion))
• Logical reading order (.accessibilitySortPriority())
• Support Bold Text, Increase Contrast preferences

Navigation

• Tab bar (3-5 sections) stays visible during navigation
• Back swipe works (never override system gestures)
• State preserved across tabs (@SceneStorage, @State)
• Never use hamburger menus

Privacy & Permissions

• Request permissions in context (not at launch)
• Custom explanation before system dialog
• Support Sign in with Apple
• Respect ATT denial

Checklist

Layout

• [ ] Touch targets >= 44pt
• [ ] Content within safe areas
• [ ] Primary actions in thumb zone (bottom half)
• [ ] Flexible widths for all screen sizes (SE to Pro Max)
• [ ] Spacing aligns to 8pt grid

Typography

• [ ] Semantic text styles or UIFontMetrics-scaled custom fonts
• [ ] Dynamic Type supported up to accessibility sizes
• [ ] Layouts reflow at large sizes (no truncation)
• [ ] Minimum text size 11pt

Colors

• [ ] Semantic system colors or light/dark asset variants
• [ ] Dark Mode is intentional (not just inverted)
• [ ] No color-only information
• [ ] Text contrast >= 4.5:1 (normal) / 3:1 (large)
• [ ] Single accent color for interactive elements

Accessibility

• [ ] VoiceOver labels on all interactive elements
• [ ] Logical reading order
• [ ] Bold Text preference respected
• [ ] Reduce Motion disables decorative animations
• [ ] All gestures have alternative access paths

Navigation

• [ ] Tab bar for 3-5 top-level sections
• [ ] No hamburger/drawer menus
• [ ] Tab bar stays visible during navigation
• [ ] Back swipe works throughout
• [ ] State preserved across tabs

Components

• [ ] Alerts for critical decisions only
• [ ] Sheets have dismiss path (button and/or swipe)
• [ ] List rows >= 44pt tall
• [ ] Destructive buttons use .destructive role

Privacy

• [ ] Permissions requested in context (not at launch)
• [ ] Custom explanation before system permission dialog
• [ ] Sign in with Apple offered with other providers
• [ ] Basic features usable without account
• [ ] ATT prompt shown if tracking, denial respected

System Integration

• [ ] App handles interruptions gracefully (calls, background, Siri)
• [ ] App content indexed for Spotlight
• [ ] Share Sheet available for shareable content

References

---

Swift, SwiftUI, UIKit, SF Symbols, Metal, and Apple are trademarks of Apple Inc. SnapKit is a trademark of its respective owners.

Accessibility

iOS accessibility guide covering Dynamic Type, semantic colors, VoiceOver, and motion adaptation.

Dynamic Type

Using System Fonts

private func setupLabels() {
    let titleLabel = UILabel()
    titleLabel.font = .preferredFont(forTextStyle: .headline)
    titleLabel.adjustsFontForContentSizeCategory = true
    
    let bodyLabel = UILabel()
    bodyLabel.font = .preferredFont(forTextStyle: .body)
    bodyLabel.adjustsFontForContentSizeCategory = true
    bodyLabel.numberOfLines = 0
}

Custom Font Scaling

extension UIFont {
    static func scaled(_ name: String, size: CGFloat, for style: TextStyle) -> UIFont {
        guard let font = UIFont(name: name, size: size) else {
            return .preferredFont(forTextStyle: style)
        }
        return UIFontMetrics(forTextStyle: style).scaledFont(for: font)
    }
}

let customFont = UIFont.scaled("Avenir-Medium", size: 16, for: .body)

Text Style Reference

Adapting Layout for Large Text

override func traitCollectionDidChange(_ previous: UITraitCollection?) {
    super.traitCollectionDidChange(previous)
    
    let isLargeText = traitCollection.preferredContentSizeCategory.isAccessibilityCategory
    contentStack.axis = isLargeText ? .vertical : .horizontal
    
    if isLargeText {
        iconImageView.snp.remakeConstraints { make in
            make.size.equalTo(64)
        }
    } else {
        iconImageView.snp.remakeConstraints { make in
            make.size.equalTo(44)
        }
    }
}

Semantic Colors

Use system semantic colors for automatic Dark Mode adaptation:

view.backgroundColor = .systemBackground
containerView.backgroundColor = .secondarySystemBackground
cardView.backgroundColor = .tertiarySystemBackground

titleLabel.textColor = .label
subtitleLabel.textColor = .secondaryLabel
hintLabel.textColor = .tertiaryLabel
placeholderLabel.textColor = .placeholderText

separatorView.backgroundColor = .separator
borderView.layer.borderColor = UIColor.separator.cgColor

System Color Reference

Custom Color Adaptation

extension UIColor {
    static let customAccent = UIColor { traitCollection in
        switch traitCollection.userInterfaceStyle {
        case .dark:
            return UIColor(red: 0.4, green: 0.8, blue: 1.0, alpha: 1.0)
        default:
            return UIColor(red: 0.0, green: 0.5, blue: 0.8, alpha: 1.0)
        }
    }
}

VoiceOver

Basic Labels

let cartButton = UIButton(type: .system)
cartButton.setImage(UIImage(systemName: "cart.badge.plus"), for: .normal)
cartButton.accessibilityLabel = "Add to cart"

let ratingView = UIView()
ratingView.accessibilityLabel = "Rating: 4 out of 5 stars"

let closeButton = UIButton()
closeButton.accessibilityLabel = "Close"
closeButton.accessibilityHint = "Dismisses this dialog"

Custom Accessibility

class ProductCell: UICollectionViewCell {
    override var accessibilityLabel: String? {
        get {
            return "\(product.name), \(product.price), \(product.isAvailable ? "In stock" : "Out of stock")"
        }
        set {}
    }
    
    override var accessibilityTraits: UIAccessibilityTraits {
        get {
            var traits: UIAccessibilityTraits = .button
            if product.isSelected {
                traits.insert(.selected)
            }
            return traits
        }
        set {}
    }
}

Accessibility Container

class CustomContainerView: UIView {
    override var isAccessibilityElement: Bool {
        get { false }
        set {}
    }
    
    override var accessibilityElements: [Any]? {
        get {
            return [titleLabel, actionButton, detailLabel]
        }
        set {}
    }
}

VoiceOver Notifications

func didLoadContent() {
    UIAccessibility.post(notification: .screenChanged, argument: headerLabel)
}

func didUpdateStatus() {
    UIAccessibility.post(notification: .announcement, argument: "Download complete")
}

Reduce Motion

func animateTransition() {
    let duration: TimeInterval = UIAccessibility.isReduceMotionEnabled ? 0 : 0.3
    UIView.animate(withDuration: duration) {
        self.cardView.alpha = 1
    }
}

func showPopup() {
    if UIAccessibility.isReduceMotionEnabled {
        popupView.alpha = 1
    } else {
        popupView.transform = CGAffineTransform(scaleX: 0.8, y: 0.8)
        popupView.alpha = 0
        UIView.animate(withDuration: 0.3, delay: 0, usingSpringWithDamping: 0.7, initialSpringVelocity: 0) {
            self.popupView.transform = .identity
            self.popupView.alpha = 1
        }
    }
}

Observing Setting Changes

NotificationCenter.default.addObserver(
    self,
    selector: #selector(reduceMotionChanged),
    name: UIAccessibility.reduceMotionStatusDidChangeNotification,
    object: nil
)

@objc func reduceMotionChanged() {
    updateAnimationSettings()
}

Accessibility Checklist

Basic Requirements

• [ ] All icon buttons have accessibilityLabel
• [ ] Custom controls have correct accessibilityTraits
• [ ] Images have accessibilityLabel or marked as decorative
• [ ] Forms have clear error messages

Dynamic Type

• [ ] Using preferredFont(forTextStyle:)
• [ ] Set adjustsFontForContentSizeCategory = true
• [ ] Layout adapts at accessibility sizes
• [ ] Text is not truncated

Color Contrast

• [ ] Body text contrast >= 4.5:1
• [ ] Large text contrast >= 3:1
• [ ] Information not conveyed by color alone

Motion

• [ ] Respect Reduce Motion setting
• [ ] No flashing or rapid animation
• [ ] Auto-playing animations can be paused

Interaction

• [ ] Touch targets >= 44x44pt
• [ ] Gestures have alternative actions
• [ ] Timeouts can be extended

---

UIKit, VoiceOver, Dynamic Type, and Apple are trademarks of Apple Inc.

Graphics & Animation

iOS graphics and animation guide covering CAShapeLayer, CAGradientLayer, UIBezierPath, and Core Animation.

CAShapeLayer

For custom shapes, paths, and animations:

class CircularProgressView: UIView {
    private let trackLayer = CAShapeLayer()
    private let progressLayer = CAShapeLayer()
    
    var progress: CGFloat = 0 {
        didSet { updateProgress() }
    }
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupLayers()
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        setupLayers()
    }
    
    private func setupLayers() {
        let center = CGPoint(x: bounds.midX, y: bounds.midY)
        let radius = min(bounds.width, bounds.height) / 2 - 10
        let startAngle = -CGFloat.pi / 2
        let endAngle = startAngle + 2 * CGFloat.pi
        
        let circularPath = UIBezierPath(
            arcCenter: center,
            radius: radius,
            startAngle: startAngle,
            endAngle: endAngle,
            clockwise: true
        )
        
        trackLayer.path = circularPath.cgPath
        trackLayer.strokeColor = UIColor.systemGray5.cgColor
        trackLayer.fillColor = UIColor.clear.cgColor
        trackLayer.lineWidth = 10
        trackLayer.lineCap = .round
        layer.addSublayer(trackLayer)
        
        progressLayer.path = circularPath.cgPath
        progressLayer.strokeColor = UIColor.systemBlue.cgColor
        progressLayer.fillColor = UIColor.clear.cgColor
        progressLayer.lineWidth = 10
        progressLayer.lineCap = .round
        progressLayer.strokeEnd = 0
        layer.addSublayer(progressLayer)
    }
    
    override func layoutSubviews() {
        super.layoutSubviews()
        setupLayers()
    }
    
    private func updateProgress() {
        progressLayer.strokeEnd = progress
    }
    
    func animateProgress(to value: CGFloat, duration: TimeInterval = 0.5) {
        let animation = CABasicAnimation(keyPath: "strokeEnd")
        animation.fromValue = progressLayer.strokeEnd
        animation.toValue = value
        animation.duration = duration
        animation.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
        progressLayer.strokeEnd = value
        progressLayer.add(animation, forKey: "progressAnimation")
    }
}

UIBezierPath

Common Shapes

let roundedRect = UIBezierPath(
    roundedRect: bounds,
    cornerRadius: 12
)

let customCorners = UIBezierPath(
    roundedRect: bounds,
    byRoundingCorners: [.topLeft, .topRight],
    cornerRadii: CGSize(width: 16, height: 16)
)

let triangle = UIBezierPath()
triangle.move(to: CGPoint(x: bounds.midX, y: 0))
triangle.addLine(to: CGPoint(x: bounds.maxX, y: bounds.maxY))
triangle.addLine(to: CGPoint(x: 0, y: bounds.maxY))
triangle.close()

let circle = UIBezierPath(
    arcCenter: CGPoint(x: bounds.midX, y: bounds.midY),
    radius: bounds.width / 2,
    startAngle: 0,
    endAngle: .pi * 2,
    clockwise: true
)

Custom Paths

let customPath = UIBezierPath()
customPath.move(to: CGPoint(x: 0, y: bounds.height))
customPath.addCurve(
    to: CGPoint(x: bounds.width, y: 0),
    controlPoint1: CGPoint(x: bounds.width * 0.3, y: bounds.height),
    controlPoint2: CGPoint(x: bounds.width * 0.7, y: 0)
)

CAGradientLayer

Linear Gradient Button

class GradientButton: UIButton {
    private let gradientLayer = CAGradientLayer()
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupGradient()
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        setupGradient()
    }
    
    private func setupGradient() {
        gradientLayer.colors = [
            UIColor.systemBlue.cgColor,
            UIColor.systemPurple.cgColor
        ]
        gradientLayer.startPoint = CGPoint(x: 0, y: 0.5)
        gradientLayer.endPoint = CGPoint(x: 1, y: 0.5)
        gradientLayer.cornerRadius = 12
        layer.insertSublayer(gradientLayer, at: 0)
    }
    
    override func layoutSubviews() {
        super.layoutSubviews()
        gradientLayer.frame = bounds
    }
}

Gradient Background View

class GradientBackgroundView: UIView {
    private let gradientLayer = CAGradientLayer()
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupGradient()
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        setupGradient()
    }
    
    private func setupGradient() {
        gradientLayer.colors = [
            UIColor.systemBackground.cgColor,
            UIColor.secondarySystemBackground.cgColor
        ]
        gradientLayer.locations = [0.0, 1.0]
        gradientLayer.startPoint = CGPoint(x: 0.5, y: 0)
        gradientLayer.endPoint = CGPoint(x: 0.5, y: 1)
        layer.insertSublayer(gradientLayer, at: 0)
    }
    
    override func layoutSubviews() {
        super.layoutSubviews()
        gradientLayer.frame = bounds
    }
    
    override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
        super.traitCollectionDidChange(previousTraitCollection)
        gradientLayer.colors = [
            UIColor.systemBackground.cgColor,
            UIColor.secondarySystemBackground.cgColor
        ]
    }
}

Gradient Types

Core Animation

Basic Animation

func animateScale() {
    let animation = CABasicAnimation(keyPath: "transform.scale")
    animation.fromValue = 1.0
    animation.toValue = 1.2
    animation.duration = 0.3
    animation.autoreverses = true
    animation.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
    layer.add(animation, forKey: "scaleAnimation")
}

func animatePosition() {
    let animation = CABasicAnimation(keyPath: "position")
    animation.fromValue = layer.position
    animation.toValue = CGPoint(x: 200, y: 200)
    animation.duration = 0.5
    layer.add(animation, forKey: "positionAnimation")
}

Keyframe Animation

func animateAlongPath() {
    let path = UIBezierPath()
    path.move(to: CGPoint(x: 50, y: 50))
    path.addCurve(
        to: CGPoint(x: 250, y: 250),
        controlPoint1: CGPoint(x: 150, y: 50),
        controlPoint2: CGPoint(x: 50, y: 250)
    )
    
    let animation = CAKeyframeAnimation(keyPath: "position")
    animation.path = path.cgPath
    animation.duration = 2.0
    animation.timingFunction = CAMediaTimingFunction(name: .easeInEaseOut)
    layer.add(animation, forKey: "pathAnimation")
}

Animation Group

func animateMultiple() {
    let scaleAnimation = CABasicAnimation(keyPath: "transform.scale")
    scaleAnimation.fromValue = 1.0
    scaleAnimation.toValue = 1.5
    
    let opacityAnimation = CABasicAnimation(keyPath: "opacity")
    opacityAnimation.fromValue = 1.0
    opacityAnimation.toValue = 0.0
    
    let group = CAAnimationGroup()
    group.animations = [scaleAnimation, opacityAnimation]
    group.duration = 0.5
    group.fillMode = .forwards
    group.isRemovedOnCompletion = false
    
    layer.add(group, forKey: "multipleAnimations")
}

Spring Animation

func springAnimation() {
    let spring = CASpringAnimation(keyPath: "transform.scale")
    spring.fromValue = 0.8
    spring.toValue = 1.0
    spring.damping = 10
    spring.stiffness = 100
    spring.mass = 1
    spring.initialVelocity = 5
    spring.duration = spring.settlingDuration
    layer.add(spring, forKey: "springAnimation")
}

UIView Animation

Basic UIView Animation

UIView.animate(withDuration: 0.3) {
    self.view.alpha = 1.0
    self.view.transform = .identity
}

UIView.animate(withDuration: 0.3, delay: 0, options: [.curveEaseInOut]) {
    self.cardView.frame.origin.y = 100
} completion: { _ in
    self.didFinishAnimation()
}

Spring Animation

UIView.animate(
    withDuration: 0.6,
    delay: 0,
    usingSpringWithDamping: 0.7,
    initialSpringVelocity: 0.5,
    options: []
) {
    self.popupView.transform = .identity
}

Keyframe Animation

UIView.animateKeyframes(withDuration: 1.0, delay: 0) {
    UIView.addKeyframe(withRelativeStartTime: 0, relativeDuration: 0.25) {
        self.view.transform = CGAffineTransform(scaleX: 1.2, y: 1.2)
    }
    UIView.addKeyframe(withRelativeStartTime: 0.25, relativeDuration: 0.25) {
        self.view.transform = CGAffineTransform(rotationAngle: .pi / 4)
    }
    UIView.addKeyframe(withRelativeStartTime: 0.5, relativeDuration: 0.5) {
        self.view.transform = .identity
    }
}

Timing Functions

---

UIKit, Core Animation, and Apple are trademarks of Apple Inc.

Layout System

iOS layout system guide covering touch targets, safe areas, UICollectionView, and Compositional Layout.

Touch Targets

Interactive elements need adequate tap areas. The recommended minimum is 44x44 points.

let actionButton = UIButton(type: .system)
actionButton.setTitle("Submit", for: .normal)
view.addSubview(actionButton)

actionButton.snp.makeConstraints { make in
    make.height.greaterThanOrEqualTo(44)
    make.leading.trailing.equalToSuperview().inset(16)
    make.bottom.equalTo(view.safeAreaLayoutGuide).offset(-16)
}

Use 8-point increments for spacing (8, 16, 24, 32, 40, 48) to maintain visual consistency.

Safe Area

Always constrain content to the safe area to avoid the notch, Dynamic Island, and home indicator.

class MainViewController: UIViewController {
    private let contentStack = UIStackView()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .systemBackground
        
        contentStack.axis = .vertical
        contentStack.spacing = 16
        view.addSubview(contentStack)
        
        contentStack.snp.makeConstraints { make in
            make.top.bottom.equalTo(view.safeAreaLayoutGuide)
            make.leading.trailing.equalTo(view.safeAreaLayoutGuide).inset(16)
        }
    }
}

UICollectionView with Diffable Data Source

class ItemsViewController: UIViewController {
    enum Section { case main }
    
    private var collectionView: UICollectionView!
    private var dataSource: UICollectionViewDiffableDataSource<Section, Item>!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupCollectionView()
        configureDataSource()
    }
    
    private func setupCollectionView() {
        var config = UICollectionLayoutListConfiguration(appearance: .insetGrouped)
        config.trailingSwipeActionsConfigurationProvider = { [weak self] indexPath in
            self?.makeSwipeActions(for: indexPath)
        }
        
        let layout = UICollectionViewCompositionalLayout.list(using: config)
        collectionView = UICollectionView(frame: .zero, collectionViewLayout: layout)
        
        view.addSubview(collectionView)
        collectionView.snp.makeConstraints { make in
            make.edges.equalToSuperview()
        }
    }
    
    private func configureDataSource() {
        let cellRegistration = UICollectionView.CellRegistration<UICollectionViewListCell, Item> { 
            cell, indexPath, item in
            var content = cell.defaultContentConfiguration()
            content.text = item.title
            content.secondaryText = item.subtitle
            cell.contentConfiguration = content
        }
        
        dataSource = UICollectionViewDiffableDataSource(collectionView: collectionView) { 
            collectionView, indexPath, item in
            collectionView.dequeueConfiguredReusableCell(
                using: cellRegistration, for: indexPath, item: item
            )
        }
    }
    
    func updateItems(_ items: [Item]) {
        var snapshot = NSDiffableDataSourceSnapshot<Section, Item>()
        snapshot.appendSections([.main])
        snapshot.appendItems(items)
        dataSource.apply(snapshot)
    }
}

Grid Layout

private func createGridLayout() -> UICollectionViewLayout {
    let itemSize = NSCollectionLayoutSize(
        widthDimension: .fractionalWidth(1/3),
        heightDimension: .fractionalHeight(1.0)
    )
    let item = NSCollectionLayoutItem(layoutSize: itemSize)
    item.contentInsets = NSDirectionalEdgeInsets(top: 2, leading: 2, bottom: 2, trailing: 2)
    
    let groupSize = NSCollectionLayoutSize(
        widthDimension: .fractionalWidth(1.0),
        heightDimension: .fractionalWidth(1/3)
    )
    let group = NSCollectionLayoutGroup.horizontal(layoutSize: groupSize, subitems: [item])
    
    let section = NSCollectionLayoutSection(group: group)
    return UICollectionViewCompositionalLayout(section: section)
}

Sectioned List with Headers

class CategorizedListVC: UIViewController {
    enum Section: Hashable {
        case favorites, recent, all
    }
    
    private var dataSource: UICollectionViewDiffableDataSource<Section, Item>!
    
    private func setupCollectionView() {
        var config = UICollectionLayoutListConfiguration(appearance: .insetGrouped)
        config.headerMode = .supplementary
        
        let layout = UICollectionViewCompositionalLayout.list(using: config)
        collectionView = UICollectionView(frame: .zero, collectionViewLayout: layout)
    }
    
    private func configureDataSource() {
        let cellRegistration = UICollectionView.CellRegistration<UICollectionViewListCell, Item> { 
            cell, indexPath, item in
            var content = cell.defaultContentConfiguration()
            content.text = item.title
            cell.contentConfiguration = content
        }
        
        let headerRegistration = UICollectionView.SupplementaryRegistration<UICollectionViewListCell>(
            elementKind: UICollectionView.elementKindSectionHeader
        ) { [weak self] header, elementKind, indexPath in
            guard let section = self?.dataSource.sectionIdentifier(for: indexPath.section) else { return }
            var content = header.defaultContentConfiguration()
            content.text = self?.title(for: section)
            header.contentConfiguration = content
        }
        
        dataSource = UICollectionViewDiffableDataSource(collectionView: collectionView) { 
            collectionView, indexPath, item in
            collectionView.dequeueConfiguredReusableCell(using: cellRegistration, for: indexPath, item: item)
        }
        
        dataSource.supplementaryViewProvider = { collectionView, kind, indexPath in
            collectionView.dequeueConfiguredReusableSupplementary(using: headerRegistration, for: indexPath)
        }
    }
    
    func applySnapshot(favorites: [Item], recent: [Item], all: [Item]) {
        var snapshot = NSDiffableDataSourceSnapshot<Section, Item>()
        if !favorites.isEmpty {
            snapshot.appendSections([.favorites])
            snapshot.appendItems(favorites, toSection: .favorites)
        }
        if !recent.isEmpty {
            snapshot.appendSections([.recent])
            snapshot.appendItems(recent, toSection: .recent)
        }
        snapshot.appendSections([.all])
        snapshot.appendItems(all, toSection: .all)
        dataSource.apply(snapshot)
    }
}

Spacing Guidelines

---

UIKit and Apple are trademarks of Apple Inc. SnapKit is a trademark of its respective owners.

Metal Shader Reference

Expert reference for Metal shaders, real-time rendering, and Apple's Tile-Based Deferred Rendering (TBDR) architecture.

Core Principles

Half precision first → Leverage TBDR → Function constant specialization → Use Intersector API

When to Use

• Metal Shading Language (MSL) development
• Apple GPU optimization (TBDR architecture)
• PBR rendering pipelines
• Compute shaders and parallel processing
• Apple Silicon ray tracing
• GPU profiling and debugging

When NOT to Use

• WebGL/GLSL (different architecture)
• CUDA (NVIDIA only)
• OpenGL (deprecated on Apple)
• CPU-side optimization

Expert vs Novice

Common Anti-Patterns

Metal Evolution

Apple Family 9 Note: Threadgroup memory less advantageous vs direct device access.

Shader Types

Rendering Techniques

Procedural Generation

Numerical Techniques

SwiftUI + MTKView Integration

Architecture Pattern

MetalView (UIViewRepresentable)
    └── Coordinator = Renderer (MTKViewDelegate)
            ├── MTLDevice
            ├── MTLCommandQueue
            ├── MTLRenderPipelineState
            └── MTLBuffer (vertices, uniforms)

Uniform Alignment Rules

Key: float3 aligns to 16 bytes. Use MemoryLayout<T>.size to verify.

Command Line Tools

GPU Debugging

Xcode Workflow

1. GPU Capture: ⌘⇧⌥G 2. Shader Profiler: Select draw call → View Shader 3. Memory Viewer: Inspect buffer/texture 4. Performance HUD: Enable in device options

Key Metrics

Debug Utility Functions

Performance Optimization Checklist

Data Types

• [ ] Default half, float only for position/depth

Memory Management

• [ ] Constants in constant address space
• [ ] Use .storageModeShared
• [ ] Leverage tile memory (TBDR free reads)
• [ ] Avoid unnecessary render target stores

Branch Optimization

• [ ] Function constants to eliminate branches
• [ ] Fixed loop bounds (GPU unrolling)

Rendering Tips

• [ ] Fullscreen quad with 4 vertex triangle strip
• [ ] Procedural textures to avoid sampling bandwidth
• [ ] [[early_fragment_tests]] for early depth test
• [ ] setFragmentBytes for small data

Compute Optimization

• [ ] Vectorize (SIMD)
• [ ] Reduce register pressure

---

Metal, Apple Silicon, and Xcode are trademarks of Apple Inc.

Navigation Patterns

iOS navigation patterns guide covering Tab navigation, Navigation Controller, and modal presentation.

Tab-Based Navigation

For apps with 3-5 main sections:

class AppTabBarController: UITabBarController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let homeNav = UINavigationController(rootViewController: HomeVC())
        homeNav.tabBarItem = UITabBarItem(
            title: "Home",
            image: UIImage(systemName: "house"),
            selectedImage: UIImage(systemName: "house.fill")
        )
        
        let searchNav = UINavigationController(rootViewController: SearchVC())
        searchNav.tabBarItem = UITabBarItem(
            title: "Search",
            image: UIImage(systemName: "magnifyingglass"),
            tag: 1
        )
        
        let profileNav = UINavigationController(rootViewController: ProfileVC())
        profileNav.tabBarItem = UITabBarItem(
            title: "Profile",
            image: UIImage(systemName: "person"),
            selectedImage: UIImage(systemName: "person.fill")
        )
        
        viewControllers = [homeNav, searchNav, profileNav]
    }
}

Tab Bar Best Practices

Navigation Controller

Use large titles for root views:

class ListViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        title = "Items"
        navigationController?.navigationBar.prefersLargeTitles = true
        navigationItem.largeTitleDisplayMode = .always
    }
    
    func pushDetail(_ item: Item) {
        let detail = DetailViewController(item: item)
        detail.navigationItem.largeTitleDisplayMode = .never
        navigationController?.pushViewController(detail, animated: true)
    }
}

Navigation Bar Configuration

class CustomNavigationController: UINavigationController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let appearance = UINavigationBarAppearance()
        appearance.configureWithDefaultBackground()
        
        navigationBar.standardAppearance = appearance
        navigationBar.scrollEdgeAppearance = appearance
        navigationBar.compactAppearance = appearance
    }
}

Navigation Bar Buttons

override func viewDidLoad() {
    super.viewDidLoad()
    
    navigationItem.rightBarButtonItem = UIBarButtonItem(
        image: UIImage(systemName: "plus"),
        style: .plain,
        target: self,
        action: #selector(addItem)
    )
    
    navigationItem.rightBarButtonItems = [
        UIBarButtonItem(systemItem: .add, primaryAction: UIAction { _ in }),
        UIBarButtonItem(systemItem: .edit, primaryAction: UIAction { _ in })
    ]
}

Modal Presentation

Sheet Presentation

func presentEditor() {
    let editorVC = EditorViewController()
    let nav = UINavigationController(rootViewController: editorVC)
    
    editorVC.navigationItem.leftBarButtonItem = UIBarButtonItem(
        systemItem: .cancel, target: self, action: #selector(dismissEditor)
    )
    editorVC.navigationItem.rightBarButtonItem = UIBarButtonItem(
        systemItem: .done, target: self, action: #selector(saveAndDismiss)
    )
    
    if let sheet = nav.sheetPresentationController {
        sheet.detents = [.medium(), .large()]
        sheet.prefersGrabberVisible = true
        sheet.prefersScrollingExpandsWhenScrolledToEdge = false
    }
    
    present(nav, animated: true)
}

Custom Detent (iOS 16+)

if let sheet = nav.sheetPresentationController {
    let customDetent = UISheetPresentationController.Detent.custom { context in
        return context.maximumDetentValue * 0.4
    }
    sheet.detents = [customDetent, .large()]
}

Full Screen Presentation

func presentFullScreen() {
    let vc = FullScreenViewController()
    vc.modalPresentationStyle = .fullScreen
    vc.modalTransitionStyle = .coverVertical
    present(vc, animated: true)
}

Presentation Styles

Navigation Best Practices

1. Back gesture - Ensure edge swipe back always works 2. State restoration - Use UIStateRestoring to save navigation stack 3. Depth limit - Avoid more than 4-5 navigation levels 4. Cancel button - Modal views must provide a cancel option 5. Save confirmation - Show confirmation dialog for unsaved changes

---

UIKit, SF Symbols, and Apple are trademarks of Apple Inc.

Swift Coding Standards

Best practices for writing clean, safe, and idiomatic Swift code following Apple's guidelines and modern Swift conventions.

---

1. Optionals and Safety

Impact: CRITICAL

Swift's optional system eliminates null pointer exceptions through compile-time safety.

1.1 Safe Unwrapping with if let

if let name = optionalName {
    print("Hello, \(name)")
}

// Multiple bindings
if let name = userName, let age = userAge, age >= 18 {
    print("\(name) is an adult")
}

1.2 Guard for Early Exit

Use guard to exit early when preconditions aren't met:

func processUser(_ user: User?) {
    guard let user = user else { return }
    guard !user.name.isEmpty else { return }
    print(user.name)
}

1.3 Nil Coalescing for Defaults

let displayName = name ?? "Anonymous"
let count = items?.count ?? 0

1.4 Optional Chaining

let count = user?.profile?.posts?.count
let uppercased = optionalString?.uppercased()

1.5 Optional map/flatMap

let uppercasedName = userName.map { $0.uppercased() }
let userID = userIDString.flatMap { Int($0) }

1.6 Never Force Unwrap

Avoid ! force unwrapping. Use safe alternatives:

---

2. Naming Conventions

Impact: HIGH

2.1 Types: PascalCase

class UserProfileViewController { }
struct NetworkRequest { }
protocol DataSource { }
enum LoadingState { }

2.2 Variables and Functions: camelCase

var userName: String
let maximumRetryCount = 3
func fetchUserProfile() { }

2.3 Boolean Naming

Use is, has, should, can prefixes:

var isLoading: Bool
var hasCompletedOnboarding: Bool
var shouldShowAlert: Bool
var canEditProfile: Bool

2.4 Function Naming

Use verb phrases, read like natural English:

// Good - clear actions
func fetchUsers() async throws -> [User]
func remove(_ item: Item, at index: Int)
func makeIterator() -> Iterator

// Avoid - unclear or redundant
func getUsersData() // "get" is redundant
func doRemove() // vague

2.5 Parameter Labels

First parameter label can be omitted when obvious:

func insert(_ element: Element, at index: Int)
func move(from source: Int, to destination: Int)

---

3. Protocol-Oriented Design

Impact: HIGH

Swift favors composition over inheritance through protocols.

3.1 Define Capabilities Through Protocols

protocol DataStore {
    func save<T: Codable>(_ item: T, key: String) throws
    func load<T: Codable>(key: String) throws -> T?
}

protocol Drawable {
    var color: Color { get set }
    func draw()
}

3.2 Protocol Extensions for Default Behavior

extension Drawable {
    func draw() {
        print("Drawing with \(color)")
    }
}

extension Collection {
    func chunked(into size: Int) -> [[Element]] {
        guard size > 0 else { return [] }

        var result: [[Element]] = []
        var i = startIndex

        while i != endIndex {
            let j = index(i, offsetBy: size, limitedBy: endIndex) ?? endIndex
            result.append(Array(self[i..<j]))
            i = j
        }

        return result
    }
}

3.3 Associated Types for Flexibility

protocol Repository {
    associatedtype Item
    func fetchAll() async throws -> [Item]
    func save(_ item: Item) async throws
}

class UserRepository: Repository {
    typealias Item = User
    
    func fetchAll() async throws -> [User] { /* ... */ }
    func save(_ item: User) async throws { /* ... */ }
}

3.4 Protocol Composition

protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }

func greet(_ person: Named & Aged) {
    print("Hello, \(person.name), age \(person.age)")
}

---

4. Value Types vs Reference Types

Impact: HIGH

4.1 Prefer Structs (Value Types)

Use structs for simple data models, independent copies:

struct User {
    var name: String
    var email: String
}

struct Point {
    var x: Double
    var y: Double
}

4.2 Use Classes When Needed

Use classes when identity, shared ownership, or reference semantics matter. Prefer actors for mutable state shared across concurrent tasks:

class NetworkManager {
    static let shared = NetworkManager()
    private init() { }
}

class FileHandle {
    // Wrapping system resource
}

4.3 Enums for Finite States

enum LoadingState {
    case idle
    case loading
    case success(Data)
    case failure(Error)
}

enum Result<Success, Failure: Error> {
    case success(Success)
    case failure(Failure)
}

---

5. Memory Management with ARC

Impact: CRITICAL

5.1 Breaking Retain Cycles with weak

class Apartment {
    weak var tenant: Person?
}

class Person {
    var apartment: Apartment?
}

5.2 Closure Capture Lists

Use capture lists intentionally to avoid retain cycles. Choose weak or unowned based on lifetime guarantees:

// Weak capture for optional self
onComplete = { [weak self] in
    self?.processResult()
}

// Capture specific values
let id = user.id
fetchData { [id] result in
    print("Fetched for \(id)")
}

5.3 unowned for Guaranteed Lifetime

Use when reference should never be nil during object lifetime:

class CreditCard {
    unowned let customer: Customer
    
    init(customer: Customer) {
        self.customer = customer
    }
}

---

6. Error Handling

Impact: HIGH

6.1 Define Typed Errors

enum NetworkError: Error {
    case invalidURL
    case noConnection
    case serverError(statusCode: Int)
    case decodingFailed(underlying: Error)
}

enum ValidationError: LocalizedError {
    case emptyField(name: String)
    case invalidFormat(field: String, expected: String)
    
    var errorDescription: String? {
        switch self {
        case .emptyField(let name):
            return "\(name) cannot be empty"
        case .invalidFormat(let field, let expected):
            return "\(field) must be \(expected)"
        }
    }
}

6.2 Throwing Functions

func fetchUser(id: Int) throws -> User {
    guard let url = URL(string: "https://api.example.com/users/\(id)") else {
        throw NetworkError.invalidURL
    }
    // ... implementation
}

6.3 Do-Catch Handling

do {
    let user = try fetchUser(id: 123)
    print(user.name)
} catch NetworkError.serverError(let code) {
    print("Server error: \(code)")
} catch NetworkError.noConnection {
    print("Check your internet connection")
} catch {
    print("Unknown error: \(error)")
}

6.4 try? and try!

// try? returns optional (nil on error)
let user = try? fetchUser(id: 123)

// try! crashes on error - use only when failure is programmer error
let config = try! loadBundledConfig()

6.5 Rethrows

func perform<T>(_ operation: () throws -> T) rethrows -> T {
    return try operation()
}

---

7. Modern Concurrency (async/await)

Impact: CRITICAL

Use actor isolation and Sendable to prevent data races across concurrency domains.

7.1 Async Functions

func fetchUser(id: Int) async throws -> User {
    guard let url = URL(string: "https://api.example.com/users/\(id)") else {
        throw NetworkError.invalidURL
    }
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode(User.self, from: data)
}

// Calling async functions
Task {
    do {
        let user = try await fetchUser(id: 123)
        print(user.name)
    } catch {
        print("Failed: \(error)")
    }
}

7.2 Parallel Execution with TaskGroup

func fetchAllUsers(ids: [Int]) async throws -> [User] {
    try await withThrowingTaskGroup(of: User.self) { group in
        for id in ids {
            group.addTask {
                try await fetchUser(id: id)
            }
        }
        return try await group.reduce(into: []) { $0.append($1) }
    }
}

7.3 async let for Concurrent Bindings

async let user = fetchUser(id: 1)
async let posts = fetchPosts(userId: 1)
async let followers = fetchFollowers(userId: 1)

let profile = try await ProfileData(
    user: user,
    posts: posts,
    followers: followers
)

7.4 Actors for Thread-Safe State

actor BankAccount {
    private var balance: Double = 0
    
    func deposit(_ amount: Double) {
        balance += amount
    }
    
    func withdraw(_ amount: Double) throws {
        guard balance >= amount else {
            throw BankError.insufficientFunds
        }
        balance -= amount
    }
    
    func getBalance() -> Double {
        balance
    }
}

// Usage
let account = BankAccount()
await account.deposit(100)
let balance = await account.getBalance()

7.5 MainActor for UI Updates

@MainActor
class ViewModel: ObservableObject {
    @Published var isLoading = false
    @Published var users: [User] = []
    
    func loadUsers() async {
        isLoading = true
        defer { isLoading = false }
        
        do {
            users = try await fetchUsers()
        } catch {
            // Handle error
        }
    }
}

7.6 Task Cancellation

func fetchWithTimeout() async throws -> Data {
    try await withThrowingTaskGroup(of: Data.self) { group in
        group.addTask {
            try await fetchData()
        }
        group.addTask {
            try await Task.sleep(for: .seconds(10))
            throw TimeoutError()
        }
        
        let result = try await group.next()!
        group.cancelAll()
        return result
    }
}

// Check for cancellation
func longOperation() async throws {
    for item in items {
        try Task.checkCancellation()
        await process(item)
    }
}

---

8. Access Control

Impact: MEDIUM

8.1 Access Levels

8.2 Best Practices

public class UserService {
    // Public API
    public func fetchUser(id: Int) async throws -> User { }
    
    // Internal helper
    func buildRequest(for id: Int) -> URLRequest { }
    
    // Private implementation detail
    private let session: URLSession
    private var cache: [Int: User] = [:]
}

8.3 Private Setters

public struct Counter {
    public private(set) var count = 0
    
    public mutating func increment() {
        count += 1
    }
}

---

9. Generics and Type Constraints

Impact: MEDIUM

9.1 Generic Functions

func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

9.2 Type Constraints

func findIndex<T: Equatable>(of value: T, in array: [T]) -> Int? {
    array.firstIndex(of: value)
}

func decode<T: Decodable>(_ type: T.Type, from data: Data) throws -> T {
    try JSONDecoder().decode(type, from: data)
}

9.3 Where Clauses

func allMatch<C: Collection>(_ collection: C, predicate: (C.Element) -> Bool) -> Bool
    where C.Element: Equatable {
    collection.allSatisfy(predicate)
}

extension Array where Element: Numeric {
    func sum() -> Element {
        reduce(0, +)
    }
}

9.4 Opaque Types (some)

func makeCollection() -> some Collection {
    [1, 2, 3]
}

var body: some View {
    Text("Hello")
}

---

10. Property Wrappers

Impact: MEDIUM

10.1 Common SwiftUI Property Wrappers

10.2 Custom Property Wrappers

@propertyWrapper
struct Clamped<Value: Comparable> {
    private var value: Value
    let range: ClosedRange<Value>
    
    var wrappedValue: Value {
        get { value }
        set { value = min(max(newValue, range.lowerBound), range.upperBound) }
    }
    
    init(wrappedValue: Value, _ range: ClosedRange<Value>) {
        self.range = range
        self.value = min(max(wrappedValue, range.lowerBound), range.upperBound)
    }
}

struct Settings {
    @Clamped(0...100) var volume: Int = 50
}

---

Quick Reference

Optionals

if let x = optional { }      // Safe unwrap
guard let x = optional else { return }  // Early exit
let x = optional ?? default  // Default value
optional?.method()           // Optional chaining
optional.map { transform($0) }  // Transform if present

Common Patterns

// Defer for cleanup
func process() {
    let file = openFile()
    defer { closeFile(file) }
    // ... work with file
}

// Lazy initialization
lazy var expensive: ExpensiveObject = {
    ExpensiveObject()
}()

// Type inference
let numbers = [1, 2, 3]  // [Int]
let doubled = numbers.map { $0 * 2 }  // [Int]

Closure Syntax

// Full syntax
let sorted = names.sorted(by: { (s1: String, s2: String) -> Bool in
    return s1 < s2
})

// Shortened
let sorted = names.sorted { $0 < $1 }

// Trailing closure
UIView.animate(withDuration: 0.3) {
    view.alpha = 0
}

---

Checklist

Safety

• [ ] No force unwrapping (!) except for IB outlets and known-safe cases
• [ ] All optionals handled with if let, guard let, or ??
• [ ] No implicitly unwrapped optionals (!) in data models

Memory

• [ ] Escaping closures capture self intentionally; use [weak self] or [unowned self] to avoid retain cycles when needed
• [ ] Delegate properties are weak
• [ ] No retain cycles between objects

Concurrency

• [ ] Async functions used instead of completion handlers
• [ ] Mutable state shared across concurrency domains is isolated, often with actors
• [ ] Types crossing concurrency domains use Sendable when appropriate
• [ ] UI updates on @MainActor
• [ ] Task cancellation checked in long operations

Access Control

• [ ] private used for implementation details
• [ ] public API is minimal and intentional
• [ ] No unnecessary internal exposure

Naming

• [ ] Types use PascalCase
• [ ] Functions and variables use camelCase
• [ ] Booleans have is/has/should prefix
• [ ] Functions read like natural English

---

Swift and Apple are trademarks of Apple Inc.

SwiftUI Design Guidelines

Design rules based on Apple Human Interface Guidelines for building native iOS interfaces with SwiftUI.

---

Design Philosophy

iOS design prioritizes content over chrome. The interface should feel invisible—users focus on their tasks, not the UI.

Key mindsets:

1. Let content breathe — Use full-screen layouts, minimize borders and boxes, let images and text take center stage

2. Leverage system conventions — Users already know how iOS works; don't reinvent navigation, gestures, or controls

3. Design for fingers — Touch is imprecise; generous tap targets and forgiving gesture recognition matter more than pixel-perfect layouts

4. Respect user choices — Honor Dynamic Type, Dark Mode, Reduce Motion, and other accessibility settings as first-class requirements

iOS 26+ Liquid Glass: The latest iOS introduces translucent UI elements that respond to lighting and content behind them. Typography is bolder, text tends left-aligned for easier scanning.

---

1. Layout & Safe Areas

Impact: CRITICAL

1.1 Minimum 44pt Touch Targets

All interactive elements must have minimum 44x44 points (not pixels—points scale with screen density).

Button(action: handleTap) {
    Image(systemName: "heart.fill")
}
.frame(minWidth: 44, minHeight: 44)

Avoid placing critical interactions near screen edges where system gestures operate.

1.2 Respect Safe Areas

Never place interactive or essential content under the status bar, Dynamic Island, or home indicator. SwiftUI respects safe areas by default. Use .ignoresSafeArea() only for background fills, images, or decorative elements—never for text or interactive controls.

ZStack {
    LinearGradient(colors: [.blue, .purple], startPoint: .top, endPoint: .bottom)
        .ignoresSafeArea()
    
    VStack {
        Text("Welcome")
            .font(.largeTitle)
        Button("Get Started") { }
    }
}

1.3 Primary Actions in Thumb Zone

Place primary actions at the bottom of the screen where the user's thumb naturally rests. Secondary actions and navigation belong at the top.

VStack {
    ScrollView {
        // Content
    }
    
    Spacer()
    
    Button("Submit") { submit() }
        .buttonStyle(.borderedProminent)
        .padding(.horizontal)
        .padding(.bottom)
}

1.4 Support All Screen Sizes

Design for iPhone SE (375pt) through iPad Pro (1024pt+). Use Size Classes to adapt:

@Environment(\.horizontalSizeClass) private var sizeClass

var body: some View {
    if sizeClass == .compact {
        VStack { content }
    } else {
        HStack { content }
    }
}

Use flexible layouts, avoid hardcoded widths:

HStack(spacing: 16) {
    ForEach(categories) { category in
        CategoryCard(category: category)
            .frame(maxWidth: .infinity)
    }
}

1.5 8pt Grid Alignment

Align spacing, padding, and element sizes to multiples of 8 points (8, 16, 24, 32, 40, 48). Use 4pt for fine adjustments.

1.6 Landscape Support

Support landscape orientation unless the app is task-specific (e.g., camera). Use ViewThatFits or GeometryReader for adaptive layouts.

ViewThatFits {
    HStack { contentViews }
    VStack { contentViews }
}

---

2. Navigation

Impact: CRITICAL

2.1 Tab Bar for Top-Level Sections

Use a tab bar at the bottom of the screen for 3 to 5 top-level sections. Each tab should represent a distinct category of content or functionality.

TabView(selection: $selectedTab) {
    HomeView()
        .tabItem {
            Label("Home", systemImage: "house")
        }
        .tag(Tab.home)
    
    DiscoverView()
        .tabItem {
            Label("Discover", systemImage: "magnifyingglass")
        }
        .tag(Tab.discover)
    
    AccountView()
        .tabItem {
            Label("Account", systemImage: "person")
        }
        .tag(Tab.account)
}

2.2 Navigation Architecture

Tab Bar (Flat) — For 3-5 equal-importance sections

• Always visible except when covered by modals
• Each tab maintains its own navigation stack
• Most important content leftmost (easier thumb access)

Hierarchical (Drill-Down) — For tree-structured info

• Push/pop navigation with back button
• Minimize depth (3-4 levels max)
• Provide search as escape hatch for deep trees

Modal (Focused Tasks) — For self-contained workflows

• Full-screen for critical tasks
• Page sheet for dismissible tasks (swipe-down)
• Clear Done/Cancel with confirmation if data loss possible

Never use hamburger menus—they reduce feature discoverability significantly.

2.3 Large Titles in Primary Views

Use .navigationBarTitleDisplayMode(.large) for top-level views. Titles transition to inline when the user scrolls.

NavigationStack {
    List(conversations) { conversation in
        ConversationRow(conversation: conversation)
    }
    .navigationTitle("Inbox")
    .navigationBarTitleDisplayMode(.large)
}

2.4 Never Override Back Swipe

The swipe-from-left-edge gesture for back navigation is a system-level expectation. Never attach custom gesture recognizers that interfere with it.

2.5 Use NavigationStack for Hierarchical Content

Use NavigationStack (not the deprecated NavigationView) for drill-down content. Use NavigationPath for programmatic navigation.

@State private var navPath = NavigationPath()

NavigationStack(path: $navPath) {
    List(products) { product in
        NavigationLink(value: product) {
            ProductRow(product: product)
        }
    }
    .navigationDestination(for: Product.self) { product in
        ProductDetailView(product: product)
    }
}

2.6 Preserve State Across Navigation

When users navigate back and then forward, or switch tabs, restore the previous scroll position and input state.

@SceneStorage("selectedTab") private var selectedTab = Tab.home
@SceneStorage("scrollPosition") private var scrollPosition: String?

---

3. Typography & Dynamic Type

Impact: HIGH

3.1 Use Built-in Text Styles

Always use semantic text styles—they scale with Dynamic Type automatically:

VStack(alignment: .leading, spacing: 8) {
    Text("Article Title")
        .font(.headline)
    
    Text("Published by Author Name")
        .font(.subheadline)
        .foregroundStyle(.secondary)
    
    Text(articleBody)
        .font(.body)
}

3.2 Support Dynamic Type Including Accessibility Sizes

Dynamic Type can scale text up to approximately 200% at the largest accessibility sizes. Layouts must reflow—never truncate or clip essential text.

@Environment(\.dynamicTypeSize) private var typeSize

var body: some View {
    if typeSize.isAccessibilitySize {
        VStack(alignment: .leading) { content }
    } else {
        HStack { content }
    }
}

3.3 Custom Fonts Must Scale

If you use a custom typeface, scale it with Font.custom(_:size:relativeTo:) so it responds to Dynamic Type.

Text("Brand Text")
    .font(.custom("Avenir-Medium", size: 17, relativeTo: .body))

3.4 SF Pro as System Font

Use the system font (SF Pro) unless brand requirements dictate otherwise. SF Pro is optimized for legibility on Apple displays.

3.5 Minimum 11pt Text

Never display text smaller than 11pt. Prefer 17pt for body text. Use the caption2 style (11pt) as the absolute minimum.

3.6 Hierarchy Through Weight and Size

Establish visual hierarchy through font weight and size. Do not rely solely on color to differentiate text levels.

3.7 SF Symbols

Use SF Symbols (6,900+ icons) instead of custom image assets:

// Basic usage with automatic text alignment
Label("Favorites", systemImage: "star.fill")

// Rendering modes
Image(systemName: "cloud.sun.rain")
    .symbolRenderingMode(.hierarchical)  // or .multicolor, .palette
    .imageScale(.large)  // .small, .medium, .large

SF Symbols automatically match text weight, scale with Dynamic Type, and align to text baselines. Let them size naturally—don't force them into fixed-dimension containers.

---

4. Color & Dark Mode

Impact: HIGH

4.1 Use Semantic System Colors

Never use hard-coded RGB, hex, or .black/.white directly. Use semantic colors:

Labels:

• .primary, .secondary, .tertiary, .quaternary

Backgrounds:

• Color(.systemBackground) — primary surface
• Color(.secondarySystemBackground) — cards, grouped
• Color(.tertiarySystemBackground) — nested elements

System Colors (adapt to appearance):

• .blue, .red, .green, .orange, .yellow, .purple, .pink, .cyan, .mint, .teal, .indigo, .brown, .gray

VStack {
    Text("Primary content")
        .foregroundStyle(.primary)
    
    Text("Supporting info")
        .foregroundStyle(.secondary)
}
.background(Color(.systemBackground))

4.2 Custom Colors Need 4 Variants

For custom colors, define in asset catalog with all appearance combinations: 1. Light mode 2. Dark mode 3. Light mode + High Contrast 4. Dark mode + High Contrast

Text("Branded element")
    .foregroundStyle(Color("AccentBrand"))

For dynamic colors in code:

let dynamicColor = UIColor { traits in
    traits.userInterfaceStyle == .dark 
        ? UIColor(red: 0.9, green: 0.9, blue: 1.0, alpha: 1.0)
        : UIColor(red: 0.1, green: 0.1, blue: 0.2, alpha: 1.0)
}

4.3 Never Rely on Color Alone

Always pair color with text, icons, or shapes to convey meaning. Approximately 8% of men have some form of color vision deficiency.

HStack(spacing: 6) {
    Image(systemName: "exclamationmark.triangle.fill")
    Text("Connection failed")
}
.foregroundStyle(.red)

4.4 4.5:1 Contrast Ratio Minimum

All text must meet WCAG AA contrast ratios: 4.5:1 for normal text, 3:1 for large text (18pt+ or 14pt+ bold).

4.5 Support Display P3 Wide Gamut

Use Display P3 color space for vibrant, accurate colors on modern iPhones. Define colors in the asset catalog with the Display P3 gamut.

4.6 Background Hierarchy

Layer backgrounds to create visual depth:

// Level 1: Main view background
Color(.systemBackground)

// Level 2: Cards, grouped sections
Color(.secondarySystemBackground)

// Level 3: Nested elements within cards
Color(.tertiarySystemBackground)

4.7 One Accent Color for Interactive Elements

Choose a single tint/accent color for all interactive elements (buttons, links, toggles). This creates a consistent, learnable visual language.

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
                .tint(.orange)
        }
    }
}

---

5. Accessibility

Impact: CRITICAL

5.1 VoiceOver Labels on All Interactive Elements

Every button, control, and interactive element must have a meaningful accessibility label.

Button(action: toggleFavorite) {
    Image(systemName: isFavorite ? "heart.fill" : "heart")
}
.accessibilityLabel(isFavorite ? "Remove from favorites" : "Add to favorites")

5.2 Logical VoiceOver Navigation Order

Ensure VoiceOver reads elements in a logical order. Use .accessibilitySortPriority() to adjust when the visual layout doesn't match the reading order.

HStack {
    Text("$49.99")
        .accessibilitySortPriority(2)
    Text("Premium Plan")
        .accessibilitySortPriority(1)
}

5.3 Support Bold Text

When the user enables Bold Text in Settings, SwiftUI text styles handle this automatically. Custom text must respond to UIAccessibility.isBoldTextEnabled.

5.4 Support Reduce Motion

Disable decorative animations and parallax when Reduce Motion is enabled.

@Environment(\.accessibilityReduceMotion) private var reduceMotion

var body: some View {
    CardView()
        .animation(reduceMotion ? nil : .spring(duration: 0.4), value: expanded)
}

5.5 Support Increase Contrast

When the user enables Increase Contrast, ensure custom colors have higher-contrast variants. Use @Environment(\.colorSchemeContrast) to detect.

5.6 Don't Convey Info Only by Color, Shape, or Position

Information must be available through multiple channels. Pair visual indicators with text or accessibility descriptions.

5.7 Alternative Interactions for All Gestures

Every custom gesture must have an equivalent tap-based or menu-based alternative for users who cannot perform complex gestures.

5.8 Support Switch Control and Full Keyboard Access

Ensure all interactions work with Switch Control (external switches) and Full Keyboard Access (Bluetooth keyboards). Test navigation order and focus behavior.

---

6. Gestures & Input

Impact: HIGH

6.1 Use Standard Gestures

Stick to gestures users already know:

• Tap — Select items, trigger buttons
• Long press — Show context menus, enter edit mode
• Horizontal swipe — List row actions (delete/archive), back navigation
• Vertical swipe — Scroll content, dismiss sheets
• Pinch — Scale images/maps
• Rotate — Adjust angle (photos, maps)

6.2 Never Override System Gestures

iOS reserves these edge gestures—do not intercept:

• Left edge swipe → back navigation
• Top-left pull → Notification Center
• Top-right pull → Control Center
• Bottom edge swipe → home/app switcher

6.3 Custom Gestures Must Be Discoverable

If you add a custom gesture, provide visual hints (e.g., a grabber handle) and ensure the action is also available through a visible button or menu item.

6.4 Support All Input Methods

Design for touch first, but also support hardware keyboards, assistive devices (Switch Control, head tracking), and pointer input.

---

7. Components

Impact: HIGH

7.1 Button Styles

Use the built-in button styles appropriately:

VStack(spacing: 16) {
    Button("Checkout") { checkout() }
        .buttonStyle(.borderedProminent)
    
    Button("Add to Wishlist") { addToWishlist() }
        .buttonStyle(.bordered)
    
    Button("Remove Item", role: .destructive) { removeItem() }
}

7.2 Alerts — Critical Info Only

Use alerts sparingly for critical information that requires a decision. Prefer 2 buttons; maximum 3.

.alert("Discard Draft?", isPresented: $showDiscardAlert) {
    Button("Discard", role: .destructive) { discardDraft() }
    Button("Keep Editing", role: .cancel) { }
} message: {
    Text("Your unsaved changes will be lost.")
}

7.3 Sheets for Scoped Tasks

Present sheets for self-contained tasks. Always provide a way to dismiss (close button or swipe down).

.sheet(isPresented: $showEditor) {
    NavigationStack {
        EditorView()
            .navigationTitle("Edit Profile")
            .toolbar {
                ToolbarItem(placement: .cancellationAction) {
                    Button("Cancel") { showEditor = false }
                }
                ToolbarItem(placement: .confirmationAction) {
                    Button("Save") { saveProfile() }
                }
            }
    }
    .presentationDetents([.medium, .large])
    .presentationDragIndicator(.visible)
}

7.4 Lists — The Foundation of iOS Apps

Most iOS apps are lists ("90% of mobile design is list design").

List Styles:

• .insetGrouped — Modern default (rounded corners, margins)
• .grouped — Traditional grouped sections
• .plain — Edge-to-edge rows
• .sidebar — Three-column iPad layout

Swipe Actions:

• Leading swipe → Positive actions (mark read, archive)
• Trailing swipe → Destructive actions (delete at far right)
• Maximum 3-4 actions per side

Row Accessories:

• Chevron → Indicates navigation
• Checkmark → Shows selection
• Detail button → Additional info without navigation

List {
    Section("Notifications") {
        ForEach(notifications) { notification in
            NotificationRow(notification: notification)
                .swipeActions(edge: .trailing, allowsFullSwipe: true) {
                    Button(role: .destructive) {
                        delete(notification)
                    } label: {
                        Label("Delete", systemImage: "trash")
                    }
                    
                    Button {
                        markRead(notification)
                    } label: {
                        Label("Read", systemImage: "envelope.open")
                    }
                    .tint(.blue)
                }
                .swipeActions(edge: .leading) {
                    Button {
                        pin(notification)
                    } label: {
                        Label("Pin", systemImage: "pin")
                    }
                    .tint(.orange)
                }
        }
    }
}
.listStyle(.insetGrouped)

7.5 Tab Bar Behavior

• Use SF Symbols for tab icons — filled variant for the selected tab, outline for unselected
• Never hide the tab bar when navigating deeper within a tab
• Badge important counts with .badge()

NotificationsView()
    .tabItem {
        Label("Notifications", systemImage: "bell")
    }
    .badge(unreadCount)

7.6 Search

Place search using .searchable(). Provide search suggestions and support recent searches.

NavigationStack {
    List(searchResults) { item in
        ItemRow(item: item)
    }
    .searchable(text: $query, prompt: "Search products")
    .searchSuggestions {
        ForEach(recentSearches, id: \.self) { term in
            Text(term)
                .searchCompletion(term)
        }
    }
}

7.7 Context Menus

Use context menus (long press) for secondary actions. Never use a context menu as the only way to access an action.

ImageThumbnail(image: image)
    .contextMenu {
        Button { shareImage(image) } label: {
            Label("Share", systemImage: "square.and.arrow.up")
        }
        Button { copyImage(image) } label: {
            Label("Copy", systemImage: "doc.on.doc")
        }
        Divider()
        Button(role: .destructive) { deleteImage(image) } label: {
            Label("Delete", systemImage: "trash")
        }
    }

7.8 Forms and Input

Text Fields:

• 44pt minimum height
• Match keyboard type to input (.emailAddress, .numberPad, .URL)
• Clear button when text entered
• Placeholder uses .quaternary label color

Form {
    Section("Account") {
        TextField("Email", text: $email)
            .textContentType(.emailAddress)
            .keyboardType(.emailAddress)
            .autocapitalization(.none)
        
        SecureField("Password", text: $password)
            .textContentType(.password)
    }
    
    Section {
        Button("Sign In") { signIn() }
            .disabled(email.isEmpty || password.isEmpty)
    }
}

Pickers:

• Inline → 3-7 options
• Menu → 2-5 options (iOS 14+)
• Wheel → Date/time or long lists

7.9 Progress Indicators

• Determinate ProgressView(value:total:) for operations with known duration
• Indeterminate ProgressView() for unknown duration
• Never block the entire screen with a spinner

VStack {
    ProgressView(value: uploadProgress, total: 1.0)
        .progressViewStyle(.linear)
    
    Text("\(Int(uploadProgress * 100))% uploaded")
        .font(.caption)
        .foregroundStyle(.secondary)
}

---

8. Patterns

Impact: MEDIUM

8.1 Onboarding — Max 3 Pages, Skippable

Keep onboarding to 3 or fewer pages. Always provide a skip option. Defer sign-in until the user needs authenticated features.

TabView(selection: $currentPage) {
    OnboardingPage(icon: "sparkles", title: "Smart Features", description: "...")
        .tag(0)
    OnboardingPage(icon: "bell.badge", title: "Stay Notified", description: "...")
        .tag(1)
    OnboardingPage(icon: "lock.shield", title: "Private & Secure", description: "...")
        .tag(2)
}
.tabViewStyle(.page)
.overlay(alignment: .topTrailing) {
    Button("Skip") { finishOnboarding() }
        .padding()
}

8.2 Loading — Skeleton Views, No Blocking Spinners

Use skeleton/placeholder views that match the layout of the content being loaded. Never show a full-screen blocking spinner.

if isLoading {
    ForEach(0..<5, id: \.self) { _ in
        ArticleRowPlaceholder()
            .redacted(reason: .placeholder)
    }
} else {
    ForEach(articles) { article in
        ArticleRow(article: article)
    }
}

8.3 Launch Screen — Match First Screen

The launch storyboard must visually match the initial screen of the app. No splash logos, no branding screens. This creates the perception of instant launch.

8.4 Modality — Use Sparingly

Present modal views only when the user must complete or abandon a focused task. Always provide a clear dismiss action. Never stack modals on top of modals.

8.5 Notifications — High Value Only

Only send notifications for content the user genuinely cares about. Support actionable notifications. Categorize notifications so users can control them granularly.

8.6 Settings Placement

• Frequent settings: In-app settings screen accessible from a profile or gear icon
• Privacy/permission settings: Defer to the system Settings app via URL scheme
• Never duplicate system-level controls in-app

8.7 Action Sheets

For destructive or multiple-choice actions:

.confirmationDialog("Delete Photo?", isPresented: $showDelete, titleVisibility: .visible) {
    Button("Delete", role: .destructive) { deletePhoto() }
    Button("Cancel", role: .cancel) { }
} message: {
    Text("This action cannot be undone.")
}

• Destructive action at top (red)
• Cancel at bottom
• Dismiss by tapping outside

8.8 Pull-to-Refresh

Standard pattern for content updates:

List(items) { item in
    ItemRow(item: item)
}
.refreshable {
    await loadNewItems()
}

8.9 Haptic Feedback

Provide tactile response for significant actions:

Button("Complete") {
    let feedback = UINotificationFeedbackGenerator()
    feedback.notificationOccurred(.success)
    markComplete()
}

---

9. Privacy & Permissions

Impact: HIGH

9.1 Request Permissions in Context

Request a permission at the moment the user takes an action that needs it—never at app launch.

Button("Take Photo") {
    AVCaptureDevice.requestAccess(for: .video) { granted in
        if granted {
            showCamera = true
        }
    }
}

9.2 Explain Before System Prompt

Show a custom explanation screen before triggering the system permission dialog. The system dialog only appears once—if the user denies, the app must direct them to Settings.

struct LocationPermissionView: View {
    var body: some View {
        VStack(spacing: 20) {
            Image(systemName: "location.fill")
                .font(.system(size: 48))
                .foregroundStyle(.blue)
            
            Text("Find Nearby Places")
                .font(.title2.bold())
            
            Text("We use your location to show relevant results. Your location is never stored or shared.")
                .multilineTextAlignment(.center)
                .foregroundStyle(.secondary)
            
            Button("Enable Location") {
                locationManager.requestWhenInUseAuthorization()
            }
            .buttonStyle(.borderedProminent)
            
            Button("Not Now") { dismiss() }
                .foregroundStyle(.secondary)
        }
        .padding()
    }
}

9.3 Support Sign in with Apple

If the app offers any third-party sign-in (Google, Facebook), it must also offer Sign in with Apple. Present it as the first option.

9.4 Don't Require Accounts Unless Necessary

Let users explore the app before requiring sign-in. Gate only features that genuinely need authentication (purchases, sync, social features).

9.5 App Tracking Transparency

If you track users across apps or websites, display the ATT prompt. Respect denial—do not degrade the experience for users who opt out.

9.6 Location Button for One-Time Access

Use LocationButton for actions that need location once without requesting ongoing permission.

LocationButton(.currentLocation) {
    fetchNearbyResults()
}
.symbolVariant(.fill)
.labelStyle(.titleAndIcon)

---

10. System Integration

Impact: MEDIUM

10.1 Widgets for Glanceable Data

Provide widgets using WidgetKit for information users check frequently. Widgets are not interactive (beyond tapping to open the app), so show the most useful snapshot.

10.2 App Shortcuts for Key Actions

Define App Shortcuts so users can trigger key actions from Siri, Spotlight, and the Shortcuts app.

struct MyAppShortcuts: AppShortcutsProvider {
    static var appShortcuts: [AppShortcut] {
        AppShortcut(
            intent: QuickAddIntent(),
            phrases: ["Add item in \(.applicationName)"],
            shortTitle: "Quick Add",
            systemImageName: "plus.circle"
        )
    }
}

10.3 Spotlight Indexing

Index app content with CSSearchableItem so users can find it from Spotlight search.

10.4 Share Sheet Integration

Support the system share sheet for content that users might want to send elsewhere.

ShareLink(item: article.url, subject: Text(article.title)) {
    Label("Share Article", systemImage: "square.and.arrow.up")
}

10.5 Live Activities

Use Live Activities and the Dynamic Island for real-time, time-bound events (delivery tracking, sports scores, workouts).

10.6 Handle Interruptions Gracefully

Save state and pause gracefully when interrupted by phone calls, Siri invocations, notifications, app switcher, or FaceTime SharePlay.

@Environment(\.scenePhase) private var scenePhase

var body: some View {
    ContentView()
        .onChange(of: scenePhase) { _, newPhase in
            switch newPhase {
            case .active:
                resumeActivity()
            case .inactive:
                pauseActivity()
            case .background:
                saveState()
            @unknown default:
                break
            }
        }
}

---

Quick Reference

Navigation & Structure

Data Display

User Input

System Features

---

Anti-Patterns

Avoid these common HIG violations:

---

Review Checklist

Code review checklist for SwiftUI apps:

Layout

• [ ] Interactive elements have 44pt minimum touch area
• [ ] Essential content stays within safe area bounds
• [ ] Main actions positioned for one-handed use (bottom)
• [ ] UI works across iPhone SE to Pro Max screen sizes
• [ ] Spacing uses 8pt increments

Navigation

• [ ] Main sections use bottom TabView (3-5 tabs)
• [ ] No drawer/hamburger navigation
• [ ] Root views show large navigation titles
• [ ] System back gesture not blocked
• [ ] Tab state persists when switching

Text & Fonts

• [ ] Text uses semantic styles (.body, .headline, etc.)
• [ ] Dynamic Type works at all sizes including accessibility
• [ ] Content reflows without truncation at large sizes
• [ ] No text below 11pt

Colors

• [ ] Uses .primary, .secondary, Color(.systemBackground)
• [ ] Custom colors have light/dark variants in assets
• [ ] Status indicators combine color with icon/text
• [ ] Text contrast ratio meets WCAG AA

Accessibility

• [ ] Icon buttons have .accessibilityLabel()
• [ ] VoiceOver order matches logical flow
• [ ] Animations respect accessibilityReduceMotion
• [ ] All actions have non-gesture alternatives

Modals & Alerts

• [ ] Alerts reserved for critical decisions only
• [ ] Sheets provide clear dismiss mechanism
• [ ] No stacked modal presentations

Permissions

• [ ] Permissions requested at point of use
• [ ] Pre-permission explanation screens used
• [ ] Core features work without sign-in

---

iPad Adaptation

iPad users expect different interaction patterns:

Layout: Use NavigationSplitView for master-detail:

NavigationSplitView(columnVisibility: $columnVisibility) {
    SidebarView()
} content: {
    ListContentView()
} detail: {
    DetailView()
}
.navigationSplitViewStyle(.balanced)

Presentation: Action sheets become popovers automatically, but you can force popover:

.popover(isPresented: $showOptions) {
    OptionsView()
}

Keyboard: Add shortcuts for power users:

.keyboardShortcut("n", modifiers: .command)  // Cmd+N

Drag & Drop: Enable cross-app data transfer:

.draggable(item)
.dropDestination(for: Item.self) { items, location in
    handleDrop(items)
    return true
}

---

Pre-Release Verification

Run through these scenarios before shipping:

Visual consistency:

• Switch between Light/Dark mode—does everything remain readable?
• Crank Dynamic Type to maximum—does layout adapt or break?
• Enable Bold Text—do custom fonts respond?

Interaction quality:

• Can you complete every action using only VoiceOver?
• Do all buttons feel tappable on first try (no mis-taps)?
• Does back-swipe work everywhere in navigation?

Edge cases:

• What happens on iPhone SE's small screen?
• What happens on iPad with keyboard attached?
• What shows when network fails mid-operation?
• What happens if user denies permissions?

Platform compliance:

• Are you using SF Symbols instead of custom icon PNGs?
• Are all colors from semantic palette or asset catalog with variants?
• Do destructive actions require explicit confirmation?

---

SwiftUI, SF Symbols, Dynamic Island, and Apple are trademarks of Apple Inc.

System Integration

iOS system integration guide covering permissions, location, sharing, app lifecycle, and haptic feedback.

Permission Requests

Request permissions contextually, not at launch:

import AVFoundation

@objc func openCamera() {
    AVCaptureDevice.requestAccess(for: .video) { [weak self] granted in
        DispatchQueue.main.async {
            if granted {
                self?.showCameraInterface()
            } else {
                self?.showPermissionDeniedAlert()
            }
        }
    }
}

Photo Library

import Photos

func requestPhotoAccess() {
    PHPhotoLibrary.requestAuthorization(for: .readWrite) { status in
        DispatchQueue.main.async {
            switch status {
            case .authorized, .limited:
                self.showPhotoPicker()
            case .denied, .restricted:
                self.showSettingsAlert()
            default:
                break
            }
        }
    }
}

Microphone

func requestMicrophoneAccess() {
    AVAudioSession.sharedInstance().requestRecordPermission { granted in
        DispatchQueue.main.async {
            if granted {
                self.startRecording()
            }
        }
    }
}

Notifications

import UserNotifications

func requestNotificationPermission() {
    UNUserNotificationCenter.current().requestAuthorization(
        options: [.alert, .badge, .sound]
    ) { granted, error in
        DispatchQueue.main.async {
            if granted {
                self.registerForRemoteNotifications()
            }
        }
    }
}

Location Button

For one-time location access without persistent permission:

import CoreLocationUI

class StoreFinderVC: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        let locationBtn = CLLocationButton()
        locationBtn.icon = .arrowFilled
        locationBtn.label = .currentLocation
        locationBtn.cornerRadius = 20
        locationBtn.addTarget(self, action: #selector(findNearby), for: .touchUpInside)
        
        view.addSubview(locationBtn)
        locationBtn.snp.makeConstraints { make in
            make.centerX.equalToSuperview()
            make.bottom.equalTo(view.safeAreaLayoutGuide).offset(-24)
        }
    }
}

Core Location

import CoreLocation

class LocationManager: NSObject, CLLocationManagerDelegate {
    private let manager = CLLocationManager()
    
    func requestLocation() {
        manager.delegate = self
        manager.desiredAccuracy = kCLLocationAccuracyBest
        manager.requestWhenInUseAuthorization()
    }
    
    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
        switch manager.authorizationStatus {
        case .authorizedWhenInUse, .authorizedAlways:
            manager.requestLocation()
        case .denied:
            showLocationDeniedAlert()
        default:
            break
        }
    }
    
    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        guard let location = locations.last else { return }
        handleLocation(location)
    }
}

Share Sheet

@objc func shareContent() {
    let items: [Any] = [contentURL, contentImage].compactMap { $0 }
    let activityVC = UIActivityViewController(activityItems: items, applicationActivities: nil)
    
    if let popover = activityVC.popoverPresentationController {
        popover.sourceView = shareButton
        popover.sourceRect = shareButton.bounds
    }
    
    present(activityVC, animated: true)
}

Custom Share Items

class ShareItem: NSObject, UIActivityItemSource {
    let title: String
    let url: URL
    
    init(title: String, url: URL) {
        self.title = title
        self.url = url
    }
    
    func activityViewControllerPlaceholderItem(_ activityViewController: UIActivityViewController) -> Any {
        return url
    }
    
    func activityViewController(_ activityViewController: UIActivityViewController, itemForActivityType activityType: UIActivity.ActivityType?) -> Any? {
        return url
    }
    
    func activityViewController(_ activityViewController: UIActivityViewController, subjectForActivityType activityType: UIActivity.ActivityType?) -> String {
        return title
    }
}

Excluding Activities

let activityVC = UIActivityViewController(activityItems: items, applicationActivities: nil)
activityVC.excludedActivityTypes = [
    .addToReadingList,
    .assignToContact,
    .print
]

App Lifecycle

class PlayerViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        NotificationCenter.default.addObserver(
            self, selector: #selector(onBackground),
            name: UIApplication.didEnterBackgroundNotification, object: nil
        )
        NotificationCenter.default.addObserver(
            self, selector: #selector(onForeground),
            name: UIApplication.willEnterForegroundNotification, object: nil
        )
        NotificationCenter.default.addObserver(
            self, selector: #selector(onTerminate),
            name: UIApplication.willTerminateNotification, object: nil
        )
    }
    
    @objc private func onBackground() { 
        saveState()
        pausePlayback()
    }
    
    @objc private func onForeground() { 
        restoreState()
        resumePlayback()
    }
    
    @objc private func onTerminate() {
        saveState()
    }
}

Scene Lifecycle (iOS 13+)

class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    func sceneDidBecomeActive(_ scene: UIScene) {
        // Resume tasks
    }
    
    func sceneWillResignActive(_ scene: UIScene) {
        // Pause tasks
    }
    
    func sceneDidEnterBackground(_ scene: UIScene) {
        // Save state
    }
    
    func sceneWillEnterForeground(_ scene: UIScene) {
        // Prepare UI
    }
}

State Preservation

class ViewController: UIViewController {
    override func encodeRestorableState(with coder: NSCoder) {
        super.encodeRestorableState(with: coder)
        coder.encode(currentItemID, forKey: "currentItemID")
    }
    
    override func decodeRestorableState(with coder: NSCoder) {
        super.decodeRestorableState(with: coder)
        if let itemID = coder.decodeObject(forKey: "currentItemID") as? String {
            loadItem(itemID)
        }
    }
}

Haptic Feedback

func onTaskComplete() {
    UINotificationFeedbackGenerator().notificationOccurred(.success)
}

func onError() {
    UINotificationFeedbackGenerator().notificationOccurred(.error)
}

func onWarning() {
    UINotificationFeedbackGenerator().notificationOccurred(.warning)
}

func onSelection() {
    UISelectionFeedbackGenerator().selectionChanged()
}

func onImpact() {
    UIImpactFeedbackGenerator(style: .medium).impactOccurred()
}

Impact Styles

Prepared Feedback

For time-critical haptics, prepare the generator in advance:

class DraggableView: UIView {
    private let impactGenerator = UIImpactFeedbackGenerator(style: .medium)
    
    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        super.touchesBegan(touches, with: event)
        impactGenerator.prepare()
    }
    
    func didSnapToPosition() {
        impactGenerator.impactOccurred()
    }
}

Deep Linking

URL Schemes

// In AppDelegate or SceneDelegate
func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
    guard let components = URLComponents(url: url, resolvingAgainstBaseURL: true) else {
        return false
    }
    
    switch components.host {
    case "item":
        if let itemID = components.queryItems?.first(where: { $0.name == "id" })?.value {
            navigateToItem(itemID)
            return true
        }
    default:
        break
    }
    
    return false
}

Universal Links

func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
    guard userActivity.activityType == NSUserActivityTypeBrowsingWeb,
          let url = userActivity.webpageURL else {
        return false
    }
    
    return handleUniversalLink(url)
}

Background Tasks

import BackgroundTasks

func registerBackgroundTasks() {
    BGTaskScheduler.shared.register(
        forTaskWithIdentifier: "com.app.refresh",
        using: nil
    ) { task in
        self.handleAppRefresh(task: task as! BGAppRefreshTask)
    }
}

func scheduleAppRefresh() {
    let request = BGAppRefreshTaskRequest(identifier: "com.app.refresh")
    request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)
    
    do {
        try BGTaskScheduler.shared.submit(request)
    } catch {
        print("Could not schedule app refresh: \(error)")
    }
}

func handleAppRefresh(task: BGAppRefreshTask) {
    scheduleAppRefresh()
    
    let operation = RefreshOperation()
    
    task.expirationHandler = {
        operation.cancel()
    }
    
    operation.completionBlock = {
        task.setTaskCompleted(success: !operation.isCancelled)
    }
    
    OperationQueue.main.addOperation(operation)
}

---

UIKit, Core Location, and Apple are trademarks of Apple Inc.

UIKit Components

Common UIKit components guide covering UIStackView, buttons, alerts, search, and context menus.

UIStackView

Stack views simplify auto layout for linear arrangements:

class FormViewController: UIViewController {
    private let mainStack = UIStackView()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        mainStack.axis = .vertical
        mainStack.spacing = 16
        mainStack.alignment = .fill
        mainStack.distribution = .fill
        
        view.addSubview(mainStack)
        mainStack.snp.makeConstraints { make in
            make.top.equalTo(view.safeAreaLayoutGuide).offset(20)
            make.leading.trailing.equalToSuperview().inset(16)
        }
        
        let headerStack = UIStackView()
        headerStack.axis = .horizontal
        headerStack.spacing = 12
        headerStack.alignment = .center
        
        let avatarView = UIImageView()
        avatarView.snp.makeConstraints { make in
            make.size.equalTo(48)
        }
        
        let labelStack = UIStackView()
        labelStack.axis = .vertical
        labelStack.spacing = 4
        labelStack.addArrangedSubview(titleLabel)
        labelStack.addArrangedSubview(subtitleLabel)
        
        headerStack.addArrangedSubview(avatarView)
        headerStack.addArrangedSubview(labelStack)
        
        mainStack.addArrangedSubview(headerStack)
        mainStack.addArrangedSubview(contentView)
        mainStack.addArrangedSubview(actionButton)
        
        mainStack.setCustomSpacing(24, after: headerStack)
    }
}

StackView Properties

UIButton.Configuration (iOS 15+)

let primaryButton = UIButton(type: .system)
primaryButton.configuration = .filled()
primaryButton.setTitle("Continue", for: .normal)

let secondaryButton = UIButton(type: .system)
secondaryButton.configuration = .tinted()
secondaryButton.setTitle("Save for Later", for: .normal)

let destructiveButton = UIButton(type: .system)
destructiveButton.configuration = .plain()
destructiveButton.setTitle("Remove", for: .normal)
destructiveButton.tintColor = .systemRed

Custom Button Configuration

var config = UIButton.Configuration.filled()
config.title = "Add to Cart"
config.image = UIImage(systemName: "cart.badge.plus")
config.imagePadding = 8
config.cornerStyle = .capsule
config.baseBackgroundColor = .systemBlue
config.baseForegroundColor = .white
let cartButton = UIButton(configuration: config)

Button State Handling

var config = UIButton.Configuration.filled()
config.titleTextAttributesTransformer = UIConfigurationTextAttributesTransformer { incoming in
    var outgoing = incoming
    outgoing.font = .boldSystemFont(ofSize: 16)
    return outgoing
}

config.configurationUpdateHandler = { button in
    var config = button.configuration
    config?.showsActivityIndicator = button.isSelected
    button.configuration = config
}

UIAlertController

Alert

func confirmDeletion() {
    let alert = UIAlertController(
        title: "Remove Item?",
        message: "This cannot be undone.",
        preferredStyle: .alert
    )
    alert.addAction(UIAlertAction(title: "Remove", style: .destructive) { _ in
        self.performDeletion()
    })
    alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
    present(alert, animated: true)
}

Action Sheet

func showOptions() {
    let sheet = UIAlertController(title: nil, message: nil, preferredStyle: .actionSheet)
    sheet.addAction(UIAlertAction(title: "Share", style: .default) { _ in })
    sheet.addAction(UIAlertAction(title: "Edit", style: .default) { _ in })
    sheet.addAction(UIAlertAction(title: "Delete", style: .destructive) { _ in })
    sheet.addAction(UIAlertAction(title: "Cancel", style: .cancel))
    
    if let popover = sheet.popoverPresentationController {
        popover.sourceView = optionsButton
        popover.sourceRect = optionsButton.bounds
    }
    
    present(sheet, animated: true)
}

Alert with Text Field

func showInputAlert() {
    let alert = UIAlertController(
        title: "Rename",
        message: "Enter a new name",
        preferredStyle: .alert
    )
    
    alert.addTextField { textField in
        textField.placeholder = "Name"
        textField.autocapitalizationType = .words
    }
    
    alert.addAction(UIAlertAction(title: "Save", style: .default) { _ in
        if let name = alert.textFields?.first?.text {
            self.rename(to: name)
        }
    })
    alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
    
    present(alert, animated: true)
}

UISearchController

class SearchableListVC: UIViewController, UISearchResultsUpdating {
    private let searchController = UISearchController(searchResultsController: nil)
    private var allItems: [Item] = []
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupSearch()
    }
    
    private func setupSearch() {
        searchController.searchResultsUpdater = self
        searchController.obscuresBackgroundDuringPresentation = false
        searchController.searchBar.placeholder = "Search"
        navigationItem.searchController = searchController
        definesPresentationContext = true
    }
    
    func updateSearchResults(for searchController: UISearchController) {
        let query = searchController.searchBar.text ?? ""
        let filtered = query.isEmpty ? allItems : allItems.filter {
            $0.title.localizedCaseInsensitiveContains(query)
        }
        updateItems(filtered)
    }
}

Search Bar Configuration

searchController.searchBar.scopeButtonTitles = ["All", "Recent", "Favorites"]
searchController.searchBar.showsScopeBar = true
searchController.searchBar.delegate = self

extension SearchableListVC: UISearchBarDelegate {
    func searchBar(_ searchBar: UISearchBar, selectedScopeButtonIndexDidChange selectedScope: Int) {
        filterContent(scope: selectedScope)
    }
}

UIContextMenuInteraction

extension PhotoCell: UIContextMenuInteractionDelegate {
    func contextMenuInteraction(
        _ interaction: UIContextMenuInteraction,
        configurationForMenuAtLocation location: CGPoint
    ) -> UIContextMenuConfiguration? {
        UIContextMenuConfiguration(identifier: nil, previewProvider: nil) { _ in
            let share = UIAction(
                title: "Share",
                image: UIImage(systemName: "square.and.arrow.up")
            ) { _ in }
            
            let favorite = UIAction(
                title: "Favorite",
                image: UIImage(systemName: "heart")
            ) { _ in }
            
            let delete = UIAction(
                title: "Delete",
                image: UIImage(systemName: "trash"),
                attributes: .destructive
            ) { _ in }
            
            return UIMenu(children: [share, favorite, delete])
        }
    }
}

Context Menu with Preview

func contextMenuInteraction(
    _ interaction: UIContextMenuInteraction,
    configurationForMenuAtLocation location: CGPoint
) -> UIContextMenuConfiguration? {
    UIContextMenuConfiguration(
        identifier: itemID as NSCopying,
        previewProvider: { [weak self] in
            return self?.makePreviewController()
        },
        actionProvider: { _ in
            return self.makeMenu()
        }
    )
}

func contextMenuInteraction(
    _ interaction: UIContextMenuInteraction,
    willPerformPreviewActionForMenuWith configuration: UIContextMenuConfiguration,
    animator: UIContextMenuInteractionCommitAnimating
) {
    animator.addCompletion {
        self.showDetail()
    }
}

CollectionView Context Menu

func collectionView(
    _ collectionView: UICollectionView,
    contextMenuConfigurationForItemAt indexPath: IndexPath,
    point: CGPoint
) -> UIContextMenuConfiguration? {
    let item = dataSource.itemIdentifier(for: indexPath)
    return UIContextMenuConfiguration(identifier: indexPath as NSCopying, previewProvider: nil) { _ in
        return self.makeMenu(for: item)
    }
}

---

UIKit and Apple are trademarks of Apple Inc.