Self-Hosted Digital Twin Frameworks: Eclipse Ditto vs FIWARE vs ThingsBoard IoT (2026)

Digital twin technology creates virtual replicas of physical assets, enabling real-time monitoring, simulation, and predictive maintenance. While cloud providers offer managed digital twin services, self-hosted open-source frameworks give you full data ownership and avoid vendor lock-in. This guide compares the leading self-hosted digital twin platforms.

What Is a Digital Twin?

A digital twin is a virtual representation of a physical object, system, or process that mirrors its real-world counterpart in real-time. Unlike simple IoT dashboards, digital twins maintain persistent state, support bidirectional communication, and enable simulation and what-if analysis.

Key capabilities of a digital twin platform:

• Device shadow — persistent state representation even when devices are offline
• Bidirectional sync — changes in the physical world update the twin, and commands to the twin propagate to the device
• Event streaming — real-time telemetry ingestion and distribution
• Policy management — access control and permissions at the device/twin level
• Search and query — find twins by attributes, state, or metadata
• API-first design — REST, WebSocket, and MQTT interfaces for integration

Eclipse Ditto

Eclipse Ditto is an open-source digital twin framework from the Eclipse IoT project. It provides a lightweight, cloud-native platform for managing digital twins with a focus on simplicity and scalability.

Key Features

• Thing model — each “Thing” represents a digital twin with features, properties, and metadata
• Protocol adapters — native support for HTTP, WebSocket, MQTT, and AMQP
• Policy-based access control — fine-grained permissions per twin
• Search API — RQL-based query language for finding twins
• Connection management — integrate with external systems (Kafka, RabbitMQ, Hono)
• Kubernetes-native — designed for containerized deployment

Docker Compose Deployment

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

version: '3.8'

services:
  ditto-gateway:
    image: eclipse/ditto-gateway:latest
    ports:
      - "8080:8080"
      - "443:443"
    environment:
      - DOGSTATSD_HOST=ditto-dogstatsd
    depends_on:
      - ditto-things
      - ditto-policies
    networks:
      - ditto-net

  ditto-things:
    image: eclipse/ditto-things:latest
    environment:
      - AKKA_CLUSTER_SEED_NODES=akka://ditto-cluster@ditto-things:2552
    networks:
      - ditto-net

  ditto-policies:
    image: eclipse/ditto-policies:latest
    networks:
      - ditto-net

  mongodb:
    image: mongo:6
    volumes:
      - mongodb_data:/data/db
    networks:
      - ditto-net

networks:
  ditto-net:
    driver: bridge

volumes:
  mongodb_data:

Pros and Cons

FIWARE Context Broker (Orion)

FIWARE is a European open-source platform for smart solutions. Its core component, the Orion Context Broker, manages the lifecycle of context information — essentially functioning as a digital twin registry and synchronization engine.

Key Features

• NGSI-LD and NGSI-v2 APIs — standardized context data management
• Subscription system — push notifications on state changes
• Temporal data — store and query historical context
• IoT Agent integration — connect to MQTT, LoRaWAN, and other IoT protocols
• Multi-tenant — support for multiple organizations
• Geospatial queries — location-aware context management

Docker Compose Deployment

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

version: '3.8'

services:
  orion:
    image: fiware/orion:latest
    ports:
      - "1026:1026"
    command: -dbhost mongodb
    depends_on:
      - mongodb
    networks:
      - fiware-net

  mongodb:
    image: mongo:6
    volumes:
      - mongo_data:/data/db
    networks:
      - fiware-net

  iot-agent:
    image: fiware/iotagent-ul:latest
    ports:
      - "4041:4041"
      - "7896:7896"
    environment:
      - IOTA_CB_HOST=orion
      - IOTA_CB_PORT=1026
      - IOTA_MQTT_HOST=mosquitto
      - IOTA_MQTT_PORT=1883
    depends_on:
      - orion
      - mosquitto
    networks:
      - fiware-net

  mosquitto:
    image: eclipse-mosquitto:latest
    ports:
      - "1883:1883"
    volumes:
      - ./mosquitto.conf:/mosquitto/config/mosquitto.conf
    networks:
      - fiware-net

networks:
  fiware-net:
    driver: bridge

volumes:
  mongo_data:

Pros and Cons

ThingsBoard IoT Platform

