Open-source middleware for the OMG RoIS Framework 2.0

Why OpenRoIS

Write the Application Once. Integrate Each Platform Once.

Service applications for human-robot interaction are usually written against the interface of one platform, so every change of hardware forces a rewrite. RoIS 2.0 standardizes the interaction at the symbolic level, and OpenRoIS provides the maintained implementation, SDKs, and adapters that the standard needs in practice.

With vendor-specific interfaces, N applications and M platforms, whether physical robots, virtual avatars, or digital services, need N times M integrations. With OpenRoIS, they need N plus M.

Architecture

The RoIS Model, Realized as Processes You Can Deploy

The gateway hosts the main HRI Engine. Each adapter hosts a sub HRI Engine for one robot, avatar, or service, and reaches it through the transport that platform requires. Media stays on a separate data plane.

OpenRoIS architecture: service applications, among them an AI agent through the MCP server, the gateway hosting the main HRI Engine, adapters hosting sub HRI Engines for physical robots, virtual avatars, and digital services, and their hosts.

Explore the Architecture →

What OpenRoIS Provides

The Building Blocks for Putting RoIS to Work

Engine

Recursive Engine

One Engine class realizes both the main and the sub HRI Engine roles of RoIS. The gateway and every adapter share a single dispatch implementation.

Learn more →Architecture

One RoIS Protocol at Every Hop

The RoIS method catalog from application to gateway, from gateway to adapter, and from engine to component. ROS 2, gRPC, and game engines stay inside adapters.

Learn more →Protocol

JSON-RPC 2.0 over WebSocket

The System, Command, Query, and Event interfaces of RoIS map to namespaced methods. The control plane works from browsers and across the internet.

Learn more →Types

Single Source of Truth

RoIS types are authored once in Python, exported to JSON Schema, and generated into TypeScript and C#, and checked locally against the normative RoIS files.

Learn more →Profiles

Profile-Driven Applications

Applications discover components, commands, queries, and events at runtime, so one application works with any platform behind the gateway.

Learn more →Components

Decorator-Based Components

Declare a component with @component, and mark its RoIS messages with @command, @query, and @event. Write only the code that talks to your robot.

Learn more →

The Five RoIS Interfaces

Standard Operations over JSON-RPC 2.0

RoIS 2.0 defines what a service application can ask of an HRI Engine. OpenRoIS maps each operation onto a JSON-RPC 2.0 method, with requests, responses, and asynchronous notifications over one WebSocket connection.

System

rois.system.*

connect
disconnect
get_profile

Command

rois.command.*

search
bind
set_parameter
execute
release

Query

rois.query.*

query

Event

rois.event.*

subscribe
unsubscribe
notify_event

Streaming

Planned

streaming components

connect_stream
suspend_stream
notify_stream_status

Read the Wire Protocol Reference →

For Developers

Build on Either Side of the Standard

Application developers use an SDK to address any platform through the RoIS interfaces. Robot developers write components that translate those interfaces into calls to their own stack, and the adapter framework handles the rest.

JavaScript SDK for web and Node.js applications
Python SDK for scripts and services
Unity SDK for desktop, mobile, and VR applications
Python component SDK for adapters, with ROS 2 support

Run the Quick Start

Service Application
Component
On the Wire

import { RoISClient } from "@openrois/sdk";

const client = await RoISClient.connect("ws://localhost:8765");

// Discover components across every connected robot, then pick one by type.
const refs = await client.search();
const nav = refs.find((ref) => ref.includes("Navigation"))!;

// Read state synchronously.
const status = await client.query(nav, "component_status");

// React to events.
client.on("reached_target", (n) => console.log(n.params));
await client.subscribe(nav, "reached_target");

// Reserve an actuation component, command it, release it.
await client.bind(nav);
await client.setParameter(nav, [
  { name: "target_positions", data_type_ref: "string[]", value: '["kitchen"]' },
]);
await client.execute(nav, { command_type: "start" });
await client.release(nav);

from openrois.components.core import Component, command, component, event
from openrois.interfaces.components import NAVIGATION_PROFILE


