The Orchestration Layer for Event-Driven ROS2 Systems

Sugarcoat is a meta-framework that replaces fragmented ROS2 development with a unified workflow, offering a high-level API to build robust components and orchestrate them into cohesive, self-healing systems.

By replacing verbose boilerplate and static launch files with an Event-Driven API, Sugarcoat allows you to orchestrate complex robotic behaviors with the elegance of modern Python.

Why Sugarcoat? Bridging the Orchestration Gap

In the standard ROS2 ecosystem, developers are given powerful tools to create individual “bricks” (Nodes), but very few tools to create the “building” (the System). As robotic systems scale, they inevitably face the Orchestration Gap: a void between low-level drivers and high-level mission planning.

• Standard ROS2: Leads to a “Manager Node” problem. To coordinate nodes, developers write a manager node that quickly becomes a “spaghetti” of callbacks, timers, and hardcoded logic that is difficult to test and prone to failure.
• Behavior Trees (e.g., Nav2): Rely on sequential polling mechanisms (“ticks”) that process logic sequentially. They are latency-prone, can block the system’s ability to react during complex actions, and make global scope safety triggers (like a universal killswitch) notoriously difficult to implement.

The Sugarcoat Solution: Sugarcoat provides an imperative, event-driven middle layer. It operates on a Parallel Event Engine that doesn’t “tick” through a list; it listens to the entire system at once, offering true distributed automation with immediate microsecond reaction times.

Key Features & Core Pillars

Packages Built with Sugarcoat

• Kompass: A framework for building robust and comprehensive event-driven navigation stacks using an easy-to-use and intuitive Python API.
• EmbodiedAgents: A fully-loaded framework for creating interactive embodied agents that can think, understand and act.

Get Started

• Learn more about the design concepts in Sugarcoat
• Learn how to create your own ROS2 package using Sugarcoat
• Port your automation recipes across different hardware using Robot Plugins
• Explore the Dynamic Web UI for real-time system visualization and control

How Sugarcoat Works

The core of Sugarcoat revolves around bringing seemless orchestration and reactive autonomy to your robot.

1. Components (Smart Execution)

A Component is your main execution unit, replacing the standard ROS2 Node. It validates its own configuration, automatically wires topics declaratively, and manages its own lifecycle natively.

2. Events & Actions (Reactive Middle Layer)

Define dynamic behavior using pure Python expressions. Events monitor topics continuously in parallel, completely independent of the execution state of your components.

from ros_sugar.core import Event, Action

# A global event monitored in parallel, executing instantly with zero polling latency
collision_risk = Event(sensor.msg.min_dist < 0.5)

# Trigger a System-Wide Action instantly
launcher.add_pkg(
    components=[...],
    events_actions={collision_risk: Action(stop_motors)}
)

3. Launcher (Orchestration)

Takes your defined Components, Events, and Actions, and executes the system. The Launcher actively tracks health statuses and orchestrates multi-threaded or multi-process execution cleanly.

Dynamic Web UI for Sugarcoat Recipes

The Dynamic Web UI feature takes system visibility and control to the next level. Built with FastHTML and MonsterUI, it is designed to automatically generate a fully dynamic, extensible web interface for any Sugarcoat recipe, completely eliminating the need for manual front-end development.

Automatic UI Generation in Action

File truncated at 100 lines see the full file