NEW The first open-source simulator for HTTP, MQTT & LoRaWAN (Semtech UDP + Basics Station), with a built-in device marketplace, is here — 100% free. Download & try it →
MapexOS MapexOS
Connect · Automate · Scale

Raw telemetry in.
Automated action out.

IoT-first, but not limited to IoT. MapexOS ingests any device over any protocol, normalizes it into a single Asset model, and drives it through rules and a workflow engine — turning a stream of bytes into business outcomes in milliseconds.

Run the platform Documentation
10
backend services
3
ingest protocols
1
docker compose up
∞
plugins & assets
HTTPMQTTLoRaWAN Workflow enginePlugin UIMulti-tenant RBACSelf-hostedamd64 · arm64 · Raspberry Pi
Why MapexOS

A complete IoT operation needs many capabilities

Ingestion, authentication, payload validation, business rules, automation, dashboards, multi-org governance — each is its own discipline. The open-source ecosystem has excellent tools for every one of them. MapexOS brings those capabilities together into a single, integrated platform.

The capabilities you assemble
IngestionAuthenticationPayload validationRules engine AutomationDashboardsMessage busIdentity & RBAC
  • Each capability is a separate system to run and secure
  • Integrations between them are yours to build and maintain
  • Business rules and identity end up living in several places
  • Multi-organization structure is modeled per project

Great tools, each strong at its slice — and a lot of surface area to operate together.

→
MapexOS

MapexOS

Acquisition · validation · processing · business rules · asset organization · observability · integration — the same capabilities, designed end to end as one platform.

HTTPLoRaWANMQTT ingestion ready out of the box
  • One architecture — every capability runs on the same core
  • Uniform scalability across the whole platform
  • No data duplication, no integrations to build or maintain
  • Multi-organization built in from the base
One integrated platform
See MapexOS in action

The platform, working

Real screens from MapexOS — design automations on a visual canvas, onboard assets from a template, watch presence and health, and govern the whole pipeline. Dark and light themes ship built-in.

Goto — virtual links

Reference a step by name instead of dragging a wire across the canvas. Fewer crossings, and a DAG that stays readable as it grows.

Native presence

Online, offline and last-seen for every asset — the platform knows the moment one goes quiet, with no heartbeat plumbing to build.

Dark & light

Your workspace, your theme — every screen ships in both dark and light, switchable anytime.

The platform

Everything between the device and the decision

Ten backend services and a Vue 3 frontend, self-hostable with one command and published multi-arch — the full path from a raw payload to an automated outcome.

Telemetry ingestion

Authenticated HTTP and MQTT. Every CONNECT/PUBLISH decision is made locally off a three-tier cache — no round-trips on the hot path.

Generic data conversion

Per-asset preprocess → validate → convert pipelines in JavaScript, executed in V8 isolates. Normalize any payload — no source changes.

Dynamic event routing

Match rules over event fields — payload.temp > 30, equals, ranges, set membership. Rules live in MongoDB and take effect at runtime, no redeploy.

Workflow engine

A durable DAG runtime — deterministic execution, retries, timers, sub-workflows, and state that survives restarts through NATS-KV checkpointing.

Plugin UI (n8n-style)

Custom workflow nodes ship as plugins from a manifest registry — new connectors land in the editor without rebuilding the frontend.

Multi-tenant & RBAC

Organization hierarchy with per-org isolation, shared templates and fine-grained permissions, evaluated centrally by mapex-iam.

The model

An Asset is anything that generates data

Not just a device. A sensor, a machine, a piece of equipment, an area, a zone, a sector — any asset that produces data or needs monitoring. Asset Templates turn each new integration from a brand-new project into a reusable configuration, shared across branches, sites and entire clients.

  • Asset Templates — integrate once, reuse everywhere. Without a template, each integration is a new project; with one, it's just configuration.
  • Multi-organization from the base — not a patch bolted on later, an architectural decision.
  • Shared templates propagate to descendant orgs; RBAC and groups are evaluated centrally.
Enterprise hierarchy — multi-tenant by design
Headquarters
 └─ Branch
     └─ Site
         └─ Sector
             └─ Zone
                 └─ Asset  ◀ sensor · machine · area
Own workflow engine — not a dependency

An integrated, n8n-inspired workflow engine processes events and applies business rules inside the platform — and is built to orchestrate AI agents inside those flows next.

Open source

The MapexOS ecosystem

One platform, many open repositories. The deploy repo runs the whole stack; the others are the services, the broker, the LoRaWAN network server, the SDKs and the tools around it.

mapexOSDeploy

↗

Docker Compose distribution that pulls pre-built multi-arch images. Start here to run the platform.

Distribution · start here

mapexOS

↗

Source for the ten backend services and the Vue 3 frontend — ingestion, conversion, routing, workflow engine and IAM.

Core · Go + Vue 3

mapexMQTTBroker

↗

Eclipse Mosquitto v2 plus an in-house Go plugin handling auth, ACL, presence and ingress in a single .so.

MQTT edge · Go

mapexLNS

↗

LoRaWAN Network Server — an overlay on The Things Stack (GS · NS · JS) wrapped in the MapexOS hexagonal architecture.

LoRaWAN · Go

mapexDevicesSimulator

↗

Desktop app (Electron + Go) that behaves like real devices on the wire over HTTP, MQTT and LoRaWAN.

Tooling · Electron + Go

mapexGoKit

↗

Shared Go SDK — HTTP middleware, NATS, Mongo/ClickHouse/MinIO/Redis clients, JWT, JS sandboxing and cross-service contracts.

SDK · Go
Tooling

Mapex Devices Simulator

Simulate real IoT devices — with no hardware to buy — and drive live traffic into MapexOS or any platform that speaks HTTP, MQTT or LoRaWAN. A desktop app (Electron around a Go sidecar) that behaves like real devices on the wire.

  • Four transports — HTTP, MQTT (pub + sub), and LoRaWAN over Semtech UDP or Basics Station with real OTAA/ABP crypto.
  • Live sessions — persistent broker/LNS connections with auto-reconnect; fire events on demand or on a schedule.
  • Console & logs — a live WebSocket stream of every uplink, downlink and frame, plus a filterable history.
  • One desktop binary — Electron app spawns the Go engine; nothing external to run.
Open on GitHub Browse the catalog API
Speaks on the wire
HTTP · send
MQTT · pub + sub
LoRaWAN · Semtech UDP
LoRaWAN · Basics Station
Point it anywhere

Built for MapexOS, but vendor-neutral: The Things Stack, ChirpStack, a cloud IoT endpoint, or your own broker — it just works.

Download the simulator

A platform that doesn't just deliver connectivity. It delivers —

StructureOrganizationPermissionsTemplates WorkflowBusiness rulesObservabilityScalability

— and above all, freedom to build real IoT solutions.

Built on Go · NATS · JetStream · V8 isolates · Prometheus · Grafana
Run it

The whole stack, one command

Clone the deploy repo and boot the full platform — Mongo replica-set, NATS, MinIO, ClickHouse and every service — on Linux, Apple Silicon, Windows + Docker Desktop or a Raspberry Pi.

# clone the runnable distribution
git clone https://github.com/Mapex-Solutions/mapexOSDeploy.git
cd mapexOSDeploy
docker compose up -d
# ~2 min later → frontend at http://localhost
✓ login: admin@mapex.local / mapex@123
Get mapexOSDeploy Read the docs