Peppy

The robotics framework for simplified robot development.

PeppyOS is a robotics framework that takes you from development to production at scale, letting you focus on building intelligent robots while we handle the complexity.

Build and deploy robot software with ease. PeppyOS streamlines your entire robot stack — sensors, actuators, AI, and controllers — making robotics development accessible even if you've never worked with robots before.

15 minutes to get productive Fully free

Example node: OpenArm01

Input

// This is an example of the backbone node for OpenArm01
{
  schema_version: 1,
  manifest: {
    name: "openarm01_backbone",
    tag: "0.1.0",
    depends_on: {
      // We use generic nodes that can do ik/collision/pose estimation
      nodes: [
        {
          name: "inverse_kinematic",
          tag: "0.1.0",
          local_id: "ik"
        },
        {
          name: "collisions_detection",
          tag: "0.1.0",
          local_id: "colisions"
        },
        // Component nodes — must start first; backbone plugs into them
        {
          name: "openarm01_arm",
          tag: "0.1.0",
          local_id: "arm"
        },
        {
          name: "openarm01_gripper",
          tag: "0.1.0",
          local_id: "gripper"
        },
      ]
    }
  },
  // Non exhaustive list of interfaces
  interfaces: {
    actions: {
      exposes: [
        {
          name: "move_arm",
          goal_service: {
            request_message_format: {
              // The arm id
              arm_id: "u16",
              // The frequency in hertz at which the feedback is being sent
              feedback_frequency: "u32",
              // x, y, z
              desired_position: {
                $type: "array",
                $items: "f64",
                $length: 3
              },
              // quaternion x, y, z, w
              desired_orientation: {
                $type: "array",
                $items: "f64",
                $length: 4
              }
            },
            response_message_format: {
              accepted: "bool"
            }
          },
          // Streamed as the arm moves toward the goal
          feedback_topic: {
            qos_profile: "standard",
            message_format: {
              joint_positions: {
                $type: "array",
                $items: "f64"
              },
              current_ee_position: {
                $type: "array",
                $items: "f64",
                $length: 3
              },
              action_time: "f64"
            }
          },
          result_service: {
            response_message_format: {
              success: "bool",
              message: "string",
              final_joint_positions: {
                $type: "array",
                $items: "f64"
              },
              final_ee_position: {
                $type: "array",
                $items: "f64",
                $length: 3
              },
              action_time: "f64"
            }
          }
        }
      ]
    },
    services: {
      consumes: [
        {
          local_node_id: "arm",
          name: "get_arm_id",
        },
        {
          local_node_id: "gripper",
          name: "get_gripper_id",
        },
      ]
    }
  },
}
// This is an example of the backbone node for OpenArm01
{
  schema_version: 1,
  manifest: {
    name: "openarm01_backbone",
    tag: "0.1.0",
    depends_on: {
      // We use generic nodes that can do ik/collision/pose estimation
      nodes: [
        {
          name: "inverse_kinematic",
          tag: "0.1.0",
          local_id: "ik"
        },
        {
          name: "collisions_detection",
          tag: "0.1.0",
          local_id: "colisions"
        },
        // Component nodes — must start first; backbone plugs into them
        {
          name: "openarm01_arm",
          tag: "0.1.0",
          local_id: "arm"
        },
        {
          name: "openarm01_gripper",
          tag: "0.1.0",
          local_id: "gripper"
        },
      ]
    }
  },
  // Non exhaustive list of interfaces
  interfaces: {
    actions: {
      exposes: [
        {
          name: "move_arm",
          goal_service: {
            request_message_format: {
              // The arm id
              arm_id: "u16",
              // The frequency in hertz at which the feedback is being sent
              feedback_frequency: "u32",
              // x, y, z
              desired_position: {
                $type: "array",
                $items: "f64",
                $length: 3
              },
              // quaternion x, y, z, w
              desired_orientation: {
                $type: "array",
                $items: "f64",
                $length: 4
              }
            },
            response_message_format: {
              accepted: "bool"
            }
          },
          // Streamed as the arm moves toward the goal
          feedback_topic: {
            qos_profile: "standard",
            message_format: {
              joint_positions: {
                $type: "array",
                $items: "f64"
              },
              current_ee_position: {
                $type: "array",
                $items: "f64",
                $length: 3
              },
              action_time: "f64"
            }
          },
          result_service: {
            response_message_format: {
              success: "bool",
              message: "string",
              final_joint_positions: {
                $type: "array",
                $items: "f64"
              },
              final_ee_position: {
                $type: "array",
                $items: "f64",
                $length: 3
              },
              action_time: "f64"
            }
          }
        }
      ]
    },
    services: {
      consumes: [
        {
          local_node_id: "arm",
          name: "get_arm_id",
        },
        {
          local_node_id: "gripper",
          name: "get_gripper_id",
        },
      ]
    }
  },
}

Output nodes

camera lidar robot brain hardware controller CAN-FD bus 1 CAN-FD bus 2

Your robot stack

Why robotics teams choose PeppyOS

Node-Based Robot Architecture

Define your robot stack as modular nodes — cameras, lidar, AI brains, and servo controllers — connected through a simple configuration file.

From Prototype to Production

Deploy robot software that scales from a single prototype to a fleet of robots. PeppyOS handles orchestration, monitoring, and updates.

Multi-Language Support

Write robot nodes in Python or Rust. PeppyOS connects them seamlessly with low-latency inter-process communication.

Built for Performance

PeppyOS is written in Rust for maximum throughput and minimal resource usage. Run more nodes on less hardware without sacrificing reliability.