ThingsBoard is primarily an IoT platform but includes robust digital twin capabilities through its device shadow and asset management features. It provides a complete end-to-end solution from device connectivity to visualization.

Key Features

• Device profiles — define digital twin schemas with telemetry, attributes, and RPC
• Rule engine — process telemetry with drag-and-drop rule chains
• Device shadow — persistent state with offline queuing
• Asset hierarchy — organize twins into parent-child relationships
• Dashboards — built-in visualization widgets
• Multi-tenant — white-label support for service providers

Docker Compose Deployment

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

version: '3.8'

services:
  mytb:
    image: thingsboard/tb:latest
    ports:
      - "8080:9090"
      - "1883:1883"
      - "5683:5683/udp"
      - "5684:5684/udp"
    environment:
      - TB_QUEUE_TYPE=in-memory
      - SPRING_DATASOURCE_URL=jdbc:postgresql://postgres:5432/thingsboard
    volumes:
      - tb_data:/data
      - tb_logs:/var/log/thingsboard
    depends_on:
      - postgres
    networks:
      - tb-net

  postgres:
    image: postgres:15
    environment:
      - POSTGRES_DB=thingsboard
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
    volumes:
      - pg_data:/var/lib/postgresql/data
    networks:
      - tb-net

networks:
  tb-net:
    driver: bridge

volumes:
  tb_data:
  tb_logs:
  pg_data:

Pros and Cons

Comparison Table

Why Self-Host Your Digital Twin Platform?

Running a digital twin platform on your own infrastructure offers several advantages over cloud-managed alternatives:

Data sovereignty: Industrial IoT data often contains sensitive operational information. Self-hosting keeps telemetry, device states, and simulation results within your network, avoiding cross-border data transfer regulations.

Latency control: Digital twins require real-time synchronization with physical assets. Self-hosted deployment on edge infrastructure eliminates the round-trip latency of cloud APIs, which is critical for time-sensitive industrial control scenarios.

Cost predictability: Cloud digital twin services (Azure Digital Twins, AWS IoT TwinMaker) charge per operation and per twin. At scale with thousands of devices sending telemetry every second, self-hosted open-source alternatives offer significantly lower total cost of ownership.

Custom integration: Open-source frameworks like Eclipse Ditto and FIWARE can be modified to support proprietary protocols, custom data models, and internal authentication systems that cloud services cannot accommodate.

For related reading, see our ThingsBoard vs IoTSharp comparison for a broader IoT platform comparison, and our IoT platform deployment guide for infrastructure setup details.

FAQ

What is the difference between a digital twin and an IoT platform?

A digital twin is specifically a virtual representation of a physical asset with persistent state and bidirectional sync. An IoT platform is a broader system that includes device connectivity, data ingestion, visualization, and often digital twin capabilities as one component. ThingsBoard is an IoT platform with digital twin features, while Eclipse Ditto is a pure digital twin framework.

Can I run Eclipse Ditto without Kubernetes?

Yes. Eclipse Ditto can run with Docker Compose for development and small-scale deployments. However, production deployments typically use Kubernetes for horizontal scaling, high availability, and rolling updates. The official Helm charts simplify Kubernetes deployment.

Which digital twin framework supports the most protocols?

ThingsBoard supports the widest range of IoT protocols natively (MQTT, CoAP, HTTP, LwM2M). Eclipse Ditto supports HTTP, WebSocket, MQTT, and AMQP through its gateway. FIWARE relies on IoT Agents to bridge between specific protocols and the NGSI context broker.

Is FIWARE suitable for industrial IoT?

FIWARE is primarily designed for smart city and environmental applications, but its NGSI-LD standard and IoT Agent ecosystem can be adapted for industrial use. For pure industrial IoT, Eclipse Ditto or ThingsBoard may be better choices due to their device shadow and rule engine capabilities.

How much RAM does a self-hosted digital twin platform need?

Eclipse Ditto requires at least 4 GB RAM for the full stack (gateway + things + policies + MongoDB). FIWARE Orion needs ~2 GB RAM plus MongoDB. ThingsBoard requires 8+ GB RAM for production due to its rule engine and dashboard components.

Can digital twins work offline?

Yes. Digital twin frameworks maintain device shadows — persistent state representations that survive device disconnections. When a device reconnects, the twin syncs its state. Eclipse Ditto and ThingsBoard both support this pattern with message queuing for offline commands.