OpenRemote

OpenRemote is a fully open‑source, self‑hosted Internet of Things (IoT) platform that unifies device management, data ingestion, rule execution, and visualization into a single stack. At its core it exposes a multi‑tenant REST/MQTT/WebSocket API that allows any device or application to register, authenticate, and publish telemetry. The platform then translates those events into programmable when‑then rules written in JavaScript or Groovy, enabling real‑time automation and alerting. The web console, built with reusable UI components, gives operators a drag‑and‑drop rule designer and a low‑code dashboard builder for data exploration.

• Back‑end: A Java/Spring Boot microservice that implements the core Manager API. It runs on a JVM (OpenJDK 17) and is packaged as an executable JAR. The service orchestrates authentication (JWT/OIDC), tenant isolation, and rule evaluation.
• Messaging: An embedded MQTT broker (Eclipse Mosquitto) handles device telemetry, while a lightweight HTTP REST gateway forwards requests to the manager. WebSocket endpoints are exposed for real‑time UI updates.
• Persistence: PostgreSQL stores all metadata (assets, rules, users) and event logs. A separate timeseries store (InfluxDB or PostgreSQL Timescale extension) is optional for high‑volume telemetry.
• Front‑end: A single‑page application written in TypeScript/React, leveraging custom Web Components for widgets. The UI consumes the Manager API via HTTPS and WebSocket.
• Containerization: Docker images are published for both amd64 and arm64, with a single docker‑compose.yml that spins up the broker, database, and manager services. Kubernetes manifests are also available for production deployments.

• Device Provisioning: Auto‑registration via X.509 certificates or symmetric keys, with per‑device credential rotation.
• Asset Modeling: Define custom asset types (e.g., sensors, actuators) with hierarchical properties and telemetry streams.
• Rule Engine: Compile-time validation of JavaScript/Groovy scripts, with a rich API (Device, Asset, Event) for manipulating state and invoking actions.
• Data Analytics: Query historical telemetry using SQL‑like syntax; export CSV/JSON for external processing.
• Webhooks & Callbacks: Trigger HTTP callbacks on rule events, enabling integration with third‑party services.
• Edge Gateway: A lightweight Java agent that can run on the device itself, providing local rule execution and buffering during connectivity loss.

The platform is designed for container‑first deployment. A single docker compose file pulls three images (manager, broker, database) and exposes HTTPS on port 8443 by default. For production, the images can be deployed to a Kubernetes cluster; Helm charts are available for automated provisioning of persistent volumes, secrets, and ingress. The architecture scales horizontally by adding more manager instances behind a load balancer; the MQTT broker can also be clustered for high availability.

• Plugin System: Developers can extend the rule engine with custom Java libraries or Node modules, packaged as JARs or NPM packages and injected into the container.
• API Hooks: The Manager API supports OAuth2 scopes, allowing fine‑grained access control for third‑party applications.
• Custom UI Components: The front‑end exposes a widget library; developers can create new widgets in React or vanilla JS and register them via the UI.
• Edge APIs: The edge gateway exposes a local HTTP API that can be polled by device firmware, enabling offline rule execution.

The project follows a conventional Maven build pipeline with automated CI/CD on GitHub Actions, providing frequent releases and a clear changelog. Documentation is hosted at docs.openremote.io, featuring API references, tutorials, and a comprehensive FAQ. The community is active on GitHub Issues and the dedicated forum, offering rapid support for integration questions. Configuration is largely environment‑driven (e.g., OR_HOSTNAME, database URLs), making it straightforward to adjust for different deployment contexts.

• Smart City Infrastructure: Deploy a city‑wide sensor network where each municipality runs its own realm, complete with autonomous firmware updates and real‑time dashboards.
• Industrial Automation: Integrate legacy PLCs via MQTT bridges, trigger alerts on threshold breaches, and log events to a central PostgreSQL warehouse.
• Consumer IoT Platforms: Manufacturers can offer customers an on‑premises portal that manages devices, runs custom rules, and exposes APIs for mobile apps.
• Edge‑First Applications: Run the edge gateway on a Raspberry Pi to provide local rule execution for remote sites with intermittent connectivity.

• Full Open Source: No vendor lock‑in; the entire stack is released under permissive licenses, allowing internal modifications.
• Performance & Flexibility: Java/Spring Boot delivers low latency rule evaluation, while the embedded MQTT broker ensures high throughput.
• Multi‑Tenancy: Built‑in realm isolation lets a single deployment serve multiple customers or departments without code changes.
• Rapid Development: The drag‑and‑drop rule designer and widget library reduce the need for custom UI code, accelerating time‑to‑value.
• Extensibility: With a plugin architecture and exposed APIs,