wasp-os: a MicroPython watch firmware for PineTime and nRF52 smartwatches

A firmware that hands you the watch instead of shipping one fixed product

wasp-os is a firmware for smart watches based on the nRF52 family of microcontrollers, aimed especially at hacker friendly watches such as the Pine64 PineTime. The feature list in the README is what a watch user expects to find: full heart rate monitoring, step counting, multiple clock faces, a stopwatch, an alarm clock, a countdown timer, a calculator, and games and utilities beyond that. What separates it from a stock watch firmware is the last clause of that sentence, that all of this comes with access to the MicroPython REPL for interactive tweaking, development and testing. In practice that means the watch behaves like a small Python machine: you can connect to it over Bluetooth and type at it, or write applications for it in Python and ship them to the device. The primary language of the repository is Python, and the top level tree shows the pieces that make this possible, with an apps directory, a watch_faces directory, a wasp directory holding the application framework, and a micropython directory.

The bootloader was rewritten for devices with no reset button or UART

wasp-os ships with a bootloader integrated from the Adafruit NRF52 Bootloader, and the README is specific about what was changed and why. The bootloader has been extended so that it holds up for development on form-factor devices that have no reset button, no power switch, no SWD debugger and no UART. That is the PineTime situation exactly, and it is the reason the project claims you can confidently develop on sealed devices using Bluetooth Low Energy for over-the-air updates. A sealed watch with a fixed back and no physical controls cannot be recovered by pressing a button during a failed flash, so the recovery path has to live in the bootloader and the radio. This is the part of the design that carries the most engineering weight, and it is also the part a user touches without noticing: the ability to reflash a watch that has no way to be put into a bootloader by hand.

Building from source, because the binary releases have been withdrawn

The README is unusually direct about the current state. It opens by looking for new maintainers, saying wasp-os is no longer being actively maintained by its original author, while noting that helpful people remain around the project and that new developers would be welcome. It lists two concrete gaps: the project is based on a relatively old version of MicroPython and would benefit from a version uplift, which needs skill in both Python and embedded C, and a release manager is needed to build, test and issue new releases. The consequence for users is stated next. The binary releases up to wasp-os-0.4 have been withdrawn because they do not support the third generation PineTime, and until that is fixed, building from source is the best and only option. So a reader deciding whether to adopt this project should know that they are signing up for a toolchain, not a firmware image. The Makefile confirms the shape of that toolchain, with a BOARD variable that must be set explicitly and separate targets for bootloader, reloader and micropython.

Three boards install without tools or disassembly

The Getting Started section names the devices that can be flashed without any tools or disassembly: the Pine64 PineTime, the Colmi P8 and the Senbono K9. It points at the Installation Guide in the documentation for the actual procedure. The end state is described so you know what success looks like: the watch shows the time, 03:00, together with a date and a battery meter, and once it drops into power saving mode you use the button to wake it again. At that point the Nordic UART Service is available and the MicroPython REPL can be reached. The repository ships a command line tool for this, tools/wasptool, and the console flag opens the REPL on the watch. From the host side you can also set the time and restart the main application without typing at the watch, which the README shows as a pair of commands to run in the REPL after interrupting it with ^C.

To set the time and restart the main application, interrupt the REPL with ^C and then run:

^C
watch.rtc.set_localtime((yyyy, mm, dd, HH, MM, SS))
wasp.system.run()

The REPL itself is reached with:

tools/wasptool --console

If you have a suitable GNU/Linux workstation, the same work is one command:

./tools/wasptool --rtc

wasptool carries the developer workflow, over the air and from the shell

tools/wasptool is the entry point for everything that happens from a workstation, and the README names two of its modes directly. The console mode gives access to the MicroPython REPL through the Nordic UART Service. The rtc mode is the counterpart for the clock: if you have a suitable GNU/Linux workstation, running it sets the time and restarts the main application, and the README notes that it can run those commands automatically. That last point matters for anyone who has dealt with a watch that boots to the wrong time and then derives everything else from it. Over-the-air updates are the other half of the story, and they follow from the bootloader work: the reloader component in the tree handles the wireless side, with the Makefile building it per board. The overall picture is a complete development loop for a sealed device: flash once over a wire, then push changes over Bluetooth and talk to the Python REPL whenever you need to.

wasp.toml decides which applications and watch faces land on the device

Customisation is handled by a single file at the top of the repository. The README says wasp-os is designed to let users easily create their own custom builds by modifying wasp.toml to include the apps and watch faces of your choice, with the documentation holding the details on how to build. The watch_faces and apps directories in the tree hold the candidates, and the screenshots in the README show the range on offer, including a digital clock, a week day clock, an analogue clock, a dual clock, a Fibonacci clock that renders the time as a sum of coloured segments, a word clock and a resistor clock, most of them shown running on the wasp-os simulator rather than real hardware. The simulator is the practical detail for evaluation: it lets you look at the application set and the faces without flashing anything. The Makefile also shows the build pulling in generated artefacts per board, including a board specific watch configuration file and an app registry, which is how a trimmed build knows which applications exist on the device.

Where the project stands: no active maintainer, an old MicroPython base, an open invitation

The state of the project is best read from three facts rather than from a status badge. The repository is not archived and the last push was on 2026-08-29, so commits are still landing. The tagged releases stop much earlier, with v0.4 published on 2021-02-20, v0.3 on 2020-11-22 and v0.2, known as M2, on 2020-05-21. And the README states plainly that the project is no longer actively maintained by its original author and asks for maintainers, for someone with both Python and embedded C skills to lift the MicroPython version, and for a release manager to build, test and issue releases. The README also notes that many drivers and features still need to be developed and points to the Roadmap for the current status. The licence is GPL-3.0, with COPYING and COPYING.LGPL at the root, and the documentation is published on Read the Docs under wasp-os.readthedocs.io, including an Application Writer's Guide for people writing applications.

Editorial conclusion

wasp-os suits a hobbyist with a PineTime or Colmi P8 who wants to write their own watch faces and apps in MicroPython and is willing to build the firmware from source, since the bootloader, the BLE reloader and the Python application model are all there to work with. It does not suit someone who wants a firmware download, a supported release, or an upstream that ships third generation PineTime binaries, because the published releases have been withdrawn and the README states the project is no longer actively maintained. Before you start, read the notice about the withdrawn binaries and the old MicroPython base, and confirm your watch model is one of the listed devices before planning around the install guide.

Frequently asked questions

Official sources

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