Wear OS app development,
without the two-platform confusion.
Search for wear os app development and you get two platforms mashed together: Google’s Wear OS for Android watches, and Apple’s watchOS for the Apple Watch. They use different languages, different stores, and different rules for whether a watch app needs a phone nearby at all. This guide keeps them separate, checks the rules against Google’s and Apple’s own developer documentation, and is honest about where cross-platform app development stops covering the watch itself.
2019
watchOS 6 put an App Store directly on Apple Watch
3
watchOS setups: watch-only, dependent, or independent
Standalone
is Google's recommended default for a Wear OS app
1
app store pipeline for Wear OS — it ships through Google Play
The short answer
A wear os app can run on its own or lean on a paired phone — Google calls this standalone versus non-standalone, and Apple calls the equivalent independent versus dependent. Both platforms now let a watch app skip the phone entirely: Wear OS apps are published through Google Play with a manifest flag that declares standalone status, and Apple Watch apps can be watch-only or independent since the App Store arrived directly on the watch. Neither is built by a cross-platform framework like React Native on its own — each needs its own native toolkit on top.
At a glance
Wear OS vs Apple Watch, side by side.
A google wear os app and an Apple Watch app solve the same job — something useful on your wrist — with almost no shared plumbing underneath. Most of that usefulness is sensor data read off the wrist itself, and the accelerometer is the one nearly every watch app ends up touching, whether for step counts, wrist-raise detection, or workout tracking.
| Aspect | Wear OS (Google) | watchOS (Apple Watch) |
|---|---|---|
| Native toolkit | Kotlin, with Jetpack Compose for Wear OS | Swift, with SwiftUI or WatchKit |
| Where it's published | Google Play — same listing pipeline as the phone app | The App Store on Apple Watch |
| Can it run without a phone? | Yes, once declared standalone in the manifest | Yes, as a watch-only or independent app |
| How you declare that | com.google.android.wearable.standalone set to true | “Supports Running Without iOS App Installation,” or a watch-only project |
| Companion phone app | Optional — Google recommends the watch work without one | Optional — watch-only, dependent, and independent are all valid |
| Data without a phone nearby | The watch app must fetch and store its own data | The watch app can't rely on Watch Connectivity as its main source |
Try it
Where do you actually flip the independence switch?
One platform, one manifest value. The other, one checkbox in Xcode.
Declared in AndroidManifest.xml
<meta-data
android:name="com.google.android.wearable.standalone"
android:value="true" />Set the value to true and the watch app is standalone. Set it to false and Google Play treats it as a companion app that needs the phone.
Android watches
Wear OS app development.
A google wear os app is an Android app built specifically for Wear OS hardware, and Google’s own developer documentation is unusually direct about how it wants that app to behave.
Standalone vs non-standalone
Every wear os watch app declares itself in AndroidManifest.xml with a com.google.android.wearable.standalone meta-data value. A standalone app is fully usable without a paired phone — its core functions, including authentication, run locally on the watch. A non-standalone app is still downloadable from Google Play on its own, but it requires the companion phone app before it’s actually usable. Google’s guidance is explicit that it recommends the standalone route by default, and reserves non-standalone for cases where something like authentication genuinely can’t work without the phone and can’t be replaced with an alternative such as a QR code or a shortlink.
That default matters for reach, not just user experience: Google validates the standalone declaration when it serves the app, and a non-standalone app isn’t visible to Wear OS devices that aren’t currently paired to a handheld device.
Publishing to the wear os app store
There’s no separate storefront to learn. A wear os app store listing is packaged and distributed through Google Play, the same pipeline your phone app already uses, with the manifest telling Google Play (and the watch itself) whether the app can stand on its own.
Source: Android Developers, Standalone versus non-standalone Wear OS apps.
Apple Watch
Apple Watch app development.
Apple’s equivalent decision isn’t binary — its own developer documentation lays out three distinct project types, and which one fits depends on whether an iPhone counterpart exists at all.
Watch-only, dependent, and independent apps
Apple’s documentation on creating independent watchOS apps names three setups. A watch-only app has no related iPhone app at all — Xcode still creates a stub iOS target behind the scenes, but nothing installs on the paired iPhone. A dependent watchOS app is what Xcode creates by default when you add a companion iOS app, and it needs that iOS app installed to function — people have to install both. An independent watchOS app has a companion iOS app but doesn’t require it: in Xcode, you turn this on with the “Supports Running Without iOS App Installation” option under the watch target’s Deployment Info.
This has been possible since Apple put an App Store directly on Apple Watch, letting people discover, buy, and install apps without ever opening a companion app on their iPhone. Apple’s own support documentation for that store still notes that some apps require the iOS version to also be installed — a reminder that “on the watch” and “independent of the phone” aren’t automatically the same thing.
What an independent watchOS app has to handle itself
Turning on independence doesn’t remove work, it moves it. Apple’s guidance names four things the watch app has to own on its own, with an iPhone treated as a bonus, not a guarantee.
Sign-in & accounts
Create accounts and sign users in on the watch itself, with no phone-side screen to lean on.
System permissions
Request camera, location, or notification access directly on the watch, using frameworks that show their own authorization screen there.
Data & sync
Download and store its own data — Watch Connectivity can be used opportunistically, but can't be the main data source.
Push notifications
Register for and receive push notifications, including complication pushes, straight on the watch.
Source: Apple Developer Documentation, Creating independent watchOS apps.
What it costs
Publishing fees, side by side.
Neither store charges extra for a watch app specifically — you pay once for the developer account, and the watch listing rides along with it.
| Aspect | Wear OS (Google Play) | Apple Watch (App Store) |
|---|---|---|
| Developer account fee | $25, one-time — Google Play Console registration | $99 per year — Apple Developer Program membership |
| Where you submit | Google Play Console | App Store Connect |
| Same account as your phone app? | Yes — one Google Play Console account covers Android and Wear OS | Yes — one Apple Developer account covers iOS and watchOS |
Sources: Google Play Console, Get started with Play Console and Apple Developer Program membership.
Try it
Should your watch app be standalone?
Pick the closest description of your situation, and see what Wear OS and watchOS each expect from it.
Beyond the phone
A watch is a small screen with its own rules.
A wear os watch app or an Apple Watch app isn’t just a shrunk-down phone screen — glanceable text, larger tap targets, and clear contrast matter even more on a display that size, and the same care applies everywhere your app runs beyond a normal phone. If accessibility on small, glanceable surfaces isn’t already part of how you design, our guide to mobile app accessibility is worth reading before you sketch the watch face.
Watches also aren’t the only surface that raises this “does it need a phone at all” question — TV platforms ask a version of it too, with their own store rules and their own standalone-app expectations. See our guide to Roku app development if the living room, not the wrist, is where you’re headed next.
Before you start
What building a wear os app actually takes.
Five decisions, in the order they actually need making, before a single line of watch UI gets written.
- 1
Decide which platform actually needs a watch app
Wear OS and watchOS solve the same problem for two different audiences. Building both at once doubles the native tooling, the store listings, and the maintenance. Most teams are better off shipping one well before attempting both.
- 2
Decide standalone vs companion for that platform
This is the decision that changes everything downstream: authentication, data storage, and notifications all have to work differently depending on whether the watch can assume a phone is nearby.
- 3
Pick the native toolkit
Jetpack Compose for Wear OS on the Android side, SwiftUI or WatchKit on the Apple side. Neither is optional, and neither is something a cross-platform framework generates for you.
- 4
Design the phone-to-watch bridge, if you need one
A non-standalone or dependent watch app still needs a defined way to talk to its phone app — Watch Connectivity on iOS, the Wearable Data Layer API on Wear OS — and that bridge is its own piece of work.
- 5
Plan the store listing for each platform separately
A Wear OS app is published through Google Play alongside (or instead of) your phone app. A watchOS app is published through App Store Connect, with its own screenshots and its own review.
The phone side
What a cross-platform framework can and can’t do here.
React Native and Expo build real, native iOS and Android phone apps, but neither generates the watch-side interface itself — Jetpack Compose for Wear OS and SwiftUI or WatchKit for watchOS are native toolkits with no cross-platform equivalent. The workable pattern is a small native watch target sitting next to your phone app, bridged over something like Watch Connectivity or the Wearable Data Layer API, so the phone app stays where the framework is strong and the watch app stays where the platform requires it.
We won’t walk through wiring that bridge here — it’s genuinely a native-code exercise on both sides, and it deserves its own reference. If you’re curious what else lives outside the main app screen on iOS, see our guide to iOS widgets.
Where Newly fits
The watch app is native. The phone app doesn’t have to be.
Newly is an AI app builder that turns a plain-English description into a real native iOS and Android app, built on React Native and Expo, that you own outright. It doesn’t generate Wear OS or watchOS UI — nothing that isn’t native Kotlin or Swift does — but it’s a fast way to build and own the phone app your watch app will eventually pair with, which is the larger part of most projects that end up needing a watch companion at all.
It starts at $25 a month, with iOS and Android deployment, real device simulators, and full source code ownership included.
FAQ
Wear OS app development, the quick answers.
They're built for different platforms with different tools and different stores. A Wear OS watch app runs on Google's Wear OS, is built with Kotlin or Jetpack Compose for Wear OS, and is distributed through Google Play. An Apple Watch app runs on watchOS, is built with Swift and SwiftUI (or WatchKit), and is distributed through the App Store on Apple Watch. Both platforms let a watch app run without a phone nearby, but neither ships from the same codebase or the same store.
Start with the app the watch eventually pairs with.
Before you scope a wear os app or an Apple Watch app, see what a real native phone app for it can look like.