This is Part 4 of our series on i3X and OPC UA. Part 1: When REST Meets Real-Time | Part 2: One API Call to Rule Them All | Part 3: The Missing Safety Layer

i3X Meets OPC UA: Performance Benchmarks & Semantic Mapping Patterns for node-i3x and i3x2ua

As the industrial automation community adopts i3X—the open REST API standard coordinated by CESMII—to bridge OPC UA operational technology (OT) with enterprise IT software, cloud platforms, and AI agents, developers benefit from multiple open-source implementations.

Two of the most prominent open-source i3X gateways available today are i3x2ua (the Python/AsyncUA reference gateway developed by Andreas Heine and community contributors) and node-i3x (the TypeScript/Node-OPCUA gateway developed by Sterfive).

When evaluating i3x2ua and node-i3x for industrial deployments, engineering teams frequently ask:

1. Performance & Scalability: How do i3x2ua (Python) and node-i3x (Node.js) compare in HTTP latency, throughput, and gzip bandwidth efficiency when querying live OPC UA servers?
2. Semantic Domain Mapping: How do i3x2ua and node-i3x map OPC UA Object and Variable nodes onto i3X REST API resources (/v1/objects and /v1/objects/value)?

In this article, we share empirical benchmarking results comparing i3x2ua and node-i3x, explore their respective architectural design choices, and provide a guide for selecting the right gateway for your industrial stack.

What is i3x2ua?

i3x2ua is an open-source Python implementation of the CESMII i3X REST API standard. Built on top of Python's asyncua OPC UA library and the FastAPI / Uvicorn web framework, i3x2ua translates REST requests into asynchronous OPC UA client calls.

Key strengths of i3x2ua:

• Python Native: Integrates seamlessly into Python-centric industrial data engineering, machine learning (Pandas, PyTorch, Scikit-learn), and Jupyter notebook workflows.
• AsyncUA Core: Uses Python's native asyncio for non-blocking OPC UA communication.
• FastAPI OpenAPI Integration: Provides automatic Swagger UI (/docs) and Pydantic v2 data validation for all i3X REST endpoints.

Finding 1: Performance Benchmarks — i3x2ua (Python) vs. node-i3x (Node.js)

To measure gateway translation efficiency, we executed automated side-by-side HTTP traffic benchmarks comparing i3x2ua (v1.12.1) and node-i3x (v0.10.0).

