Watch App: What Is It, Development for Apple Watch and Wear OS

What is Watch App

Watch App is an application designed to work on wearable devices: Apple Watch (watchOS) and smartwatches on Wear OS. The main difference from a mobile app is the form factor. The watch screen has a diagonal of 1.5–2 inches (versus 6–7 inches for a smartphone), which limits the amount of information displayed simultaneously. Interaction with the app is short — the user checks the time, notification, heart rate or steps in 5–15 seconds, then lowers their hand.

Key Watch App scenarios: fitness tracker (steps, heart rate, calories, sleep), notifications (messages, calls, calendar), quick actions (start timer, reply to a message by voice, control music), companion (camera remote, car keys, NFC payment). According to Counterpoint Research (2026), the global smartwatch market exceeds 150 million devices per year, of which Apple Watch holds 35%, Wear OS — 20%, the rest — Fitbit, Garmin and others.

Watch App limitations: small screen (up to 2 inches), limited battery life (up to 18–24 hours), no full keyboard (only voice input or dictation), background task limit (watchOS — up to 10 minutes, Wear OS — up to 5 minutes), need to sync with phone for most functions. Starting with watchOS 6 (2019) and Wear OS 3 (2022), apps can work autonomously via LTE module without being paired with a phone.

Apple Watch: watchOS and SwiftUI

watchOS is Apple's operating system for smartwatches, based on iOS and using the same frameworks (Foundation, UIKit in adapted version, SwiftUI). Development is done in Xcode using Swift. The main UI framework is SwiftUI, which provides watchOS-specific components: TabView with carousel, NavigationStack, Digital Crown via DigitalCrownModifier, long-press menu.

Navigation on watchOS is built on a hierarchical paradigm. Main elements: hierarchical stack (NavigationStack with automatic return), modal presentations (sheet), page-based navigation (via TabView with .tabViewStyle(.page)), context menus on long press. Digital Crown allows scrolling content and changing values. Gestures: tap, long press, swipe, Force Touch (until watchOS 7), Digital Crown rotation.

Key watchOS frameworks: HealthKit (access to health data — heart rate, steps, sleep, ECG), CoreMotion (accelerometer, gyroscope), WatchConnectivity (data exchange with iPhone), ClockKit (complications on watch face), BackgroundTasks (background updates up to 10 minutes), ARKit (FaceTime effects on Series 9+). A Watch App can be full-featured (separate app in the dock) or an extension (simultaneous with iOS version).

Wear OS: Kotlin and Compose

Wear OS is Google's platform for smartwatches, based on Android. Modern development is done in Kotlin with Jetpack Compose for Wear OS — a set of components optimized for round screens: Scaffold, ScalingLazyColumn, Chip, Button, Card, Stepper. Unlike mobile Compose, Wear OS uses its own modifiers: scrollable for vertical scrolling, swipable for swiping, RotaryInput for crown control.

Navigation on Wear OS uses a side panel (SwipeToDismiss) and card screens. Main elements: SwipeDismissableNavHost (navigation with swipe-back), screen positioning (ScalingLazyColumn for lists), horizontal carousel (Carousel), watch face (WatchFace via WatchFaceService). Google recommends using side swipe for back navigation and vertical scroll for lists. The power button on the watch opens the list of recent apps.

Health and sensors on Wear OS: Health Services API (steps, heart rate, calories, sleep, SpO2 via data providers), SensorManager (accelerometer, gyroscope, barometer, magnetometer), Location Services (GPS via FusedLocationProvider). Wear OS 5+ supports tracking running, walking, cycling and swimming with automatic activity type detection. Data syncs with Google Fit via Health Connect.

Code Example: Swift for Apple Watch

Let's look at a heart rate monitoring app for Apple Watch using SwiftUI and HealthKit.

import SwiftUI
import HealthKit

// Heart rate data model
struct HeartRateData: Identifiable {
    let id = UUID()
    let bpm: Double
    let date: Date
}

