This article tries to explain the relation between Juliet & Romeo® and the Standard Robot Command Interface, outlining their respective roles, design principles, and how they can be used together in modern robotics and automation projects. The important thing here is that the two technologies are not mutually exclusive but rather overlapping and can easily coexist and complement each other across the automation stack.
SRCI defines a standardized interface between PLCs and robot controllers, using vendor-independent function blocks and communication structures. It’s ideal for allowing robots to be commanded from PLC logic in a unified, hardware-agnostic way.
Juliet & Romeo offers a modern, expressive programming language for deterministic multitasking, motion programming, logic, AI, and more.
Juliet & Romeo can implement SRCI servers to expose motion control to external PLCs, or act as SRCI clients to control robots that expose an SRCI-compatible interface.This two-way compatibility allows seamless integration into SRCI-based PLC environments or broader automation architectures, letting Juliet applications benefit from the SRCI interface just as PLC systems does. Where SRCI is limited to the robot interface, Juliet & Romeo offers a complete suite for building modern robot applications.
Juliet is a robot and automation programming language (from Cognibotics), designed to support real-time motion, process logic, sensor handling, user interfaces, AI integration, etc. It is intended to enable developers to model, reuse and evolve complex automation systems with clarity.
Romeo is the real-time virtual machine/runtime that executes Juliet (and potentially other languages that follow its bytecode format). It offers execution safety, deterministic behavior, real-time constraints, automatic memory management, etc.
It’s positioned as a “future-proof robotics and automation foundation” that unifies programming, execution, and system evolution; meant to reduce setup time, support for modular updates, enable AI readiness, etc.
SRCI is an open standard/protocol/interface that defines how PLCs (Programmable Logic Controllers) can send standardized robot commands to robot controllers (servers), regardless of manufacturer. It is being defined and hosted by groups like Profibus & Profinet International.
It standardizes not just communication but also function-blocks / libraries in the PLC environment, so you can program robot motion, logic, etc., via PLC using SRCI blocks rather than proprietary robot interfaces.
It has (or will have) profiles (Core, Extended, optional) that define a set of commands (move, path, force control, etc.), and vendors can support subsets depending on hardware or version.
The two technologies are complementary and overlapping, not competing. This compatibility offers two primary integration paths:
Juliet & Romeo as an SRCI Server: When used to develop a robot control system (as done by Estun Automation), Juliet & Romeo can incorporate an SRCI library. This allows external SRCI clients, such as PLC systems, to seamlessly access and command the Juliet & Romeo-based robot control system.
Juliet & Romeo as an SRCI Client: For line or cell control systems, a Juliet & Romeo application can utilize an SRCI client library to send standardized commands to a robot system that exposes an SRCI-compatible interface.
Detailed Comparison: Goals and Strengths
Key Differences and Trade-offs
Feature Mapping and Scope
The relationship between SRCI and Juliet & Romeo is not one of competition, but of strategic integration. SRCI achieves its core mission of providing a reliable, vendor-agnostic interface for motion control from the PLC. However, modern automation systems demand more than simple robot commands. Juliet & Romeo steps into this gap, offering a complete, future-proof programming foundation that encompasses real-time motion, complex process logic, multi-robot coordination, AI integration, and HMI development. By offering two-way compatibility, Juliet & Romeo ensures that users can both serve and benefit from the SRCI standard while gaining a robust and flexible platform for all advanced automation challenges.
For deeper technical insights, the following articles explore how Juliet & Romeo® relates to key automation ecosystems and standards:
Juliet & Romeo® and ROS 2 (link): How Cognibotics’ real-time platform complements the open-source robotics framework.
Juliet & Romeo® and IEC 61131 (link): How modern deterministic automation extends traditional PLC programming environments.
Juliet & Romeo® and SRCI (link): Understanding how standardized PLC-to-robot interfaces align with Cognibotics’ real-time approach.
Julliet & Romeo® Coexisting with Robotics and Automation Ecosystem (link): By coexisting with IEC 61131 PLCs, SRCI, and ROS, it supports modernization where ROI is clear, without disrupting what already works.
