Pebble watch faces & apps in Elm.
Elm Pebble gives Pebble developers a real language and a tight feedback loop: model your app in Elm, see it on a tiny round screen, and keep the logic understandable as the interface evolves.
Beta notice: Elm Pebble is still evolving. The compiler, IDE, runtime packages, and public APIs can change while the project settles.
Why bother (in a good way)
Sketch a face quickly
Elm keeps UI experiments readable, so you can try a layout, adjust it, and keep moving without a pile of mystery state.
Fewer “wait, why did that crash?” moments
Typed messages and explicit updates make small watch apps easier to reason about as they grow.
Make something people can wear
Tweak colors, complications, and interaction details until the watch face feels right on real hardware.
The shape of the system
Elm Pebble keeps the application loop and build pipeline explicit, so you can see where state, events, UI, and Pebble tooling fit together.
Elm Architecture on the watch
Messages come from Pebble events and subscriptions, update changes the model, and view redraws the Pebble UI from that model.
From Elm code to a Pebble app
Elm Pebble branches the project into native C output for the Pebble SDK and JavaScript output for the phone-side companion app.
Features
Elm Pebble brings the parts you need for real Pebble projects into one Elm-first workflow.
Elm to native Pebble apps
Write Elm and compile to C code that runs on the Pebble SDK instead of a browser runtime.
Typed Pebble UI
Build watch screens with Elm data structures for text, images, shapes, layout, colors, and resources.
Companion communication
Define shared protocol types for watch-to-phone messages, including AppMessage-style data flow.
Project templates
Start from working watchface, companion app, and protocol templates instead of assembling the structure by hand.
Browser-based IDE
Edit, inspect, and build projects from the Elm Pebble IDE with tooling shaped around Pebble apps.
Hardware-oriented loop
Use the Pebble SDK, emulator, and real watches as the target for every iteration.
How Elm Pebble works
Pebble apps are not web pages: there is no browser on the watch. You write Elm that compiles to C and drives Pebble's native UI. Anything that makes this site pretty in your desktop browser stays there—your watch never sees it.
1. Start small
Grab a minimal watch face or tiny app skeleton, then grow it one visible behavior at a time.
2. Play in Elm
Describe the screen with Elm and the Pebble UI API; the compiler turns that into native draw code—not HTML or CSS on the watch.
3. Try it on hardware
Build with the Pebble SDK, run the emulator or flash your watch, and see how the idea feels on the wrist.
Who it is for
Pebble fans, Elm-curious developers, and anyone who wants a calmer way to build watch faces and small wrist apps with explicit state and predictable updates.
Clone, run, and iterate from Elm code to an emulator or watch without losing the shape of your app.