// ViewModel for HealthKit
@Observable
final class HealthViewModel {
    private let healthStore = HKHealthStore()
    var currentHeartRate: Double = 0
    var isAuthorized: Bool = false

    func requestAuthorization() {
        guard let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate)
        else { return }
        let types = Set([heartRateType])
        healthStore.requestAuthorization(toShare: nil, read: types) { success, _ in
            Task { @MainActor in
                self.isAuthorized = success
                if success { self.startHeartRateQuery() }
            }
        }
    }

    func startHeartRateQuery() {
        guard let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate)
        else { return }
        let query = HKObserverQuery(
            sampleType: heartRateType, predicate: nil
        ) { [weak self] _, _, _ in
            self?.fetchLatestHeartRate()
        }
        healthStore.execute(query)
    }

    private func fetchLatestHeartRate() {
        guard let heartRateType = HKQuantityType.quantityType(forIdentifier: .heartRate)
        else { return }
        let sort = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: false)
        let query = HKSampleQuery(
            sampleType: heartRateType, predicate: nil,
            limit: 1, sortDescriptors: [sort]
        ) { _, samples, _ in
            guard let sample = samples?.first as? HKQuantitySample else { return }
            let bpm = sample.quantity.doubleValue(for: HKUnit.count().unitDivided(by: .minute()))
            Task { @MainActor in
                self.currentHeartRate = bpm
            }
        }
        healthStore.execute(query)
    }
}

// Main screen
struct HeartRateView: View {
    @State private var viewModel = HealthViewModel()

    var body: some View {
        VStack {
            Image(systemName: "heart.fill")
                .foregroundColor(.red)
                .font(.largeTitle)

            Text("\(Int(viewModel.currentHeartRate))")
                .font(.system(size: 60, weight: .bold, design: .rounded))
                .foregroundColor(.red)

            Text("BPM")
                .font(.caption)
                .foregroundColor(.secondary)
        }
        .padding()
        .onAppear(perform: viewModel.requestAuthorization)
    }
}

Key points: HKHealthStore requests access to HealthKit data; HKObserverQuery notifies about heart rate changes in real time; HKSampleQuery gets the latest value. Watch App automatically updates the UI when currentHeartRate changes thanks to @Observable. HealthKit processes data locally on the device — no server requests are needed.

Code Example: Kotlin for Wear OS

Similar app for Wear OS in Kotlin with Jetpack Compose and Health Services API.

// MainActivity.kt
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.wear.compose.material.*
import androidx.wear.compose.foundation.arc.BasicArcParams
import com.google.android.horologist.health.HealthService

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            WearAppTheme {
                HeartRateScreen()
            }
        }
    }
}

@Composable
fun HeartRateScreen() {
    var heartRate by remember { mutableIntStateOf(0) }
    var isConnected by remember { mutableStateOf(false) }

    LaunchedEffect(Unit) {
        // HealthService — API for sensor access
        val healthService = HealthService()
        healthService.connect().onSuccess {
            isConnected = true
        }
    }

    Scaffold(
        timeText = { TimeText() },
        vignette = { Vignette(vignettePosition = VignettePosition.TopAndBottom) }
    ) {
        Column(
            modifier = Modifier
                .fillMaxSize()
                .scrollable(state = ScrollState),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Center
        ) {
            Icon(
                imageVector = Icons.Filled.Favorite,
                contentDescription = "Heart Rate",
                modifier = Modifier.size(40.dp),
                tint = MaterialTheme.colors.error
            )

            Text(
                text = heartRate.toString(),
                style = MaterialTheme.typography.display1
            )
            Text(
                text = "BPM",
                style = MaterialTheme.typography.caption2
            )
        }
    }
}

Key Wear OS components: Scaffold with TimeText and Vignette for a standard layout; .scrollable() modifier for round screen compatibility; HealthService (Horologist) for heart rate sensor access. Jetpack Compose for Wear OS automatically adapts the interface for round and square screens — the developer doesn't need to handle different form factors manually.