OpenDigitalTwin

A lightweight web-based digital twin for robot simulation, OPC UA integration, and industrial automation.

Comment

Inspiration

Small manufacturers and engineering teams often need to verify a machine layout, robot motion, or PLC data connection before committing to physical equipment.

However, creating even a simple digital twin can require specialized tools such as Unity, Unreal Engine, or industrial physics platforms. These tools are powerful, but they can also require significant licensing costs, 3D-engine expertise, dedicated simulation engineers, and long setup times.

We built OpenDigitalTwin to provide a more accessible starting point.

Our goal is not to replace advanced physics simulation or safety-certified robot engineering tools. Instead, OpenDigitalTwin helps small businesses quickly perform early-stage kinematic validation, visualize automation data, and communicate machine concepts using only a web browser.

What it does

OpenDigitalTwin is a lightweight, browser-based environment for building and testing industrial 3D scenes.

It allows users to:

  • Import robot and equipment geometry.
  • Configure robot links, joints, tools, TCPs, and coordinate frames.
  • Position objects using X, Y, Z, Roll, Pitch, and Yaw.
  • Create robot poses and organize them into executable Jobs.
  • Adjust pose order and transition speed.
  • Visualize robot and object motion without installing a game engine.
  • Bind scene objects to OPC UA variables.
  • Display object status values directly in the 3D workspace.
  • Save and reload digital-twin projects.
  • Perform geometry-based collision checks without running a full physics simulation.

For our live demonstration, OpenDigitalTwin operates as an OPC UA Client through a middleware gateway.

A simulated PLC exposes an object pose such as:

ObjectPos
├─ X
├─ Y
├─ Z
├─ Roll
├─ Pitch
├─ Yaw
└─ Status

The user selects a 3D object, opens its OPC UA binding configuration, and maps these values to the object transform.

When the values change in the simulated PLC, the object moves in the browser-based 3D scene. The interface clearly indicates that OPC UA owns the transform, preventing manual input from overriding live automation data.

The same workspace also contains an industrial robot and a logical linear slide. Users can create and run robot Jobs to review joint motion, coordinate frames, pose order, and approximate spatial interaction with surrounding equipment.

This creates a practical workflow for validating both kinematic behavior and industrial data integration from a normal web browser.

How we built it

OpenDigitalTwin was built with React, TypeScript, Three.js, React Three Fiber, Zustand, and Vite.

The system is divided into several layers:

Simulated PLC / OPC UA Server
              ↓
     OPC UA Client Gateway
              ↓
      Browser Runtime Store
              ↓
 Robot, Object, and Status Bindings
              ↓
        Three.js 3D Scene

Web browsers cannot directly communicate with native opc.tcp endpoints, so we use a middleware gateway as the OPC UA Client. The gateway subscribes to PLC variables and publishes normalized runtime values to the web application.

The browser then maps those values to scene entities.

Each object can have independent ownership for:

  • Transform
  • Numeric status
  • Visibility
  • Display color

For example, an object can use OPC UA for its XYZRPY transform while retaining a manually configured status or color.

Robot geometry and robot mechanics are also separated. Geometry defines what the robot looks like, while the robot definition describes its link hierarchy, joint axes, limits, tool frames, and kinematic behavior. This allows the same 3D workspace to support imported robot models without assuming every STEP file has the same internal structure.

Robot Jobs use deterministic joint poses and configurable transition speeds. This keeps the web simulation reproducible and lightweight while still providing useful kinematic and layout validation.

Challenges we ran into

One major challenge was handling industrial CAD data in a browser.

STEP files may contain hundreds of thousands of triangles, large assemblies, or manufacturer-specific structures. A single STEP assembly may visually represent an entire robot but still lack the explicit joint hierarchy, axes, and limits required for simulation.

We learned that geometry import and mechanical configuration must be treated as separate processes.

Another challenge was OPC UA connectivity. Browsers cannot directly open native OPC UA TCP connections, so we needed a gateway architecture that could connect to an OPC UA Server, subscribe to values, and safely pass normalized data to the web application.

