Easily build and manage.
Fabrix is a runtime that allows you to manage meshes of ESP32 devices. Add functionality by dropping in apps that bring their own UI, and drive the hardware you want — all from one browser tab. No USB cable. No reflash.
The idea
The idea came to me when I was just starting to build my own devices. After attempting to build and reverse-engineer a few, I realized I was missing a solid base to work from — and when I looked for one, there was none. So I started building a firmware with all the features needed to speed up developing new devices, and to actually deploy and manage them efficiently.
One binary does one job. Changing anything means recompiling, reflashing over a cable, and rebooting every board by hand. A fleet is a chore.
- — reflash per change
- — one job per device
- — USB cable required
The board runs a small runtime instead of your logic. Capabilities are apps you drop in, update, and remove live — over Wi-Fi, across the whole mesh, from a browser tab.
- + hot-swap apps
- + many jobs, one board
- + no cable after flash
The firmware has its trade-offs: staying ready to hot-swap apps means carrying a lot of pre-compiled, unused code, and functions that reserve RAM by default even when they're never called.
Firmware that behaves like software.
Monolithic firmware means a full reflash for every change. Fabrix treats each capability as an app you can deploy, update, and remove live — across a whole fleet of devices at once.
Hot-swap apps
Push a new app to one device or the whole mesh without a cable or a reboot. Rollback is a click — the old version is still in flash.
Control motors, light, sensors and much more
Connect your devices to the board I/O and control them easily. Build and manage what you want.
Apps bring their own UI
Each app injects its own window into the shared web desktop — sliders, scopes, pads. No separate dashboard to build or maintain.
One tab, whole mesh
Discover, name, and manage every ESP32 from a single page. A leader and three subleaders keep config in sync, so the fleet survives reboots and lost nodes.
High availability built in
Integrated high availability to ensure the system configuration and functionality persist.
Open and scriptable
Build your own apps, add API endpoints, and wire up the integrations you need.
Debug remotely
Monitor and control many boards from anywhere — check what's happening with no physical connection required.
Mesh over any connection
The built-in mesh defaults to Wi-Fi so the load is offloaded to the antennas — but any board can also act as a LoRa, Zigbee, or Wi-Fi bridge for another, extending the mesh's range.
A graph wired to all nodes.
When data needs to reach another board, the network reroutes it to wherever you choose. It works much like the internet: each node forwards data to the next hop until it reaches its destination — across many connection types.
Got a board closer to a Zigbee hub? No problem — data can hop to an app on a distant node just as easily.
A self-healing mesh, not a hub.
Every device links to the nearest available peers over Wi-Fi, hopping through the mesh to reach the rest. A single leader coordinates; three subleaders hold persisted configuration so the fleet survives a reboot or a leader going dark. Leaders, subleaders and nodes alike download apps and drive hardware.
Drop-in apps, each with its own window.
Install from the registry or write your own. Every app declares its inputs, outputs, and the UI it injects into the desktop.
Samsung MDC Control
HUE Bridge
ArtNet
HUE Light
GPIO -> USB HID
Up and running in a few minutes.
Flash a base image once. After that, everything is a hot-swap over Wi-Fi from your browser.
Flash the base image
One-time bootstrap over USB. From then on the device joins your network and never needs a cable again.
Open the web desktop
Browse to node-manager.local. Every device on the mesh shows up automatically.
Install an app & wire it up
Build or pick an app from the registry, drop it into the node, and connect sources to outputs. It deploys live.