LandscapeTested on hardware
ELECROW 5 inch touch display
5 inch, 1024 x 600
- ·IPS, 178° viewing angle
- ·5-point capacitive touch
- ·HDMI video, USB touch
Calxis
The GUI framework for embedded every product.
01
Build it the easy way.
Design your interface with HTML, CSS and JavaScript, the tools your team already knows. No new toolkit, no retraining, no hiring for a niche skillset.
ui.htmlui.cssui.js
1<div class="gauge">
2 <span id="temp">21.4</span> °C
3</div>
4<button class="primary">Start</button>
5
6.primary { background: #a349a4; }
7
8sensor.on('temp', v =>
9 temp.textContent = v.toFixed(1));
02
No dependencies. None.
Calxis is one self-contained library. No Chromium to ship, no Node, no system webview to match versions against, no package tree to audit. You ship your application and Calxis, and nothing else.
What you ship
Chromium
Node
System webview
Package tree
1
Your application
+
2
Calxis
✓ Nothing else
03
It fits anything that needs a GUI.
- desktop application
- VST plugin
- phone app
- kiosk
- EV charger
- vending machine
- factory control panel
- synthesiser
- bench instrument
- thermostat
- door intercom
- toy
Show information on a static display, or build something richly interactive. Touch is optional: drive it with a mouse, or with the knobs and encoders on your own front panel.
Touch
Mouse
Knobs and encoders
Displays
Screens of any size and orientation.
Calxis layouts adapt to any resolution, aspect ratio and rotation. Landscape, portrait, round and bar displays all run from one project.
5 inch, 1024 x 600
ELECROW 5 inch touch display
7 inch, 600 x 1024
7 inch portrait panel
2.1 inch, 480 x 480
2.1 inch round display
8.8 inch, 1920 x 480
8.8 inch bar display
10.1 inch, 1280 x 800
10.1 inch panel
Displays
Pick the screen your product needs.
Tested with the 5 inch display below. The others show the range of panels and interfaces Calxis is built to drive.
PortraitSupported
7 inch portrait panel
7 inch, 600 x 1024
- ·IPS, capacitive touch
- ·MIPI DSI or HDMI
- ·Rotated in software, no extra hardware
RoundSupported
2.1 inch round display
2.1 inch, 480 x 480
- ·Round IPS panel
- ·MIPI DSI or RGB
- ·Dials, knobs and wearables
BarSupported
8.8 inch bar display
8.8 inch, 1920 x 480
- ·Stretched IPS bar
- ·HDMI or MIPI DSI
- ·Instrument clusters and control strips
LandscapeSupported
10.1 inch panel
10.1 inch, 1280 x 800
- ·IPS, capacitive touch
- ·LVDS or HDMI
- ·Control panels and HMIs
LandscapePortraitRoundBar
Your display. Your board.
One cable.
Power on.
Calxis Linux
04
It's fast and light.
Nothing to spin up, no engine to warm. On a modest arm64 embedded Linux board, Calxis is on-screen and interactive in under two seconds from power-on. On desktop or mobile, it's blazingly fast to start.
Custom Linux image per boardNo desktop, straight to your UI
05
Fast with a GPU. Fast without one.
Calxis renders through WebGPU, the modern graphics standard that runs on every platform, sitting on Direct3D, Vulkan and Metal underneath. Where there's no GPU, or no driver worth trusting, you can use Calxis's own software renderer instead.
Same application, same behaviour, no application code to change. You are fast on both paths.
Your application
Calxis
WebGPU
Direct3D
Vulkan
Metal
GPU
Software renderer
No GPU needed
CPU
Rendering on the GPU: same pixels
06 · Runs everywhere
The only way to get both.
Web-style convenience and a genuinely native application, on Windows, macOS, Linux, iOS and Android. One library, one codebase. Nobody else offers that.
Embedded LinuxTested on hardware
KICKPI K2B
Allwinner H618
- ·4x Cortex-A53 at 1.5 GHz
- ·Mali-G31 MP2 GPU
- ·2 GB RAM, 16 GB eMMC
- ·Custom Calxis Linux image
Embedded LinuxTested on hardware
Raspberry Pi 5
Broadcom BCM2712
- ·4x Cortex-A76 at 2.4 GHz
- ·VideoCore VII GPU
- ·Custom Calxis Linux image
Embedded LinuxTested on hardware
STM32MP257F DevKit
ST STM32MP257F
- ·2x Cortex-A35 at 1.5 GHz
- ·Cortex-M33 co-processor
- ·Custom Calxis Linux image
MobileSupported
Android
Phones and tablets
- ·Native app build
- ·Touch and gestures
MobileSupported
iOS
iPhone and iPad
- ·Native app build
- ·Touch and gestures
DesktopSupported
Windows
x86-64 and Arm64
- ·Desktop app
- ·Mouse, keyboard and touch
DesktopSupported
macOS
Apple silicon and Intel
- ·Desktop app
- ·Mouse, keyboard and trackpad
DesktopSupported
Linux
x86-64 and Arm64
- ·Desktop app
- ·Also handy as a desktop simulator for embedded targets
Embedded LinuxMobileDesktop
07
Your interface talks straight to your code.
No sandbox to message across, no browser process to round-trip through. Calxis compiles into your binary, so your JavaScript reaches your native code directly.
Web view or browser engine
JavaScriptSandboxBrowser processNative
Message, serialise, round trip
Calxis, compiled into your binary
JavaScriptYour native code
Direct call
08
Firewalled by you.
Every resource Calxis touches is one you handed it, through a single documented interface that you own. Any socket, thread, file or device is allowed or denied by you.
Calxis does not open a connection, spawn a process, or reach anything you didn't give it. You are the firewall, and there is no way around you.
your host interfacepolicy: yours
Calxis→open socket 10.0.0.12:443ALLOWED
Calxis→read file /data/settings.jsonALLOWED
Calxis→spawn process /bin/shDENIED
Calxis→open device /dev/ttyS1ALLOWED
Calxis→connect telemetry.example.comDENIED
Calxis→start worker threadALLOWED
09
And it won't take your application down.
No exceptions thrown, no runaway recursion, no hidden failure modes. Disciplined native code that behaves the same on the bench as it does in the field, and clean enough that the exact same engine compiles to WebAssembly without compromise.
On the bench0 exceptions
In the field0 exceptions
Same engine
✓ Native arm64✓ Native x86-64✓ WebAssembly
Agentic deployment
Describe the change. Watch it ship.
Calxis projects ship with context files and skills for coding agents. Your agent edits the UI, builds for the target and deploys to the device over USB or the network.
agent session
$ agent "Add a fan speed control to the home screen"
› Reading Calxis project (12 screens, 48 widgets)
› Editing ui/home.cx
› Building for Calxis (Allwinner H618) ... done in 3.2 s
› Deploying to calxis-k2b.local over USB
› Device restarted. UI live in 0.8 s
✓ Fan speed control added to home screen
Deployed v1.4.2
MCP server on the hardware
Your agent can see and touch the device.
Every Calxis build can run a Model Context Protocol server on the device. Agents take screenshots, tap the screen, read logs and check frame times, so they test their own changes on real hardware.
mcp://calxis-k2b.local
Agent tool calls
calxis.list_screens()
→ home, run, settings, logs
calxis.tap(x: 512, y: 530)
→ Pressed "Start"
calxis.screenshot()
→ 1024 x 600 PNG captured
calxis.read_logs(level: "warn")
→ 0 warnings
calxis.get_frame_time()
→ 16.4 ms average (60 fps)
✓ Test passed: Start opens the run screen
Why not just build it yourself?
Fair question. Today, an agent can write code for almost anything. What it cannot do is hand you an architecture. Calxis's was hard won, by people who specialize in exactly this problem: cross-platform native rendering, layout, scripting, and keeping all of it from ever crashing the host it's embedded in. Every edge case already found, every wrong turn already made and backed out of, is sunk cost you don't have to pay again.
Rebuilding that maturity from scratch, even with the best team possible (human or agentic), would be a considerable undertaking, taking time and tokens not worth counting, and that's just the architecture, not the ongoing multiplatform test regime.
Licensing Calxis is simply cheaper than reinventing it.
Want early access?
We haven't launched yet. If you'd like to try Calxis on your product, get in touch.