Orbit OS turns embedded Linux devices into a programmable ecosystem. Expose hardware, networking, and system services as secure, unified APIs — locally and remotely — with built-in security, real-time control, and full application lifecycle management.
The Problem
GPIO handling. Networking. Remote access. OTA updates. Application lifecycle. APIs.
Teams repeatedly rebuild the same platform layer instead of focusing on their product.
Orbit OS removes that burden.
It provides a complete runtime platform — from low-level device control to secure connectivity, centralized application management, controlled resource access, and seamless OTA updates for both system and applications.
Instead of stitching infrastructure together, teams focus on what actually matters: building the logic that differentiates their product.
What it does
Access and control your device from any language, locally or remotely.
Device capabilities are exposed as unified APIs — locally or remotely. GPIO, PWM, I²C, SPI, UART, WiFi, Ethernet and Bluetooth behave consistently across all devices.
Every connection is encrypted and authenticated. Orbit OS verifies every caller before granting access — no open ports, no implicit trust. Built for secure industrial deployments.
Applications run in isolated environments and communicate through defined interfaces. Faulty apps are automatically restarted by the runtime to maintain system stability.
Safe, atomic updates with full or delta downloads, instant rollback, and zero-downtime upgrades. Update devices in the field without risk of bricking.
Build applications in Go, Python, Java, or C++. Applications are packaged into a unified .orb format
for consistent deployment across all Orbit OS devices.
Develop against real hardware without deploying first. Run applications from your laptop while interacting with device peripherals in real time using the same SDK and APIs.
Optimized for embedded and edge systems. Lightweight runtime services enable modern application patterns on resource-constrained devices.
Architecture
Gravity RT is the core execution layer of Orbit OS. It orchestrates applications, hardware access, and system services within a unified runtime environment. Every interaction with the device passes through a controlled API layer with strict authentication and policy enforcement.
Application/OTA Distribution
Deploy and manage applications across your devices from a central store.
Every package is verified, signed, and delivered in the unified .orb format.
The store also handles automatic updates and OTA system upgrades.
Applications are installed from a centralized store with encrypted delivery and trusted execution on all devices.
Apps are packaged in .orb format and cryptographically verified before installation or update.
Installations and updates are transactional — they either complete fully or roll back automatically to a safe state.
The store manages full application and system lifecycle — including automatic updates, version control, and OTA system upgrades across your entire device fleet.
Developer Experience
Connect from any machine. Control hardware. In any language.
// Connect — UDS on-device or TCP remotely, same API
device, _ := sdk.NewClientAuto(DEVICE_IP_ADDRESS)
defer device.Close()
// GPIO — set direction and drive a pin high
led := sdk.GpioPin{Number: 18, ChipNumber: 0}
device.GpioManager.SetDirection(led, true) // OUTPUT
device.GpioManager.SetLevel(led, true) // HIGH
// PWM — 1 kHz signal at 50% duty cycle
pwmPins, _ := device.GpioManager.ListPwmPins()
device.GpioManager.SetPwm(pwmPins[0], 0.5, 1000.0)
// UART — open ttyAMA0 at 115200 baud and send a command
device.UartManager.Open(sdk.UartConfig{Port: "/dev/ttyAMA0", Baudrate: 115200})
device.UartManager.Write("/dev/ttyAMA0", []byte("AT\r\n"))
// I²C — scan bus and read a sensor register
addrs, _ := device.I2CManager.ScanBus(1)
data, _ := device.I2CManager.WriteRead(1, addrs[0], []byte{0x00}, 2)
Have a question, partnership idea, or technical use case? Send us a message.