Krill - Process orchestrator for Robotics

Professional-grade process orchestrator for robotics systems built in Rust.

Unlike ROS2 launch or Docker compose, Krill adds safety-first orchestration with cascading failures, critical service protection, and a real-time monitoring UI designed for robots.

[]() []() []()

Overview

Krill provides DAG-based service orchestration, health monitoring, and safety interception for critical robotics applications. It manages complex dependency graphs of services (pixi tasks, ROS2 launch files, shell commands) with automatic restart policies, fault cascading, and emergency stop capabilities.

Key Features:

• ⚡ DAG-based orchestration - Services start/stop in correct dependency order
• 🔄 Automatic restarts - Configurable policies: always, on-failure, never
• 💚 Health monitoring - Heartbeat, TCP, HTTP, and script-based checks
• 🚨 Safety interception - Critical service failures trigger emergency stop
• 🔗 Cascading failures - Dependent services stop when dependencies fail
• 📊 Terminal UI - Monitoring interface
• 🔌 IPC protocol - JSON-based client-server communication
• 📝 Session logging - Per-service logs with timeline aggregation
• 🎮 GPU validation - Checks GPU availability before starting services
• 🛡️ Shell safety - Validates and rejects dangerous shell patterns

Quick Start

Installation

just install

Create a recipe

Here's a complete example orchestrating a ROS2 robot navigation stack:

version: "1"
name: autonomous-robot
log_dir: ~/.krill/logs
env:   ROSDOMAINID: "42"   ROSLOCALHOSTONLY: "0"
services:   # Hardware drivers start first   lidar:     execute:       type: ros2       package: ldlidar_ros2       launch_file: ldlidar.launch.py     health_check:       type: tcp       port: 4048     policy:       restart: on-failure       max_restarts: 3
camera:     execute:       type: ros2       package: realsense2_camera       launchfile: rslaunch.py       launch_args:         enable_depth: "true"         enable_color: "true"     dependencies:       - lidar     health_check:       type: tcp       port: 8554
# SLAM for mapping and localization   slam:     execute:       type: ros2       package: slam_toolbox       launchfile: onlineasync_launch.py     dependencies:       - lidar: healthy       - camera: healthy     health_check:       type: heartbeat       timeout: 5s
# Navigation stack   navigation:     execute:       type: ros2       package: nav2_bringup       launchfile: navigationlaunch.py     dependencies:       - slam: healthy     critical: true  # If navigation fails, stop everything     health_check:       type: http       port: 8080       path: /health     policy:       restart: always       restart_delay: 2s
# Web dashboard   dashboard:     execute:       type: docker       image: ghcr.io/robotics/web-ui:latest       ports:         - "3000:3000"       volumes:         - "./config:/app/config:ro"       network: host     dependencies:       - navigation: started

See Configuration Guide for all available options.

Running krill

Start the daemon and open the TUI

krill up krill.yaml

If a daemon is already running, just connect to the TUI

krill

Stop krill with the command:

krill down

Why krill?

After working on various robotics projects, we realised the need for a robust process orchestrator that could handle complex dependencies and provide a user-friendly interface for monitoring and managing services. Krill was born out of this need, with a focus on:

• Predictability: Know exactly why a service failed and which dependent nodes were brought down as a result.
• Safety-First: If a critical "Guardian" node fails, Krill can trigger an immediate system-wide shutdown or emergency state.
• Tool Agnostic: Stop fighting environment variables. Seamlessly mix Rust, Python, C++, and Dockerized workloads in a single graph.

How it looks

https://github.com/user-attachments/assets/4707d2e5-42ac-4d92-8fba-749ccb340a2c

Open-Core Philosophy

Krill follows an open-core model. The community edition you see here is fully open-source under the Apache-2.0 license and covers everything needed to orchestrate robotics services in production:

• DAG-based orchestration, health monitoring, restart policies, cascading failures, and safety interception
• Terminal UI, CLI, and client SDKs (Rust, Python, C++)
• Pixi, ROS2, Docker, and shell execution backends

Krill Pro (coming soon) extends the core with enterprise features for larger teams and fleet deployments:

• Advanced scheduling policies
• Fleet-wide orchestration and remote management
• Metrics export and observability integrations
• Priority support

The boundary is simple: if you're running services on a single robot or dev machine, the open-source edition has you covered. Pro targets multi-robot fleets and enterprise operational needs.

We believe the core orchestrator should always be free and community-driven. Revenue from Pro funds continued development of both editions.

Learn more

Full Documentation

Examples

SDK Installation

License

Apache-2.0

Copyright 2026 Tommaso Pardi

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.