@component(NAVIGATION_PROFILE)
class Navigation(Component):
    """Translates RoIS Navigation into calls to your robot's own API."""

    def __init__(self, robot_url: str) -> None:
        self._robot_url = robot_url

    async def connect(self) -> None:
        self._robot = await MyRobotClient.open(self._robot_url)

    @command("start")
    async def start(self) -> None:
        target = self.parameters["target_positions"][0]
        await self._robot.go_to(target)
        self.emit("reached_target", target=target, is_final_target=True)

    @event("reached_target")
    async def reached_target(self) -> None:
        pass  # start emits the event when the robot arrives.

// Service application to gateway
{ "jsonrpc": "2.0", "id": 7, "method": "rois.command.bind",
  "params": { "component_ref": "robot_1/Navigation" } }

{ "jsonrpc": "2.0", "id": 7, "result": { "return_code": "OK" } }

// Gateway to service application, pushed when the robot arrives
{ "jsonrpc": "2.0", "method": "rois.event.notify_event",
  "params": {
    "event_id": "evt-8b0c",
    "event_type": "reached_target",
    "subscribe_id": "sub-3f2a",
    "expire": "",
    "results": [
      { "name": "target", "data_type_ref": "string", "value": "kitchen" },
      { "name": "is_final_target", "data_type_ref": "bool", "value": "true" }
    ] } }

Project Status

Built in the Open, One Capability at a Time

OpenRoIS is alpha software with an unstable API. The foundations are in place and demonstrated with a physical robot. The rest of the RoIS surface follows a public roadmap.

Available

RoIS interface types in Python, JSON Schema, TypeScript, and C#
Recursive engine, gateway process, and component SDK (Python), on PyPI
Client SDKs for JavaScript (npm), Python (PyPI), and Unity, passing one conformance list
The OpenRoIS Inspector, and an MCP server that lets AI agents drive robots
Reachy Mini adapter, run on the real robot and in simulation

In Progress

RoIS conformance: run-time XML component profiles and a conformance claim
Applications and engines that recover from a restart

Planned

A physical robot and a virtual avatar behind one gateway
Authentication and authorization
Media streaming, transport-neutral, with an optional WebRTC integration
A stable API with semantic versioning guarantees (v1.0)

See the Full Roadmap →

Get Involved

Help Carry RoIS into Practice

OpenRoIS is community-driven and developed in the open under the Apache License 2.0. Components for new robots are the natural entry point, and the roadmap lists work that can be picked up in parallel.

OMG RoIS 2.0JSON-RPC 2.0WebSocketJSON SchemaROS 2Unity

Contribute on GitHub Contributing Guide

Cite OpenRoIS

Using OpenRoIS in Your Research?

The position paper describing OpenRoIS is accepted at SII 2027. Until it appears in the proceedings, please cite its preprint, arXiv:2609.21178, or the software. The repository also provides a CITATION.cff file.

@misc{carrera2026openrois,
  author        = {Carrera Villalobos, Sebastian and Arellano, Christopher Nolan and
                   Hitzmann, Arne and Morais Brito, Edilson and Utsumi, Akira and
                   Horikawa, Yukiko and Miyashita, Takahiro and Ishiguro, Hiroshi and
                   El Hafi, Lotfi},
  title         = {{OpenRoIS}: A Community-Driven Open-Source Middleware Implementing
                   the Robotic Interaction Service ({RoIS}) Framework for Physical
                   Robots, Virtual Avatars, and {AI} Agents},
  year          = {2026},
  eprint        = {2609.21178},
  archivePrefix = {arXiv},
  primaryClass  = {cs.RO},
  doi           = {10.48550/arXiv.2609.21178},
  url           = {https://arxiv.org/abs/2609.21178},
  note          = {Accepted at the 2027 IEEE/SICE International Symposium on
                   System Integration (SII 2027), to appear}
}

@software{openrois,
  author  = {{OpenRoIS Community}},
  title   = {{OpenRoIS}: Open-Source Middleware Implementing the {OMG}
             Robotic Interaction Service ({RoIS}) Framework 2.0},
  url     = {https://openrois.org/},
  license = {Apache-2.0},
  year    = {2026}
}