The real-time platform for edge & industrial systems
ByteHive is a blazing-fast software platform written in pure C. A sub-millisecond variable bus, 45+ modular services, and zero runtime dependencies — flexible, reusable, and expandable from an ARM64 SBC to the cloud.
Trusted foundation for energy storage, industrial gateways, and IoT fleets.
See it running on real hardware
ByteHive CSS Gateway — a turnkey BESS & VPP control product built entirely on the ByteHive platform. Live dashboards, industrial protocols, visual control logic, one-command deploy.
One fast core. Endless applications.
ByteHive gives every device a shared, real-time data fabric — then layers services on top. Build your product on a foundation engineered for speed and longevity.
Blazing fast
Shared-memory variable store with O(1) lookups and sub-millisecond notification. Written in pure C for deterministic, time-critical control.
Zero dependencies
No runtime frameworks, no garbage collector, no surprises. ByteHive runs lean on bare Linux — what ships is what runs, for years.
Modular & reusable
45+ composable services — protocols, control logic, telemetry, auth. Mix only what you need; everything talks over the same bus.
Configurable, no rebuild
Define variables, device maps, and state-machine logic in JSON and scripts. Reconfigure in the field without recompiling firmware.
Edge to cloud
Delta-only variable sync streams edge state upstream; a cloud control plane pushes commands back. One model, both ends.
Runs anywhere
Native x86_64 (WSL2, Linux > 22.04) and ARM64 (Cortex-A76 SBC, TI AM64x Sitara). One SDK bundle per architecture — same API, same modules, no rebuilds.
A layered system around a real-time core
- Central data storeEvery service reads and writes named, typed variables — int, float, double, string — keyed by name and instance ID (0–255).
- Real-time notificationsSubscribe to any variable and receive instant updates over IPC. No polling, no busy-waits — events the moment data changes.
- State-machine engineA deterministic logic runner and scripting layer turn live variables into control actions — peak shaving, BESS dispatch, safety interlocks.
- Open at every layerAdd your own modules in C, expose them over the same bus, and ship — without touching the core.
Batteries included
A growing library of production services you can compose — or extend with your own.
From SDK bundle to running edge
One x86_64 bundle for development on WSL2 and 64-bit Linux. One ARM64 bundle for production edge hardware. Same API, same modules, no rebuilds.
Validated targets
| Target | Architecture |
|---|---|
| WSL2 · Ubuntu > 22.04 | x86_64 |
| Linux > 22.04 (AMD/Intel 64-bit) | x86_64 |
| ARM64 Cortex-A76 SBC | aarch64 |
| TI AM64x Sitara (Cortex-A53) | aarch64 |
SDK bundle
- bins/ — platform daemons, polling servers, CLI utilities
- libs/ — shared libraries, self-locating, no env setup required
- include/ — public headers to build against the platform
- User manual — self-contained HTML with example code
Delivered via secure transfer under confidentiality terms. The Yocto builder repository is provided as source for your chosen processor.
Built for the field
BESS & VPP control
Aggregate inverters and meters, run dispatch logic on-site, and scale to fleet-wide virtual power plants.
Protocol translation
Bridge heterogeneous field devices to modern networks and cloud — one bus, many protocols.
Edge intelligence at scale
Local processing, real-time telemetry, and remote orchestration across distributed device fleets.
Engineered for performance. Designed for longevity.
Sub-millisecond by design
A shared-memory bus and O(1) lookups keep control loops deterministic, even on modest edge hardware.
No runtime to rot
Pure C with no external runtime means fewer moving parts, smaller attack surface, and devices that keep running for a decade.
You own the application layer
ByteHive is the foundation; your product logic and data are yours. Build differentiated applications on top, not lock-in.
Field-proven architecture
Already powering energy-storage gateways and industrial deployments on ARM64 SBCs and edge devices.
See ByteHive running on your hardware
Book a walkthrough of the platform, or tell us about the system you're building. We'll show you how fast a pure-C foundation can be.