iPadOS: key concepts, iPad development and Apple Pencil

What is iPadOS?

iPadOS is Apple's operating system for iPad, first released in 2019 as a fork of iOS (version 13). Before this, iPad used the same iOS as iPhone. The separation of iPadOS allowed Apple to introduce features specific to the large screen: multitasking, desktop Safari, Drag & Drop, and external monitor support.

iPadOS maintains full compatibility with iOS apps: any iPhone app runs on iPad in scaling mode. However, a quality user experience requires adaptation: using Size Classes, UISplitViewController, and keyboard shortcut support. According to Apple (WWDC 2025), 80% of time on iPad users spend in tablet-optimized rather than scaled versions of apps.

iPadOS Version History

iPadOS 13 (2019) introduced Slide Over and Split View. iPadOS 14 (2020) added Apple Pencil Scribble and compact UI. iPadOS 15 (2021) introduced Quick Note and multitasking improvements. iPadOS 16 (2022) brought Stage Manager and external monitor support. iPadOS 17 (2023) added interactive widgets and Lock Screen customization.

iPadOS Architecture and Differences from iOS

iPadOS is based on the same XNU kernel and Darwin as iOS, but uses a modified UIKit shell adapted for multiple windows and arbitrary screen sizes. The key architectural difference is UIScene support, introduced in iOS 13.

UIScene and Window Lifecycle

In iPadOS, each window (including those in Split View) is a separate UISceneSession with its own lifecycle. Unlike iPhone, where one app has a single UIWindowScene, on iPad one app can have multiple UIScene instances (multiple windows, Slide Over, Stage Manager). SceneDelegate manages each window's state independently.

import UIKit
import SwiftUI

/// SceneDelegate for multiple window support on iPadOS
class SceneDelegate: UIResponder, UIWindowSceneDelegate {

    var window: UIWindow?
    var splitVC: UISplitViewController?

    func scene(_ scene: UIScene,
                 willConnectTo session: UISceneSession,
                 options connectionOptions: UIScene.ConnectionOptions) {
        guard let windowScene = (scene as? UIWindowScene) else { return }

        // Creating UISplitViewController for tablet navigation
        let splitVC = UISplitViewController(style: .tripleColumn)
        splitVC.primaryBackgroundStyle = .sidebar

        let sidebar = SidebarViewController()
        let primary = PrimaryViewController()
        let detail = DetailViewController()

        splitVC.viewControllers = [sidebar, primary, detail]

        let window = UIWindow(windowScene: windowScene)
        window.rootViewController = splitVC
        window.makeKeyAndVisible()
        self.window = window
    }

    // Adapting when window size changes (Split View)
    func windowScene(_ windowScene: UIWindowScene,
                     didUpdate previousCoordinateSpace: UICoordinateSpace,
                     interfaceOrientation previousOrientation: UIInterfaceOrientation) {
        let isMultitasking = windowScene.traitCollection.horizontalSizeClass == .compact
        print("iPadOS multitasking mode: \(isMultitasking ? "compact" : "regular")")
    }
}

UISplitViewController with .tripleColumn style displays three columns simultaneously: sidebar (navigation), primary (list), and detail (content). When transitioning to compact mode (Split View with another app), UIKit automatically collapses columns into a navigation stack. The developer does not manage this behavior manually — UIKit adapts the layout through traitCollection.

Additional Differences from iOS

iPadOS offers: external storage support via Files (USB-C/Thunderbolt), Safari terminal mode with element inspection, keyboard shortcuts via UIKeyCommand, system download manager, Drag & Drop between apps, and Picture in Picture with resizable window.

Multitasking on iPad: Split View, Slide Over, Stage Manager

Multitasking is a key feature of iPadOS that fundamentally sets it apart from iOS. The user can simultaneously work with multiple apps on one screen. The developer must ensure the app works correctly in any multitasking mode.

Split View

Split View divides the iPad screen between two apps in a 50/50 or 33/67 ratio. Each app gets its own UISceneSession with its own memory and lifecycle. When the screen width is less than 600 points, UIKit forcibly switches the app to a compact horizontal size class. The app must handle this change correctly.

Slide Over

Slide Over is a floating window on top of the active app (320 points wide). An app in Slide Over switches to a compact horizontal size class (.compact). It is important to optimize the UI for a narrow screen. In Slide Over, the app can be invoked by swiping from the right edge or through the dock. The user can drag Slide Over into Split View or close it by swiping right.

Stage Manager

