Description
Solarian is an open-source Python framework designed for the comprehensive development, control, teleoperation, and training of robots. It provides a unified stack for robotics projects, from hardware integration to advanced AI control, enabling developers to build, simulate, and deploy robots efficiently. The framework is built around a clean three-node architecture: Robot, Server, and Controller, each capable of running as a separate process on different machines.
Read More
Key to Solarian's design is its real-time multi-process modularity. Each hardware module, such as an arm, gripper, or camera, operates in its own OS process at a configurable rate, communicating with the robot loop via shared-memory ring buffers. This ensures that high-frequency components are not bottlenecked by slower ones, allowing for precise and responsive control. The framework also incorporates built-in kinematics, enabling command of end effectors with automatic inverse kinematics solving and live pose reporting through forward kinematics.
Solarian emphasizes reusability and extensibility through a plug-and-play system for hardware and skills. Developers can install servo drivers, arms, grippers, and cameras as plugins, complete with configuration. Similarly, skills—ranging from motion plans to learned policies—can be installed and reused across different robots that expose compatible actions. The framework supports simulation out-of-the-box, allowing the same robot declarations and configurations to drive either a MuJoCo world or physical hardware by simply setting a flag.
A standout feature is the AI Agentic Controller, which transforms any Solarian Controller into an AI agent. This harness wraps around a vision-language model (such as Anthropic, OpenAI, or compatible servers), allowing users to give high-level tasks via chat. The agent then plans the task and executes it by calling the robot's physical skills as tools. A fast monitor model continuously observes the running skills through cameras, providing real-time feedback and enabling dynamic adjustments or interventions. This controller is highly configurable, utilizing Hydra for composed YAML configurations across all modules and commands.
For learning and development, Solarian offers robust recording and training capabilities. It allows for session recording of camera feeds and sensor signals at their native rates, ensuring no data quality is lost. Dataset management tools facilitate mirroring, splitting, trimming, and merging episodes. The framework supports training various policies, including diffusion and ACT, locally or on cloud GPUs, and provides services for deploying these trained policies to skills. Developer utilities like typed observations and actions (using Pydantic schemas) and calibration tools further enhance the development experience, making it easier to go from concept to a functional robot.
- CategoryRobotics & AI Hardware
- Pricing ModelOpen Source
- DeploymentOn-premise, Cloud (Solarian Base GPUs)
- PlatformsWeb
Solarian's Core Features
Open-source Python framework for robotics
Real-time multi-process modules for hardware
Robot ↔ Server ↔ Controller architecture
Plug-and-play hardware and skill plugins
AI Agentic Controller for chat-driven robot tasks
Integration with any vision-language model (Anthropic, OpenAI, vLLM)
Built-in kinematics for end effector control
Simulation support with MuJoCo
Session recording and dataset management
Policy training and serving capabilities
Hydra-driven YAML configuration
Typed observations and actions with Pydantic
Developer utilities including calibration tools
ZeroMQ for high-throughput inter-node communication
PyTorch support for policies and inference
How to use Solarian?
Install Solarian: Use `pip install solarian` and optionally `pip install 'solarian[agent]'` for AI agent features.
Scaffold a Project: Use `solarian create-project` to set up a new robotics project.
Attach Hardware Modules: Install plug-and-play hardware drivers and their configurations using `solarian install <module_name>`.
Configure System: Edit `conf/robot.yaml`, `conf/controller.yaml`, and module-specific YAML files to define your robot and control logic.
Run Components: Start the relay server, robot loop, and controller processes, potentially on separate machines.
Define Skills: Create or install physical skills that the AI Agentic Controller can use as tools.
Enable AI Agentic Control: Add an `agent:` block to your `conf/controller.yaml` and declare `agent_enabled=True` tools.
Interact with Robot: Give high-level tasks to the AI Agentic Controller via chat to plan and execute actions.
Solarian's Use Cases
- Building Custom Robots
- Robot Teleoperation
- AI Agentic Control
- Robot Skill Development
- Robotics Simulation
- Robot Policy Training
- Robotics Research
- Hardware Integration
- Data Collection for Learning



