Reachy Mini FAQ

To control Reachy Mini, you mainly use the ReachyMini class from the reachy_mini package:

from reachy_mini import ReachyMini

mini = ReachyMini()

This connects to the Reachy Mini daemon (started via reachy-mini-daemon or reachy_mini.daemon.app.main) and initializes motors and sensors.

Recommended pattern: use a context manager to automatically handle connection and cleanup:

from reachy_mini import ReachyMini

with ReachyMini() as mini:
    # your code here
    ...

Source: API documentation.

Yes. All examples assume you have already started the Reachy Mini daemon:

• Either via command line: reachy-mini-daemon
• Or via Python: reachy_mini.daemon.app.main

The ReachyMini instance will then connect to this daemon.

Source: API documentation.

Most testers report 1.5–2 hours, with some up to 4 hours depending on experience.

Source: Feedback – "What's your background?" = hobbyist / developer / experienced technology professional.

Most testers consider about 2 hours to be an ideal assembly time.

Source: Feedback – "What's your background?"

Testers highlighted:

• Cable routing
• Correct torque on screws

Source: Feedback – "What's your background?"

Typical checks:

1. You are using a proper Python virtual environment (.venv).
2. You installed/updated the Reachy Mini SDK inside that environment:

   pip install -U reachy-mini

3. The daemon is running.

This combination fixed most dashboard issues.

Source: Discord – author: matth_lap (trusted).

Use goto_target with a pose created by create_head_pose:

from reachy_mini import ReachyMini
from reachy_mini.utils import create_head_pose

with ReachyMini() as mini:
    mini.goto_target(head=create_head_pose(y=-10, mm=True))

Here:

• create_head_pose builds a 4x4 transform matrix (position + orientation).
• mm=True means translation arguments are in millimeters.
• The head frame is located at the base of the head.

Source: API documentation.

You can add orientation arguments to create_head_pose, for example:

pose = create_head_pose(z=10, roll=15, degrees=True, mm=True)
mini.goto_target(head=pose, duration=2.0)

• degrees=True ⇒ angles are given in degrees.
• You can combine translation (x, y, z) and orientation (roll, pitch, yaw).

Source: API documentation.

Use goto_target with multiple named arguments:

import numpy as np
from reachy_mini import ReachyMini
from reachy_mini.utils import create_head_pose

with ReachyMini() as mini:
    mini.goto_target(
        head=create_head_pose(y=-10, mm=True),
        antennas=np.deg2rad([45, 45]),
        duration=2.0,
        body_yaw=np.deg2rad(30),
    )

• antennas is a 2-element array in radians [right, left].
• body_yaw controls body rotation.

Source: API documentation.

goto_target:

• Interpolates motion over a duration (default 0.5s).
• Supports different interpolation methods (linear, minjerk, ease, cartoon).
• Ideal for smooth, timed motions.

set_target:

• Sets the target immediately, without interpolation.
• Suited for high-frequency control (e.g. sinusoidal trajectories, teleoperation).

Example (sinusoidal motion):

y = 10 * np.sin(2 * np.pi * 0.5 * t)
mini.set_target(head=create_head_pose(y=y, mm=True))

Source: API documentation.

Use the method argument in goto_target:

mini.goto_target(
    head=create_head_pose(y=10, mm=True),
    antennas=np.deg2rad([-45, -45]),
    duration=2.0,
    method="cartoon",  # "linear", "minjerk", "ease", or "cartoon"
)

For a visual comparison of methods, you can run the example:

• examples/goto_interpolation_playground.py

Source: API documentation.

Inherit from ReachyMiniApp and implement run:

import threading
from reachy_mini.apps.app import ReachyMiniApp
from reachy_mini import ReachyMini

class MyApp(ReachyMiniApp):
    def run(self, reachy_mini: ReachyMini, stop_event: threading.Event):
        # your app logic
        ...

• stop_event tells you when the app should stop.
• This pattern is used for standalone apps and for HF Spaces.

Source: API documentation.

Use the app template generator:

reachy-mini-make-app my_app_name

This creates:

my_app_name/
├── pyproject.toml
├── README.md
├── my_app_name/
│   ├── __init__.py
│   └── main.py

You can run it via:

python my_app_name/main.py

Or install it as a package:

pip install -e my_app_name/

Source: API documentation.

Yes, via Hugging Face Spaces:

• Example hub: Reachy Mini Apps
• Official example space: reachy_mini_app_example

Source: API documentation + Discord – author: annecharlotte_pollen (trusted).

Use RecordedMoves and play_move:

from reachy_mini import ReachyMini
from reachy_mini.motion.recorded_move import RecordedMoves

with ReachyMini() as mini:
    recorded_moves = RecordedMoves("pollen-robotics/reachy-mini-dances-library")
    for move_name in recorded_moves.list_moves():
        mini.play_move(recorded_moves.get(move_name), initial_goto_duration=1.0)

• initial_goto_duration smoothly brings the robot to the starting pose of the move.
• Datasets are hosted on Hugging Face (e.g. emotions / dances libraries).

Source: API documentation.

Call start_recording() and stop_recording(), which record all set_target calls:

with ReachyMini() as mini:
    mini.start_recording()
    # run your teleop / control code...
    recorded_motion = mini.stop_recording()

You can then unpack time, head, antennas, body_yaw from each frame and save them.

Tools to record/upload datasets are available in:

• reachy_mini_toolbox/tools/moves

Source: API documentation.

Use the media object:

from reachy_mini import ReachyMini

with ReachyMini() as mini:
    frame = mini.media.get_frame()
    # frame is a numpy array as returned by OpenCV

Source: API documentation.

from reachy_mini import ReachyMini

with ReachyMini() as mini:
    sample = mini.media.get_audio_sample()
    # sample is a numpy array as output by sounddevice

Source: API documentation.

from reachy_mini import ReachyMini

with ReachyMini() as mini:
    mini.media.push_audio_sample(chunk)  # chunk = numpy array of audio samples

Source: API documentation.

Install with the GStreamer extra:

pip install -e ".[gstreamer]"

Then run examples with:

• --backend gstreamer

You need GStreamer binaries properly installed on your system. You can also define custom pipelines (see camera_gstreamer.py in the repo).

Source: API documentation.