Glass: The Screen Is Generic, the Interface Is a Message
Posted: 2026 | Category: Hardware Platform
The Screen With Three Buttons On It
Every machine eventually wants one. A workshop press that should show the current program and a big red stop. A van that needs the next drop and a “done” button. A test rig with a temperature, a bar and two toggles. Nothing exotic. Three buttons and a number.
And then you ask what it costs to build.
You get a firmware project. A board to pick, a display driver to fight, a touch controller with undocumented reset timings, a Bluetooth stack, a build toolchain, an over-the-air update path, and someone who owns all of it for the next five years. Three months later there is a screen with three buttons on it, and the moment the workflow changes, you are recompiling firmware and walking around the building with a USB cable.
Three buttons and a number is the ask. A five-year firmware commitment is the quote.
The screen was never the hard part. The coupling was. Every application had to become firmware.
The Split That Fixes It
Glass is a wireless HMI terminal: an ESP32-S3 with a 4.3 inch touchscreen, or a 4 inch square one, that knows nothing whatsoever about your application.
An app links to it over Bluetooth LE and ships one declarative interface as a single compact message. Screens built from seven primitives: box, text, button, list, progress, gauge, image. After that, the app streams key/value state into the bindings. Taps and answers come back as events.
That is the whole idea.
The terminal renders. The app decides. Nothing in between gets compiled.
Change the layout, and you send a different config. Change what the number means, and you send a different number. There is no firmware project per application, because there is no application on the terminal.
The traffic after the one-time config is tiny, which is what makes a Bluetooth link a sane place to put a live dashboard. And because the terminal is application-agnostic, the same physical screen on the desk can be a kitchen timer in the morning and a meeting-room panel in the afternoon.
What Is Around It
HMIKit, the Swift SDK. Describe the screen once, hand it over, then set values. It talks to a real terminal over Bluetooth or to the Mac simulator over TCP, with the same code. It is an ObservableObject, so a SwiftUI view watches the link directly.
The simulator. The renderer compiles for macOS: the same LVGL, the same fonts, the same pixels. Not an approximation of the screen, the screen. Render a PNG before you flash anything. Compiled to WebAssembly it also runs in a browser tab, where zero of 384,000 pixels differ from the native build.
The browser editor. Build a layout on glass.glue.blue, watch it render in that pixel-identical preview, export it as JSON, Swift or JavaScript, and share it as a URL. No account, no backend. The whole site runs in the browser.
Glass Bridge, a menu bar app for macOS and Windows that owns the Bluetooth link and serves it on the loopback. It speaks the simulator’s exact wire, so a script written against the simulator drives real hardware by changing nothing. Any JavaScript in any browser tab can now put pixels on a physical screen.
Claude Buddy, which is where this stops being a demo. When a coding agent asks permission to run a command or edit a file, the question appears on the glass on your desk, with Allow and Deny as real buttons you press with a finger. No answer within 150 seconds and it falls back to the terminal, quietly.
A decision that leaves the keyboard and becomes something you press with a finger.
The Part That Keeps It Honest
There is one machine-readable spec: JSON schemas, a compatibility file per firmware version, 17 interface vectors and 32 encoding vectors, each with its bytes, its hash and a rendered picture.
Three separate encoders exist, in C, Swift and TypeScript. All three are tested against those same bytes. A new primitive is not finished until the schema, the vectors, the firmware and every SDK agree. That is what stops a hardware platform from turning into four subtly incompatible ones.
Consent lives on the glass.
The first time an unknown app says hello, the screen asks, and someone with a finger decides. The token belongs to the app, never to the bridge, never to the site. Bridges pass it through untouched.
Wi-Fi does one job: over-the-air updates through Foundry. A panic or a watchdog leaves a core dump, and the next check-in reports the reset reason, the last breadcrumb, the free heap and a backtrace, because there is no serial console to watch and a screen that restarts at random needs to say why.
Who This Is For
Anyone who was about to start a firmware project for a screen. You probably do not need one. You need a layout and a stream of values.
Machine builders and workshops. One terminal, one shared firmware, an interface that changes when the process changes rather than when the release cycle allows it. A layout drawn for the wrong panel size is refused with a clear message on the screen, not rendered as a mangled mess.
iOS and Mac developers. The SDK is a Swift package. A dashboard for your app on a real screen is an afternoon, and you can render it in the simulator before any hardware arrives.
Web developers. Install the bridge, point a WebSocket at the loopback, and drive physical hardware from a browser tab with no user gesture and no chooser dialog.
What It Already Runs
Roadbook ‘71 puts the next junction diagram, the distance and the instruction on a terminal stuck to a dashboard, computed entirely on the phone and sent as values once a second. A Mac host mirrors what is playing, album art and all. The site’s own demo pages run a booking calendar, a weather panel with city search, a lights controller and a kitchen timer, each a real small web app whose state mirrors to the glass.
Get Started
Go to glass.glue.blue. Build a layout in the editor and watch it render in a preview that is the firmware. Open the demos and drive them in the browser. If there is a board on your desk, link it with Web Bluetooth from the same page.
The screen with three buttons on it does not need to be a project any more.
Glass is built by glue.blue - we stick solutions to problems. Permanently.
→ Open the editor → Contact Us
Posted in: Hardware, Embedded, Bluetooth, HMI