The Open Source
Robotics Framework
Build, simulate, teleoperate, train, and deploy robots with one extensible Python framework—from hardware to AI control in one stack.
Everything you need to build robots that learn
Real-time control
Modules, kinematics, and an AI planner share one control loop, each running at the rate it needs.
Real-time modules
Solarian has a modular architecture: a robot is built from modules like an arm, a gripper, or a camera. Each runs in its own process at its own rate, so a 500 Hz arm never waits on a 30 Hz camera.
Kinematics built in
Command the end effector and the module solves inverse kinematics every tick, reporting the live pose through forward kinematics.
AI Controller
A vision-language model plans the task and picks the skill to run. Each runs at its own rate in a separate thread or process.
Simulate, plug in, reuse
Build a robot once, run it in MuJoCo or on hardware, and extend it with hardware and skill plugins.
Simulation built in
Declare a robot as a class with its modules as attributes. Set is_sim = True and the same modules and YAML drive a MuJoCo world instead of the hardware.
Plug-and-play hardware
Solarian is extended through plugins. Servo drivers, arms, grippers, and cameras install with solarian install, config included, and solarian create-plugin starts your own.
Plug-and-play skills
Skills install the same way: a motion plan, a scripted routine, or a learned policy that runs on any robot exposing the same actions.
Learning policies
Go from teleoperated demonstrations to a trained policy driving the robot, without leaving the framework.
Session recording
solarian record keeps every camera as mp4 and every signal at its native rate, so no quality is lost.
Dataset management
Mirror, split, trim, and merge episodes into new versions without copying or losing data.
Policy training and serving
solarian train runs diffusion, ACT, or your own trainer, locally, on Modal, or on Solarian Base GPUs. solarian run-service then serves the policy to your skills.
Developer utilities
The pieces every robotics project needs, built in.
Typed observations and actions
Pydantic schemas bound to your modules. What a sensor reads is what you stream, record, replay, and feed to a policy.
Hydra configuration
Every command reads composed YAML: robot.yaml, controller.yaml, one file per module. Override any value from the command line.
Calibration tools
solarian calibrate records joint limits and the home pose. Latency commands measure camera and actuator delay on your hardware.
From idea to robot in three commands
Scaffold a project, attach a hardware module from a plugin, then run the relay server, the robot loop, and a controller — each on whatever machine makes sense.
# Scaffold a new project
create-solarian myrobot
cd myrobot
# Install a plugin
solarian install ur5
# Run the three nodes
solarian run-server
solarian run-robot
solarian run-controllerBuilt on a foundation of fast, production-grade tooling
ZeroMQ
High-throughput PUSH/PULL and PUB/SUB sockets carry every action and observation between nodes.
Hydra
Composable YAML configs for every command, every module, and every connection profile.
PyTorch
First-class support for policies, vision-language models, and on-robot inference.
Pydantic
Strong typing for configs, observations, actions, and inter-process messages.
Ready to bring your robot to life?
Start with the overview, or jump straight into installing Solarian and scaffolding your first project.