ZSWatch: a Zephyr-based smartwatch you build yourself, hardware and firmware included

What ZSWatch actually is, and who the project is aimed at

ZSWatch is a smartwatch built from scratch, both hardware and software, on the Zephyr RTOS. The name is a contraction of Zephyr Smartwatch, and the repository holds the firmware, the enclosure resources and the production test code, while the PCB designs live in separate repositories for the watch, the development kit, the extension board and the dock. The primary language is C, and the licence is GPL-3.0.

The audience is not someone comparing watches in a shop. It is an embedded developer who wants a wearable target with real sensors, a real display and a real BLE stack, and who is willing to run a Zephyr toolchain to get there. The hardware list reads like a component catalogue: an nRF5340 BLE chip in a u-blox NORA-B10 module with a 128 MHz dual core, 512 KB RAM and 1 MB flash, a 240x240 round touch display driven over a 30 MHz SPI bus, a Bosch BMI270 IMU for gesture navigation, wrist-wake and step counting, a Bosch BMP581 pressure sensor quoted at roughly 20 cm accuracy, an ST magnetometer, 64 MB of external Macronix flash, a Broadcom light sensor for automatic brightness, a Micro Crystal RTC, an I2S microphone and a Nordic nPM1300 PMIC.

That is a lot of silicon to bring up, and it is the point. The project is a platform for firmware work, not a finished product with a support line.

How the firmware, app framework and phone link fit together

The firmware is a Zephyr application. The repository separates the application code under app/ from hardware resources, power and debug tooling, production test code and the website, with Zephyr pulled in as a submodule. That layout matters because it tells you where your own code goes: applications live under the app source tree, and the README points to app/src/applications/settings, app/src/applications/music_control and app/src/applications/compass as examples of what an application looks like.

The README describes an application picker with an extensible app framework, and multiple watchfaces that are dynamically switchable, showing time, date, battery, weather, steps, notifications and environmental data. So the runtime model is a shell with switchable faces and a launcher for small apps, rather than a single monolithic UI.

Phone communication is Bluetooth LE. On iOS the project ships an official ZSWatch Companion App on the App Store, and the watch also speaks the native Apple Notification Center Service and Apple Media Service, which means an iPhone can deliver notifications and media control without the companion app in the loop. On Android the companion app is described as experimental and currently requires invite access, with GadgetBridge named as the stable option. That asymmetry is the most consequential architectural fact for anyone planning a daily driver: the iOS path has a first-party client, the Android path leans on a third-party one.

Getting started with the WatchDK and a first build

The recommended entry point is the WatchDK, a development kit priced at $99 that carries the same nRF5340 chip and sensors as the final watch in a larger form factor with breakout headers and a debug header. Battery is optional and it runs from USB-C. The README links a quick start page at zswatch.dev for the kit and a separate toolchain page for environment setup, building and flashing. The repository does not restate those commands, so the site is the place to follow them.

What the repository does show is the shape of the tree you will be working in. After cloning, Zephyr arrives as a submodule, which is why the project's own instructions cover the toolchain rather than assuming a system Zephyr install:

git clone https://github.com/ZSWatch/ZSWatch.git
cd ZSWatch
git submodule update --init --recursive

The top level then contains app/, hardware/, power_debug/, production_test/, resources/ and website/. Your application code belongs under app/, and the README's writing-apps page at zswatch.dev/docs/development/writing_apps is the reference for adding one. The documentation also covers PCB design for anyone going past the kit to a self-built board.

One practical note from the release history: v0.8.1 is titled "RTC Auto detect DevKit LiPo compatability", which suggests that the RTC and battery behaviour of the kit changed between revisions. Check the release notes against the board you actually have before flashing. The README does not describe a rollback procedure for a bad flash, so treat the debug header as your recovery path rather than assuming one exists in software.

Where ZSWatch is the wrong tool

The obvious limitation is that this is not a product. There is no consumer sales channel described in the README beyond ordering the development kit from Elecrow, and the watch itself is something you assemble, print or machine. The enclosure is a 3D-printed case with 3D-printed buttons, with an option for a CNC-machined metal casing, so the finish depends on your printer or your supplier.

The software has rough edges that the README states plainly. The Android companion app is experimental and gated behind invite access requested through Discord or email, with GadgetBridge offered as the stable alternative. The health and audio extension board is marked work in progress, and the README warns that its design, BOM and firmware support may change. If your goal is heart-rate or speaker features, you are building on a moving target.

There is also a hardware revision treadmill. The hardware overview image is labelled v5 with v6 coming soon, the extension board is roughly 16.8 mm in diameter and plugs into the WatchDK headers, and firmware releases carry compatibility notes about the DevKit. Anyone treating this as a long-lived personal device should expect to track revisions rather than buy once and forget.

Finally, the price question has no single answer in the repository. The $99 figure applies to the WatchDK. A self-built watch costs whatever your PCB fabrication, assembly, display, module and casing come to, and the README does not total that up.

How it differs from GadgetBridge and from ESP32 watchface projects

GadgetBridge is not a competitor to ZSWatch, and the README treats it as a companion rather than a rival: it is the recommended Android client for talking to the watch. The difference in approach is that GadgetBridge is a phone-side application that speaks to existing commercial wearables, while ZSWatch is the wearable itself. If you already own a supported watch and want to escape a vendor cloud, GadgetBridge is the smaller commitment. If you want to control what runs on the watch, GadgetBridge does not help you.

A closer comparison is the ESP32 watchface work. The README notes that the watch supports ESP32 watchfaces from Felix Biego and links a fork, esp32-lvgl-watchface, for details. Both projects render watchfaces with LVGL, which is listed among the repository topics alongside the GC9A01A display controller. The difference is the target: the ESP32 route is a cheaper, more common chip with a smaller sensor set, while ZSWatch is built around the nRF5340 dual-core part with its BLE stack and the full sensor complement described above. Choosing between them is mostly a question of whether you want the Nordic toolchain or the Espressif one.

Maintenance, licence and what upgrades cost you

The repository is not archived and the last push was on 2026-09-11, so the project is being worked on. Releases are spaced rather than continuous: v0.7.0 in November 2025, v0.8.0 in March 2026 and v0.8.1 shortly after. The version numbers are still in the 0.x range, which is consistent with a project that changes interfaces between releases. Budget for reading release notes before every firmware update, particularly around RTC and battery behaviour, since that is what the v0.8.1 title flags.

The upgrade cost is mostly toolchain and submodule management. Zephyr is pulled in as a submodule, so moving to a new firmware release can mean moving the Zephyr revision underneath it, and the toolchain page is the authority on what that requires. There is no package manager shortcut here.

The licence is GPL-3.0, and the repository ships a LICENCE file at the top level. For most readers the practical consequence is that if you distribute a modified watch firmware, the source has to travel with it under the same terms. The hardware repositories are separate projects, so do not assume the firmware licence tells you everything about the PCB files. This is not legal advice; read the LICENCE file and the individual hardware repositories before you plan a commercial product around any of it.

Editorial conclusion

Adopt ZSWatch if you want to write firmware for a watch you can also modify at the PCB level, and start from the WatchDK rather than a finished unit. Do not adopt it if you need a polished consumer wearable or a phone app that anyone can install today, since the Android companion app still requires invite access. Before ordering anything, read the WatchDK quick start and the toolchain page at zswatch.dev, and check which hardware revision the firmware release you plan to flash was built against.

Frequently asked questions

Official sources

1. License: GPL-3.0
2. Project website
3. README
4. Releases
5. ZSWatch/ZSWatch on GitHub