We also needed to define data ownership clearly. If an object is controlled by OPC UA, manual UI changes must not silently compete with PLC data. OpenDigitalTwin therefore displays whether each transform is owned by manual input, simulation, or OPC UA.

Other challenges included:

  • Converting industrial coordinate conventions into Three.js coordinates.
  • Supporting XYZRPY while using stable quaternion-based rotation internally.
  • Avoiding unnecessary React rerenders during high-frequency pose updates.
  • Keeping imported geometry responsive in a browser.
  • Distinguishing an offline gateway from a genuine application error.
  • Preserving project data while allowing assets to be referenced externally.
  • Providing useful collision feedback without implementing a complete physics engine.

We initially explored a more complex multi-robot handover scenario, but narrowed the live demonstration to the most reliable and reusable workflow: OPC UA-driven object motion combined with browser-based robot kinematic verification.

That scope decision made the demonstration easier to understand and closer to a real small-manufacturer use case.

Accomplishments that we're proud of

We are proud that OpenDigitalTwin combines industrial connectivity, robot kinematics, and 3D visualization in one browser-based workspace.

The current prototype demonstrates:

  • Live OPC UA Client integration through middleware.
  • PLC-controlled object position and orientation.
  • Clear transform-ownership indication.
  • Robot joint visualization and manual control.
  • Multi-pose Robot Jobs with speed and sequence configuration.
  • Robot, object, linear-axis, tool, and coordinate-frame representation.
  • Runtime status overlays for scene objects.
  • Project save, load, import, and export.
  • Geometry-based collision validation.
  • Support for manually positioned and OPC UA-controlled objects.
  • A production web build validated by 2,190 automated unit tests.

Most importantly, the project provides a working path from a PLC variable to a visible 3D result without requiring users to build a custom Unity or Unreal application.

What we learned

We learned that an industrial digital twin is not simply a 3D model.

A useful digital twin needs a clear relationship between:

  • Geometry
  • Mechanical structure
  • Coordinate frames
  • Runtime data
  • Data ownership
  • Robot Jobs
  • External automation systems

We also learned that small businesses often need fast and understandable validation before they need high-fidelity physics.

For many early engineering decisions, the most valuable questions are:

  • Is the equipment positioned correctly?
  • Does the robot’s motion approximately fit the workspace?
  • Are the joint axes and mechanical relationships configured correctly?
  • Is the PLC publishing the expected values?
  • Does the correct object move when the OPC UA variable changes?
  • Are the coordinate systems and units consistent?

A lightweight web tool can answer many of these questions before a team invests in more advanced simulation.

We also learned the importance of separating high-frequency runtime data from the React component tree. Live pose data must update the 3D scene efficiently without rebuilding the entire application or collision model on every subscription update.

What's next for OpenDigitalTwin

The next step is to make robot and machine configuration easier for users without specialized simulation experience.

Planned improvements include:

  • A guided robot-import workflow for STEP and GLB assets.
  • Manual configuration of robot links, joint axes, origins, limits, and hierarchy.
  • URDF import and export.
  • Automatic suggestions for separating a robot assembly into mechanical links.
  • OPC UA browsing and drag-and-drop variable mapping.
  • Structured OPC UA mappings for robot joints and object XYZRPY values.
  • Timestamp-aware interpolation for smoother subscribed motion.
  • Configurable moving frames for conveyors, linear axes, and positioners.
  • More primitive industrial assets such as boxes, cylinders, tables, and safety zones.
  • Performance budgets and automatic mesh simplification for large CAD files.
  • Docker deployment for the web application and OPC UA gateway.
  • Reusable project templates for common manufacturing cells.
  • Improved reachability and geometry-based collision visualization.
  • Optional OPC UA Server mode for sending simulated values back to a PLC or external application.

Longer term, OpenDigitalTwin could provide a simple progression:

Concept Layout
      ↓
Kinematic Validation
      ↓
OPC UA Integration Test
      ↓
Detailed Engineering Tool
      ↓
Physical Commissioning

OpenDigitalTwin is intended to make the first three steps faster and more accessible, especially for small manufacturers that cannot dedicate a large budget or specialized team to industrial simulation.

Built With

Share this project:

Updates