Both gateway servers were run locally against an identical OPC UA test server (opc.tcp://localhost:48412/UA/EmbeddedDemo) hosting over 680 nodes and 280 object types.

⏱️ HTTP Response Latency Benchmark

The table below summarizes average local HTTP response times across core i3X REST endpoints (measured across 10 benchmark runs per endpoint):

📦 Payload Efficiency & Network Serialization

Both i3x2ua and node-i3x support HTTP gzip compression out of the box:

Understanding the Performance Profile (V8 + Node-OPCUA vs. CPython + asyncua)

The observed throughput and latency advantages stem from two complementary factors: the underlying language runtime (V8 JIT compilation vs. CPython bytecode interpretation) and the architectural maturity of the OPC UA stack:

1. Binary Protocol Encoding & Buffer Optimization:

   • Node-OPCUA: Features over 12 years of continuous industrial optimization. It handles OPC UA binary protocol chunking using fast, low-level V8 Buffer operations and pre-allocated byte structures, minimizing heap object allocations during bulk node browses.
   • asyncua (Python): Implemented in pure Python. Decoding OPC UA binary streams requires instantiating native Python objects (DataValue, Variant, ExtensionObject, NodeId) for every node. In CPython, heap-allocating thousands of Python dictionary and class objects during a browse operation creates CPU and Garbage Collection (GC) overhead.

2. JIT Machine Code vs. Bytecode Execution:

   • Node.js: Uses Google's V8 engine to JIT-compile JavaScript/TypeScript directly into native x86_64 machine code. Tight loops in binary parsing and JSON serialization run close to native C speed.
   • Python: Executes bytecode through the CPython interpreter, carrying higher CPU overhead for bitwise binary framing and bulk string serialization.

3. Event Loop Efficiency:

   • Node.js (libuv): Uses a C++ event loop where MonitoredItem queues, session timeouts, and Fastify JIT JSON serializers (fast-json-stringify) execute with minimal context-switching overhead.
   • Python (asyncio / FastAPI): While FastAPI and Pydantic v2 represent the state of the art in Python web frameworks, coroutine context-switching in CPython carries higher per-task cost during concurrent REST queries.

In summary, node-i3x leverages Node-OPCUA's binary encoding engine and Fastify to deliver low-latency, high-concurrency REST translation, while i3x2ua provides an excellent, native Python stack that integrates seamlessly into data science, AI, and industrial analytics pipelines (Pandas, PyTorch, Jupyter).

Finding 2: Semantic Address Space Mapping in i3x2ua and node-i3x

A core architectural question when building an OPC UA-to-i3X gateway is: How should OPC UA address space elements map onto i3X REST API resources?

In OPC UA, address spaces contain Object, ObjectType, Variable, VariableType, and ReferenceType nodes. In i3X, the API is organized into Objects (/v1/objects), ObjectTypes (/v1/objecttypes), and Values/Properties (/v1/objects/value).

Figure 1: Visual comparison showing how node-i3x (Asset-Centric Model) and i3x2ua (Direct Node Discovery Model) project the same OPC UA address space onto CESMII i3X REST resources.

Strategy 1: Direct Node Discovery (i3x2ua)

• How i3x2ua maps nodes: i3x2ua lists both OPC UA Object nodes and Variable nodes in the /v1/objects endpoint as discoverable elements.
• Advantages: Every OPC UA NodeId is directly visible as an element ID in the /v1/objects response. Clients can easily inspect any individual variable NodeId and pass it directly to POST /v1/objects/value.
• Use Case: Excellent for OPC UA address space exploration, debugging, and direct variable tag mapping.

Strategy 2: Asset-Centric Abstraction (node-i3x)

• How node-i3x maps nodes: node-i3x restricts /v1/objects strictly to OPC UA Object nodes (representing physical assets like pumps, boilers, or production lines). OPC UA Variable nodes are represented as telemetry properties queried via POST /v1/objects/value or nested property attributes.
• Advantages: Aligns strictly with ISA-95 and Asset Administration Shell (AAS) domain modeling standards. The /v1/objects endpoint returns a clean Asset Knowledge Graph that AI agents can navigate without being overwhelmed by raw variable tags.
• Use Case: Ideal for enterprise Knowledge Graphs, AI agents, and asset-level analytics dashboards.

Frequently Asked Questions (FAQ)

Is i3x2ua fully compliant with the CESMII i3X 1.0 specification?

Yes. i3x2ua achieves 100% compliance with the i3X 1.0 REST API specification, passing all automated conformance tests for REST queries, authentication, error handling, and VQT value formatting.

Should I choose i3x2ua or node-i3x for my project?

• Choose i3x2ua if your engineering stack is built on Python, or if you are integrating i3X data into Python data science pipelines (Pandas, NumPy, Scikit-learn), FastAPI microservices, or Jupyter notebooks.
• Choose node-i3x if your application requires TypeScript / Node.js integration, high-concurrency web REST services, or a strict ISA-95 Asset Knowledge Graph for AI agents.

Conclusion: The Debate Remains Open — Let's Discuss!

The semantic boundary between OPC UA Variables and i3X Objects remains an active, open debate as the i3X specification evolves towards its official 1.0 standardization under CESMII.

While node-i3x prioritizes an asset-centric hierarchy and i3x2ua provides direct address space node discovery, both strategies highlight valuable trade-offs for industrial integrators:

• Should i3X gateways enforce a strict Asset Entity boundary at the /v1/objects endpoint?
• Or should the specification allow configurable view filters so clients can toggle between raw OPC UA node discovery and ISA-95 asset topology?

We believe the best standards are forged through open collaboration. We are very happy and excited to continue this discussion with Andreas Heine, the i3x2ua community, CESMII working groups, and the broader OPC UA open-source community to help shape the future of i3X interoperability.

Project Links & Join the Discussion

• i3x2ua (Python Gateway): github.com/AndreasHeine/i3x2ua
• node-i3x (TypeScript Gateway): github.com/sterfive/node-i3x
• i3X Portal Live Playground: i3x-portal.sterfive.io