Phase 1 field notes · KineticWear / Software Development / IoT
A smartwatch is a funny place to build a software framework. The screen is tiny, the battery is unforgiving, and the moment you think the interface is behaving, an innocent-looking dropdown can remind you that embedded systems have opinions.
But that’s exactly why I wanted to do it. I wasn’t trying to make another watch face. I wanted a small, independent computing platform I could wear, extend, and eventually connect to other experiments in sensing, feedback, and robotics. The first working milestone is now here: WristFoundry, an open-source ESP32-S3 smartwatch framework built with ESP-IDF and LVGL.
From CommandWatch to WristFoundry
The work started in a private project called CommandWatch. It proved out the essentials on real hardware: touch navigation, a scrolling launcher, back and home behavior, RTC-backed time, battery telemetry, and display sleep/wake. Once those fundamentals worked, the more interesting question became: could this become a clean starter platform for somebody else’s watch apps?
WristFoundry is the separate public answer. It has its own repository and history, an Apache-2.0 license, documented app registration and lifecycle callbacks, reusable services, example applications, and automated firmware builds. The original CommandWatch project stays separate.
Engineering note / What makes it a framework?
An application registers with the runtime and participates in a common create/show/hide/update/destroy lifecycle. Navigation and shared hardware ownership are managed centrally instead of every app reinventing them.
A tiny interface that has to work like a real interface
The target is the Waveshare ESP32-S3-Touch-AMOLED-2.06, with a 410 × 502 AMOLED touchscreen. The current interface includes a watch face, scrolling app launcher, Settings, system diagnostics, Wi-Fi scanning, an on-screen password keyboard, and timezone selection. These aren’t speculative screens; the source-derived mockups below closely match what is running on the device.

One deceptively useful feature is the keyboard. I don’t want a watch that requires me to rebuild firmware every time I change Wi-Fi networks. The development firmware can scan, select an SSID, and accept a password directly on the touchscreen. In that profile the credentials live in RAM and disappear after reboot. A separate secure profile supports encrypted persistent storage.
A watch should know the time without asking a phone
Wi-Fi/NTP is the primary synchronization design, with the PCF85063 hardware RTC keeping time when the radio is off. BLE remains available for optional applications, but the watch doesn’t need a Bluetooth phone-time service just to be a watch. The full real-network credential persistence, NTP-to-RTC writeback, and offline continuity sequence is still on the release acceptance checklist.
The real constraint is energy
An embedded device can have perfectly good code and still be a terrible watch if it keeps the screen and radios awake. WristFoundry dims the AMOLED, turns it off after inactivity, uses bounded Wi-Fi and BLE activity, and has battery-oriented light-sleep behavior. Radio ownership is explicit so applications don’t quietly leave connections running.
Those are working power-management policies, not a claimed battery-life number. Active, display-off, and sleep current still need proper battery-path measurements before we can publish meaningful runtime figures.
Engineering note / A screen-off watch is still running
The display state, Wi-Fi lease, BLE scan, RTC, and wake source all need coordinated lifecycles. Power management isn’t a single sleep call; it’s a contract among services.
A very small stack overflow with very large consequences
During development, adding a timezone dropdown produced a white-screen reboot loop. The culprit wasn’t the dropdown’s visual design: a large local UI buffer had pushed the main task over its stack limit. Moving timezone, Wi-Fi scan text, and scan-record buffers out of task stacks restored normal operation. It’s the sort of bug that reminds you a watch UI is still embedded software, with memory limits that don’t care how nice the mockup looks.
Security: a key that belongs to the watch
The optional secure-storage profile uses ESP32-S3 HMAC-backed encrypted NVS. A hardware-protected, device-specific secret helps protect saved credentials against straightforward flash copying. This also has a permanent consequence: first-time provisioning can consume an eFuse key block. That deserves a prominent warning and an explicit choice, not a surprise during ordinary development. The normal development profile makes no such irreversible change and keeps credentials volatile.
It’s also important not to oversell the protection. Encrypted NVS isn’t the same as securing every byte of flash, and secure boot and full flash encryption are separate decisions. The public repository documents those boundaries.
What Phase 1 actually proves
The development firmware has been built and flashed to the physical watch. Display and touch initialized, navigation survived a fifty-round stress test without an observed object leak, Wi-Fi scanning and network selection worked, the keyboard and timezone UI passed physical review, and the watch remained stable through dim and display-off behavior. GitHub CI also builds both development and encrypted-NVS configurations and generates checksums and a software bill of materials.
That is enough to call the functional watch and framework foundation milestone complete. It is not the same as declaring the first public firmware release finished. Secure-profile end-to-end acceptance, battery-path current measurements, and release controls are still on the list.
Where KineticWear goes next
The watch is a useful starting point for a bigger set of ideas: accelerometer games, motion sensing, haptic feedback, physical-computing experiments, and eventually interfaces to robotic systems. Before that, I want the basics to be boringly reliable. A watch that can boot, navigate, keep time, conserve power, and recover cleanly is a better foundation than a flashy demo that only works while plugged into USB.
The source is already public at github.com/macroflux/wristfoundry. The first tagged release will follow the remaining acceptance tests. For now, Phase 1 is a working platform, a collection of hard-earned embedded lessons, and a small screen with a surprisingly large future.