Stage Manager (iPadOS 16+, M1 and newer) is a window manager that allows creating overlapping windows of arbitrary sizes. Up to 4 windows are supported on the iPad screen and up to 4 on an external monitor (8 total). Apps receive the UISceneWillConnectNotification event for each new window. Stage Manager changes the lifecycle rules: a background window is not frozen but continues working with limited resources.

Apple Pencil and Handwriting Input

Apple Pencil is Apple's active stylus with tilt, pressure, and hover detection support (iPad Pro M2+). The latency between pen movement and ink display is 9–20 ms depending on the model. PencilKit is the primary framework for integrating drawing into an app.

PencilKit: Drawing Integration

PKCanvasView provides a ready-made drawing surface with support for ink, pencil, marker, and eraser. PKToolPicker is the tool selection panel. The developer does not need to implement stroke rendering — PencilKit does this hardware-accelerated with Metal shaders. Pen color, thickness, and opacity customization are available.

import PencilKit
import UIKit

class DrawingViewController: UIViewController {

    private lazy var canvasView: PKCanvasView = {
        let canvas = PKCanvasView()
        canvas.tool = PKInkingTool(.pen, color: .black, width: 5)
        canvas.delegate = self
        canvas.drawingPolicy = .anyInput
        canvas.backgroundColor = .white
        return canvas
    }()

    private lazy var toolPicker: PKToolPicker = {
        let picker = PKToolPicker()
        picker.addObserver(canvasView)
        picker.setVisible(true, forFirstResponder: canvasView)
        return picker
    }()

    override func viewDidLoad() {
        super.viewDidLoad()
        view.addSubview(canvasView)
        canvasView.frame = view.bounds
        canvasView.becomeFirstResponder()
        toolPicker.addObserver(canvasView)
    }

    // Saving drawing to PKDrawing (binary format)
    func saveDrawing() {
        let drawingData = canvasView.drawing.dataRepresentation()
        let url = FileManager.default.urls(
            for: .documentDirectory, in: .userDomainMask
        )[0].appendingPathComponent("drawing.drawing")
        try? drawingData.write(to: url)
    }
}

extension DrawingViewController: PKCanvasViewDelegate {
    func canvasViewDrawingDidChange(_ canvasView: PKCanvasView) {
        print("Canvas changed: \(canvasView.drawing.strokes.count) strokes")
    }
}

PKCanvasView with drawingPolicy .anyInput accepts both Apple Pencil and finger input. PKToolPicker gives the user tool selection without needing to write custom UI. PKDrawing is stored in a binary format with high compression — one hour of drawing takes about 5–10 MB.

Scribble and Text Recognition

Scribble (iPadOS 14+) allows handwriting in any UITextField and UITextView. The system recognizes handwriting on-device using the Neural Engine. The ML model works with Latin and Cyrillic scripts. In iOS 17+, Scribble supports autocorrection and next-word prediction. The developer does not need to add code — Scribble works automatically with any input field.

Hover API for Apple Pencil Pro

Starting with iPadOS 17.4 and Apple Pencil Pro, developers get hover events when the stylus approaches the screen (up to 12 mm). The event contains position, force, and azimuth. Applications: preview of brush contact point in drawing apps, tool preview, visual feedback before touch.

Adapting the Interface for iPad

Adaptive interface is a mandatory requirement for iPad apps. iPad operates in different screen sizes (8.3"–13") and multitasking modes. UIKit provides Size Classes (horizontal: .regular/.compact, vertical: .regular/.compact) and UISplitViewController for automatic adaptation.

Size Classes and traitCollection

Size Classes are an abstraction that defines available space. On iPad in full-screen mode, both axes are .regular. In Split View (50%), the horizontal class can become .compact on iPad mini or iPad Air. All popular layouts built with Auto Layout and UICollectionViewCompositionalLayout adapt automatically. Custom adaptation is done by overriding traitCollectionDidChange.

import SwiftUI

/// Adaptive layout for iPad using Size Classes
struct AdaptiveContentView: View {
    @Environment(\.horizontalSizeClass) private var horizontalSizeClass
    @Environment(\.verticalSizeClass) private var verticalSizeClass

    var body: some View {
        if horizontalSizeClass == .regular && verticalSizeClass == .regular {
            // Tablet mode: sidebar + content
            NavigationSplitView {
                SidebarView()
            } detail: {
                ContentGridView()
            }
        } else {
            // Compact mode: stack navigation
            NavigationStack {
                ContentGridView()
            }
        }
    }
}

