# Solarian > Solarian is an open-source Python framework to build, simulate, teleoperate, train and deploy robots. A robot is a Python class made of modules (arms, grippers, cameras), each made of sensors and actuators; skills and learned policies (UMI, diffusion, ACT) drive it, and an agentic controller calls those skills as tools. Coding agents: install with `pip install solarian`, then start from the CLI instead of writing files by hand. `solarian create-project ` scaffolds a project and `solarian create-plugin ` a plugin; both write an AGENTS.md and agent skills, so read AGENTS.md next. `solarian docs list` and `solarian docs show ` print these docs for the installed version, offline. ## Get Started - [Overview](https://solarian.dev/docs/overview.md): A high-level introduction to Solarian — what it is, what it solves, the architecture, and the key features. - [Installation](https://solarian.dev/docs/installation.md): Install Solarian on Linux, macOS, or directly on your robot. Includes optional extras for AI policies and simulation. - [Creating a Project](https://solarian.dev/docs/creating-a-project.md): Scaffold a Solarian project named my_robot, wire its arm module, and run the relay server, robot, and a keyboard controller end-to-end. ## Tutorials - [Tutorials](https://solarian.dev/docs/tutorials.md): The Solarian tutorial series, in order: the ideas, a simulated robot, the real arm, skills, and training a policy. - [A Gentle Introduction to Robotics](https://solarian.dev/docs/tutorials/gentle-intro-to-robotics.md): The basic ideas of robot manipulation, from joints and coordinates to sensors, control, and learned policies. The start of the tutorial series. - [The robot's body](https://solarian.dev/docs/tutorials/gentle-intro-to-robotics/body.md): Links, joints, end effectors, and degrees of freedom, with the six-joint Solarian Arm 1 as the example, and the Solarian classes that describe a robot. - [Robot configurations and coordinates](https://solarian.dev/docs/tutorials/gentle-intro-to-robotics/configuration.md): What a robot's configuration is, the two ways to write it down, joint coordinates and task coordinates, and the frames and rotations those numbers live in. - [Kinematics](https://solarian.dev/docs/tutorials/gentle-intro-to-robotics/kinematics.md): What kinematics is, forward and inverse kinematics, why inverse kinematics can have two answers or none, the reachable and dexterous workspace, and how Solarian computes both directions. - [The control loop](https://solarian.dev/docs/tutorials/gentle-intro-to-robotics/control.md): The read, decide, write loop every robot runs: the sensors that read, the actuators and torque that write, and the control that turns a goal into motion. - [Policies and learning](https://solarian.dev/docs/tutorials/gentle-intro-to-robotics/learning.md): What a policy is, the language of states, observations, actions, dynamics and trajectories, and how robots learn policies: imitation learning, diffusion policies, ACT, VLAs, and reinforcement learning. - [Your first Solarian robot](https://solarian.dev/docs/tutorials/first-robot.md): Build a Solarian Arm 1, a solarian-gripper1, and a wrist camera in simulation, starting from an empty Solarian project. - [Create a project](https://solarian.dev/docs/tutorials/first-robot/project.md): Scaffold a Solarian project named my_robot, see what each file is for, and run the three processes on a robot with no hardware yet. - [The Robot](https://solarian.dev/docs/tutorials/first-robot/arm.md): Build the Solarian Arm 1 robot: write its first module, the arm, declare it on the robot class, and place the arm model in a MuJoCo scene. - [Observations & Actions](https://solarian.dev/docs/tutorials/first-robot/observations-actions.md): What observations and actions are, why every Solarian project defines them, and how to write the ones for the Solarian Arm 1. - [The Controller](https://solarian.dev/docs/tutorials/first-robot/keyboard.md): Write the Solarian Arm 1 controller: a teleop skill that nudges each joint from the keyboard, and a controller that starts it. - [Move it](https://solarian.dev/docs/tutorials/first-robot/simulate.md): Run the Solarian Arm 1 project in MuJoCo and move the arm with the keyboard. - [The gripper](https://solarian.dev/docs/tutorials/first-robot/gripper.md): Install the solarian-gripper1 Feetech gripper from a plugin and attach its model to the arm flange. - [The camera](https://solarian.dev/docs/tutorials/first-robot/camera.md): Add a Pi camera module and show the simulated wrist view in the controller. - [The real robot](https://solarian.dev/docs/tutorials/real-robot.md): Buy and assemble a Solarian Arm 1, calibrate the servos, and drive the Tutorial 2 project on the hardware. - [Assemble](https://solarian.dev/docs/tutorials/real-robot/assemble.md): Assemble the Solarian Arm 1, then the solarian-gripper1 and the wrist camera. - [Computer](https://solarian.dev/docs/tutorials/real-robot/computer.md): Set up the Raspberry Pi, the Feetech serial port, and a deployment file so the laptop controller talks to the robot. - [Calibrate](https://solarian.dev/docs/tutorials/real-robot/calibrate.md): Record each Solarian Arm 1 joint limit, the home pose, and the sim direction with solarian calibrate. - [Drive it](https://solarian.dev/docs/tutorials/real-robot/drive.md): Run the Tutorial 2 keyboard controller on the physical Solarian Arm 1. - [Real camera](https://solarian.dev/docs/tutorials/real-robot/camera.md): Open the Raspberry Pi CSI camera with PiCameraModule and see the live image in the controller. - [Robot skills](https://solarian.dev/docs/tutorials/skills.md): Add skills beside keyboard teleop: MoveSkill from a plugin, and a pretrained UMI policy. - [Move to a pose](https://solarian.dev/docs/tutorials/skills/move.md): Install MoveSkill, name a joint pose, and add inverse kinematics so the arm can also move to a Cartesian pose. - [What UMI is](https://solarian.dev/docs/tutorials/skills/umi.md): A short introduction to the Universal Manipulation Interface: demonstrations from a hand-held gripper, a wrist camera, and a policy that outputs motion. - [A pretrained pick](https://solarian.dev/docs/tutorials/skills/pick.md): Install UMISkill, point it at a pick checkpoint, and run it in simulation with one key. - [On the real arm](https://solarian.dev/docs/tutorials/skills/real-arm.md): Calibrate the wrist lens and the hand-eye transform, then run the same pick skill on the hardware. - [Train a skill](https://solarian.dev/docs/tutorials/training.md): Train a UMI policy on an example dataset, then collect your own demonstrations with a Lumi recorder and train again. - [Datasets](https://solarian.dev/docs/tutorials/training/datasets.md): What a Solarian dataset is: episodes of observations and actions, and what a useful demonstration looks like. - [Run your checkpoint](https://solarian.dev/docs/tutorials/training/run.md): Point the Tutorial 4 pick skill at the checkpoint you just trained and run it with the same key. - [Lumi](https://solarian.dev/docs/tutorials/training/lumi.md): What the Lumi collector is, the parts, and how a demonstration gets onto the SD card. - [Collect](https://solarian.dev/docs/tutorials/training/collect.md): Record pick demonstrations on Lumi, pack them, and turn the archive into a training dataset. Record on the robot when the demonstration is teleop. - [Train on your data](https://solarian.dev/docs/tutorials/training/train.md): Drop short episodes, train a UMI policy on your own dataset, and run it with the same pick key. ## Core Concepts - [Robots](https://solarian.dev/docs/robots.md): A Robot is the on-robot node that owns hardware. Subclass it, attach Modules as class attributes, and Solarian handles process spawning, ZMQ messaging, and shared-memory observation buffers. - [Modules](https://solarian.dev/docs/modules.md): A Module is a self-contained unit of robot hardware (an arm, a gripper, a camera) that runs in its own process at its own rate. It groups components (actuators, sensors, servos) reached through buses, owns its own control loop, and handles incoming actions. - [Observations](https://solarian.dev/docs/observations.md): Observation is the typed schema of every sensor reading the robot publishes. It groups per-module ModuleObs subclasses tied to your robot tree, supports server-side computed fields, and is the same object you record, replay, and feed to policies. - [Controllers](https://solarian.dev/docs/controllers.md): A Controller is the node that decides what the robot does. Subclass it, register it, and either start Skills (teleop, a move to a named pose, a learned policy) and let the base class merge what they emit, or override control_step() and build each Action yourself. - [AI Overview](https://solarian.dev/docs/ai.md): How Solarian layers artificial intelligence on top of the core control loop: low-level Skills driven by learned policies (diffusion, ACT, VLAs) as System 1, and the AI Agentic Controller, an agent harness around any vision-language model that plans and calls those skills as tools, as System 2. - [AI Agentic Controller](https://solarian.dev/docs/agentic_controller.md): Agentic control for any robot: a harness around any vision-language model takes a task from chat, plans it, and carries it out by calling the controller’s physical skills as tools, while a fast monitor model watches each one through the cameras. - [Policies](https://solarian.dev/docs/policies.md): A Policy is the trainable model a Skill calls to produce actions — diffusion, ACT, VLAs, or classical methods. A policy server is a service with a standard API, trained and served independently of the Skill that consumes it. - [Training](https://solarian.dev/docs/training.md): Train policies in Solarian via library-agnostic policy plugins: implement a PolicyTrainer, register it under solarian.trainers, and run `solarian train` locally or on Modal. - [Experiment Tracking](https://solarian.dev/docs/tracking.md): Log training metrics with a wandb-shaped API and pick the backend in config: wandb, Solarian Base, both, or none. - [Actions](https://solarian.dev/docs/actions.md): Action is the typed schema of every command sent to the robot. It groups per-module ModuleAction subclasses and carries an integer action type that decides how the robot routes it: into a module queue as a motion, to a skill, or to an @action_handler you declare. - [Skills](https://solarian.dev/docs/skills.md): A Skill is a self-contained behavior — a diffusion policy, a motion plan, a scripted routine — that runs in its own process. The AI Agentic Controller calls skills as tools to carry out tasks given in chat. - [Server](https://solarian.dev/docs/servers.md): The RelayServer is the middle node in Solarian. It forwards actions from controllers to robots and observations back, and can run server-side observation processors and skills. - [Events](https://solarian.dev/docs/events.md): An Event is something that happened — a key went down, a button was clicked, a limit switch tripped. Modules emit them, their host drains them on its own tick, and handlers and skills react. - [Services](https://solarian.dev/docs/services.md): A service is a model served over HTTP that a calculated observation field or a skill calls, such as a click-to-track bounding box or a policy. Run it locally with solarian run-service. - [Project Settings](https://solarian.dev/docs/settings.md): Every Solarian project has a settings.py that registers the Robot, Controller, and Server classes. The CLI auto-discovers it; you can also point at it explicitly with --settings. - [Project Configs](https://solarian.dev/docs/project-configs.md): Solarian uses Hydra to compose YAML configuration. The conf/ folder is organized by consumer: robot.yaml, controller.yaml and server.yaml at the root, and a folder per kind of config (modules, skills, services, commands, training, calibrations, deployment). - [Calibration](https://solarian.dev/docs/modules/calibration.md): Record physical joint limits, check that travel does not straddle the encoder seam, and map those ranges and directions onto the sim model. - [Scheduling Waypoints](https://solarian.dev/docs/modules/scheduling-waypoints.md): How SCHEDULE_L / SCHEDULE_J work: controllers send sparse timestamped targets; the module upsamples with a pose or scalar TrajectoryInterpolator at its control rate. Examples for MinkIK arms and grippers. - [Inverse Kinematics](https://solarian.dev/docs/ik.md): Give a module Cartesian (end-effector) control by declaring six CartesianIKActuators and an ik_backend spec. Solarian auto-wraps the joint bus with an IKActuatorBus that runs differential IK every tick. Works identically on real hardware and in simulation. Includes the contract and a Solarian Arm 1 walkthrough for adding a new arm. - [Latency & Synchronization](https://solarian.dev/docs/latency.md): How UMI-style skills compensate for sensing and actuation delay: the five latency parameters, which direction each one corrects, why the camera is the master clock, and how to measure every value on your own hardware with calibrate-arm, calibrate-gripper and calibrate-camera-latency. - [Recording](https://solarian.dev/docs/recording.md): How Solarian records episodes: the robot writes one mp4 per camera at archive resolution and one parquet of every signal at its native rate, and the controller can write the same layout from what reached it, so a dataset keeps the quality the sensor produced and, beside it, what the policy actually saw. - [Datasets](https://solarian.dev/docs/datasets.md): The Solarian dataset format: a recording session of episodes, each one parquet table of every signal at its own rate and one mp4 per camera. How it is laid out, how ops derive new versions of it without copying, and the other formats Solarian Base opens. - [Simulation](https://solarian.dev/docs/simulation.md): Run any Solarian robot in a MuJoCo simulation by flipping a switch: declare a scene and run solarian run-robot --sim. The same modules, servos, cameras and YAML drive both real hardware and sim. Covers scenes, attaching module models, simulated servos and cameras, and building models from CAD. - [Plugins](https://solarian.dev/docs/plugins.md): Plugins are standalone solarian- packages that extend Solarian with hardware drivers, modules, robots, skills, policies, dataset ops and CLI commands. Install one with solarian install, or scaffold your own with solarian create-plugin and publish it to PyPI. ## CLI - [Command Line Interface](https://solarian.dev/docs/commands.md): Reference for every Solarian CLI command — running the robot, controller, and server, recording datasets, training policies, and authoring custom commands. ## Glossary - [Glossary](https://solarian.dev/docs/glossary.md): A glossary of robotics terms used in Solarian and Solarian-specific concepts. ## Optional - [All docs in one file](https://solarian.dev/llms-full.txt) - [Plugin directory](https://solarian.dev/plugins): published solarian-* packages - [Hardware directory](https://solarian.dev/hardware): open hardware with BOMs and assembly