eSOL Brings Game Engine Visualization to Industrial Embedded Development

eSOL Co. Ltd. has launched eXRP, a real-time 3D engine that helps visualize systems such as 3D simulations, digital twins, and human machine interfaces (HMIs) across automotive, robotics, manufacturing, and other industrial sectors.

The launch comes as embedded and industrial systems are becoming more software-defined and harder to validate through traditional methods alone. Engineers need logs, numerical outputs, computer-aided-engineering (CAE) results, and physical prototypes. But those tools do not always show how a system behaves in context.

The company emphasizes that automotive and manufacturing systems increasingly require advanced visualization, high-quality UI/UX, digital twins, cyber-physical systems, faster development cycles, and more cost-efficient workflows.

For these workflows, game engines are attractive because they provide real-time rendering, interactive scene manipulation, multiplatform deployment, and intuitive development environments. According to eSOL, eXRP provides a real-time visualization and interaction layer around those systems.

Challenges with siloed tools

The development of modern software-defined physical systems, such as autonomous mobile robots (AMRs), automated guided vehicles (AGVs), and software-defined vehicles (SDVs), is increasingly constrained by highly fragmented engineering workflows.

Traditionally, the lifecycle of industrial and embedded system development isolates discrete technical tasks into specialized, disconnected silos. For example, a CAE tool may be used to model dynamics or analyze a physical process, while a separate HMI tool may be used to design the operator's display. As a result, engineers are operating in fragmented environments.

Yuta Nakauchi, director of product management at eXRP, in an exclusive interview with Embedded.com, said conventional CAE tools are strong at accurate simulation but face challenges around real-time performance and interactivity. "On the other hand, HMI tools are responsive for user-facing displays but can be limited when rich 3D rendering and dynamic simulation need to be integrated," he added.

This separation becomes expensive and time consuming. For example, if a late-stage physical validation reveals an edge case failure, such as an AGV failing to navigate a dynamic obstacle while an operator attempts a manual override, the entire siloed toolchain must be reengaged.

eSOL frames this as one of the core problems that eXRP (eSOL XrossReality Platform), an industrial-grade real-time 3D engine, solves. "eXRP aims to provide an environment where simulations run and are visualized in real time," Nakauchi explained. "This allows users to interact with the model and validate behavior to eliminate the separation between simulation and visualization."

With eXRP, powered by the open-source Godot game engine, the goal is to bring fragmented tasks into a more continuous loop. The robot, factory floor, warehouse, obstacles, and operating conditions can be represented in a 3D environment. The system state can be visualized as it changes. Human operators can interact with the simulation while it is running. Engineers can test path planning, obstacle avoidance, fleet behavior, and intervention scenarios earlier, before every case has to be reproduced with physical robots.

"In eXRP, integration with embedded systems and ROS 2 forms a bidirectional data flow between the virtual space and control logic," Nakauchi said.

In a typical robotics use case, the workflow starts with robots and their surrounding environments being constructed within eXRP's 3D space, he explained, and the resulting point cloud data is output as virtual ROS nodes that act as substitutes for actual LiDAR devices.

The output data is then fed into ROS 2 applications for perception and path planning, which generate control commands. These commands are fed back into eXRP through virtual control-related ROS nodes to drive robot models such as wheels or arms. This shows that eXRP operates in a closed loop workflow where it not only renders robot animation but also processes software commands.

In eXRP's closed validation workflow, virtual sensors feed into software; the software produces commands; and the virtual world responds to those commands. For robotics developers, this creates a bridge between simulated environment behavior and the same ROS 2-based software patterns used in closer-to-deployment settings.

A game engine cannot replace deterministic control

While the capabilities of real-time 3D engines are comprehensive, certain technical boundaries must be maintained. Game engines are highly attractive because they provide real-time rendering, spatial scene management, 2D/3D UI systems, asset pipelines, and native multiplatform deployment capabilities.

However, these engines are non-deterministic in nature. Their execution loops are controlled by variable frame rates, asynchronous asset loading, and thread schedulers.

Therefore, a game engine cannot satisfy the requirements of safety-critical control or strict certification traceability (such as ISO 26262 for automotive environments or IEC 61508 for industrial safety systems).

eXRP addresses this through a framework where deterministic and non-deterministic components coexist within the same broader system that is separated by hardware and software boundaries.

Tasks that demand hard real-time scheduling, such as motor control loops, anti-lock braking systems, steering actuation, and emergency-stop safety monitors, remain within the embedded deterministic control stack. This is where eSOL positions its proprietary real-time operating system (RTOS), called eMCOS.

eMCOS is built on a patented multikernel (distributed microkernel) architecture. It deploys a compact, independent microkernel to each individual processor core. To achieve high-throughput parallel processing with safety, eMCOS isolates applications by maintaining separate thread databases (TDBs) for each core.

A similar boundary exists between eXRP and CAE tools. eXRP complements CAE by acting as an interactive visualizer for the results. "The boundary between the two lies in whether the objective is strict numerical validation or understanding, exploration, and decision-making," Nakauchi adds.

For example, in use cases where high-precision physical simulation or certification-related reproducibility and traceability are required, CAE tools remain the appropriate choice.

3D visualization engines become part of the embedded stack

To deploy the eXRP visualization engine to an embedded system-on-chip, it requires a capable GPU, sufficient memory bandwidth, and compatible graphics API support.

In a production environment, some of the systems involved are PLM, MES, and SCADA. Integrating a 3D engine with these systems comes with architectural challenges due to legacy interfaces, inconsistent data models, access control boundaries, and synchronization latency.

Game engines operate on frame rendering loops, while industrial data arrives asynchronously over different protocols. To solve this gap, modern industrial middleware uses standardized protocols, such as Open Platform Communications Unified Architecture (OPC UA).

"Integration is based on a loosely coupled architecture using APIs and middleware, rather than tight, system-specific integrations," Nakauchi noted.

This allows engineers to work on C/C++ libraries via GDExtension to integrate these protocols. For example, open-source C-stacks like open62541 allow Godot applications to act natively as OPC UA clients.

Positioning real-time 3D engines

eXRP is significant for embedded development because engineers need visual environments that help them understand and validate system behavior before hardware is fully available.

From a runtime perspective, real-time 3D engines may not become as universal as RTOSes or middleware. Their use will depend on the application, hardware constraints, safety requirements, and whether a deployed system needs advanced visualization.

eSOL positions the real-time 3D engine not as a replacement for deterministic control platforms, but as a visualization and interaction layer around them. The larger implication is that embedded software may increasingly be designed alongside the visualization infrastructure used to test, debug, and validate it.

The post eSOL Brings Game Engine Visualization to Industrial Embedded Development appeared first on Embedded.