/// Example adaptive grid: 3 columns on iPad, 2 on iPhone
struct ContentGridView: View {
    @Environment(\.horizontalSizeClass) private var horizontalSizeClass

    private var columns: [GridItem] {
        let count = horizontalSizeClass == .regular ? 3 : 2
        return Array(repeating: GridItem(.flexible(), spacing: 16), count: count)
    }

    var body: some View {
        ScrollView {
            LazyVGrid(columns: columns, spacing: 16) {
                ForEach(items) { item in
                    ItemCard(item: item)
                }
            }
            .padding()
        }
    }
}

In the example, NavigationSplitView is used only when horizontalSizeClass == .regular (full-screen iPad). NavigationStack is used in compact mode. The number of grid columns (3 vs 2) also changes depending on Size Classes. Everything updates automatically when the multitasking mode changes.

UISplitViewController: Three-Column Navigation

UIKit provides UISplitViewController with three styles: .doubleColumn (sidebar + detail), .tripleColumn (sidebar + primary + detail), and .single. In iPadOS 16+, splitViewController automatically switches between styles when the size class changes. The developer sets viewControllers for each column, UIKit manages visibility.

Frameworks and APIs for iPadOS

iPadOS SDK includes all iOS frameworks as well as APIs available only on iPad. Below are the key iPad-specific capabilities.

Drag & Drop

iPadOS supports Drag & Drop between apps and within an app. UIDragInteraction and UIDropInteraction allow dragging text, images, files, and custom objects. Drag & Drop works simultaneously with Multi-Touch: the user can drag multiple items with different fingers. In SwiftUI, .onDrag and .onDrop modifiers are used.

Keyboard Shortcuts

When a keyboard is connected (Magic Keyboard, Smart Keyboard), UIKeyCommand allows adding hotkeys. In iPadOS 17+, keyboard shortcuts are displayed when holding Cmd. Apple recommends supporting standard combinations: ⌘C (copy), ⌘V (paste), ⌘F (find), ⌘N (new document).

External Monitors

iPadOS 17+ supports external monitors with native resolution up to 6K (Pro Display XDR). An app can display content on an external screen through UIWindowScene with a separate session identifier. Stage Manager allows placing up to 4 windows on an external monitor with resizable dimensions.

Optimizing Apps for iPad

Development for iPadOS requires a special approach to UI/UX, performance, and testing. Errors that are forgivable on iPhone become critical on iPad due to the larger screen and multitasking.

Performance and Memory

iPad uses M-series chips (M1, M2, M4) with unified memory up to 16 GB. Despite the powerful hardware, an app in Split View or Slide Over shares resources with another app. Memory pressure is higher than on iPhone. Use image compression, lazy loading collections, and profiling through Instruments Allocations. iPad Pro M4 with 16 GB allows running desktop-class apps (Final Cut Pro, Logic Pro).

Keyboard First Design

Most iPad users use an external keyboard. The interface should be fully keyboard-navigable: Tab for field navigation, Space for activating a selected element, Enter for confirmation. Add support for Full Keyboard Access — a system setting that allows controlling any UI element with the keyboard.

Testing on Real Devices

The iPad simulator does not fully reproduce multitasking behavior. Test on a real device in different modes: Split View with a heavy app (Safari with 20 tabs), Stage Manager with 4 windows, Slide Over with quick app switching. Check the scenario: the user opens the app from Slide Over, drags it to Split View, changes the size, closes it — the app should not crash.

// Checking current multitasking mode on iPadOS
- (void)checkMultitaskingMode:(UIWindowScene *)scene {
    if (scene.traitCollection.userInterfaceIdiom != UIUserInterfaceIdiomPad) {
        return;
    }

    BOOL isFullScreen = (scene.traitCollection.horizontalSizeClass == UIUserInterfaceSizeClassRegular &&
                              scene.traitCollection.verticalSizeClass == UIUserInterfaceSizeClassRegular);

    BOOL isSlideOver = (CGRectGetWidth(scene.coordinateSpace.bounds) == 320.0);

    if (scene.windows.first?.windowScene?.activationConditions.canBecomeFocused == YES) {
        NSLog(@"Stage Manager active");
    }

    if (isSlideOver) {
        NSLog(@"Slide Over mode");
    } else if (isFullScreen) {
        NSLog(@"Full screen mode");
    } else {
        NSLog(@"Split View mode");
    }
}