Built and published Reachy Mini greeting appPublic

Now I have everything I need. Let me build the app. I'll structure it as a proper Reachy Mini app (Python package with the right entry point), with a web button as the primary interface (matching "press a button" literally) plus antenna-press as a hardware fallback.

Let me sanity-check the Python compiles cleanly before handing it over:

Compiles cleanly. Here's what I built:

[View the README](computer:///Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning/README.md) [View main.py (the app)](computer:///Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning/src/good_morning_app/main.py) [View pyproject.toml](computer:///Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning/pyproject.toml)

It's packaged as a proper Reachy Mini app (subclass of ReachyMiniApp, registered via the reachy_mini_apps entry point — same shape as reachy_mini_conversation_app). On startup it pre-renders "Good morning!" once with pyttsx3, caches it as a WAV, and on every press loads it as mono float32 @ 16 kHz and pushes it to the speaker via reachy_mini.media.push_audio_sample(...) — that's the canonical TTS path because the SDK doesn't expose a .speak() helper.

You get two buttons:

A big on-screen button at http://<robot>:7860/ (also embedded in the dashboard), and either antenna as a physical button — Reachy Mini doesn't have a real push-button, but the antennas are spec'd that way; deflection >0.3 rad on either antenna fires the same trigger, with a 1.5 s debounce so a single push doesn't repeat.

Run it standalone with python -m good_morning_app.main after pip install -e ., or install it and launch through the Reachy Mini dashboard.

Sources:

• pollen-robotics/reachy_mini SDK
• Python SDK audio docs (push_audio_sample)
• Reference app: reachy_mini_conversation_app

Quickest path, assuming you have a Reachy Mini (Lite plugged in via USB, or Wireless on your network):

1. Set up a Python env with the Reachy Mini SDK

# Python 3.10–3.12 requiredpython3.12 -m venv ~/reachy_mini_envsource ~/reachy_mini_env/bin/activatepip install reachy-mini

If you're on Linux you'll also need GStreamer + the udev rules for the USB connection — see the SDK installation doc. On macOS/Windows, just pip install reachy-mini is usually enough.

2. Make sure the robot daemon is running and the robot is reachable

reachy-mini-daemon            # starts the daemon (Lite, USB)# or for Wireless: it runs on the robot itself; just check reachy-mini.local:8000 responds

Quick sanity check the SDK can see it:

from reachy_mini import ReachyMiniwith ReachyMini() as mini:    print(mini.get_current_joint_positions())

3. Install the Good Morning app

From the folder I just created (reachy-mini-good-morning/):

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"pip install -e .

(-e = editable install, so any tweak you make to main.py takes effect immediately.)

On Linux, pyttsx3 needs espeak: sudo apt install espeak-ng. On macOS it uses the built-in say voices, no extra install. On Windows it uses SAPI5.

4. Run it — two ways

The "I just want to see it work" way:

python -m good_morning_app.main

You'll see logs like Good Morning app starting (web on :7860, antennas armed). Then:

• Open http://localhost:7860/ in a browser → click the big orange button → robot says "Good morning!"
• Or push either antenna on the robot → same thing.

The "as a real Reachy Mini app" way (shows up in the dashboard alongside the other installed apps):

# the app is already registered via the entry point in pyproject.toml,# so the dashboard / launcher will pick it up automatically.# Open the Reachy Mini dashboard and click "Good Morning".

5. If you don't have the robot yet

You can still verify the TTS half works on its own:

pip install pyttsx3 soundfile scipy numpypython -c "from good_morning_app.main import _synthesize_phrase, _load_phrase_for_robotfrom pathlib import Path_synthesize_phrase('Good morning!', Path('test.wav'))print(_load_phrase_for_robot(Path('test.wav')).shape)"

You should see something like (20480, 1) and a playable test.wav next to you. The robot half (mini.media.push_audio_sample) only runs when a real Reachy Mini is connected.

Common gotchas

• "ReachyMini cannot connect" → daemon isn't running, or the robot isn't powered on / on the same network.
• "No audio comes out" → run mini.media.start_playing() was skipped (the app does this for you in run()); also check the speaker isn't muted via alsamixer on the robot.
• "Antenna press isn't detected" → push it further, or lower ANTENNA_THRESHOLD in main.py from 0.3 to 0.2.
• Port 7860 already in use → change WEB_PORT in main.py.

pip isn't on your PATH on stock macOS — pip3 usually is, or even better, use a virtual environment so the SDK doesn't fight your system Python.

Try this from the same folder you're already in:

# 1. Check what Python you havepython3 --version

If it says 3.10, 3.11, or 3.12 you're set. If it's 3.13 or you get "command not found", install Python 3.12 first (brew install python@3.12 if you have Homebrew, otherwise grab the installer from python.org).

# 2. Make a venv and activate itpython3 -m venv .venvsource .venv/bin/activate
# 3. Now `pip` exists inside the venv. Install the app + the SDK.pip install --upgrade pippip install -e .
# 4. Run itpython -m good_morning_app.main

Then open http://localhost:7860/ in a browser.

If python3 -m venv complains, fall back to:

python3 -m pip install --user -e .python3 -m good_morning_app.main

Let me know what python3 --version prints and I'll tailor from there if anything errors out.

Yes — the Reachy Mini app directory IS Hugging Face Spaces with the reachy_mini tag. You publish by pushing the app to a Hugging Face Space and the robot's dashboard discovers it. Let me make our app publish-ready (it's missing the HF Space landing page) and walk you through it.

The app folder is now publish-ready (HF Space frontmatter, landing page, styles, .gitignore). Here are the two ways to publish — the easy path uses Pollen's official tool, the manual path is just git push to a Hugging Face Space.

[Open the app folder](computer:///Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning/README.md)

How the Reachy Mini app directory actually works

There's no separate "app store" to submit to. The directory is just Hugging Face Spaces tagged with reachy_mini. The robot's dashboard scans HF for spaces with that tag and lists them. So to publish you literally just need an HF Space with the right README frontmatter (which our README already has) — git push and you're listed.

Path A — the official tool (recommended)

This avoids the broken pip problem because we'll go through uv (faster, doesn't need a system pip).

# 1. Install uv (modern Python installer/runner)brew install uv      # or: curl -LsSf https://astral.sh/uv/install.sh | sh
# 2. Make a Python 3.12 envcd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"uv venv --python 3.12source .venv/bin/activate
# 3. Install the SDK + the app-assistant CLIuv pip install reachy-mini reachy-mini-app-assistant huggingface_hub
# 4. Log in to Hugging Face (creates the Space under your account)hf auth login         # paste a token from https://huggingface.co/settings/tokens (write scope)
# 5. Validate our app's structure first (catches missing frontmatter, bad entry points, etc.)reachy-mini-app-assistant check .
# 6. Push it as a Space — this creates huggingface.co/spaces/clementdelangue/good-morning#    and the Reachy Mini dashboard will pick it up.reachy-mini-app-assistant publish .

If publish isn't a subcommand on your version, regenerate the scaffold with our code merged in:

reachy-mini-app-assistant create good_morning ../tmp_good_morning --publish# then copy our src/good_morning_app/main.py, index.html, style.css over the scaffold and `git push`

Path B — manual, no extra tools, just git

Cleanest if the assistant gives you any trouble:

# 1. Create an empty Space on the web:#    https://huggingface.co/new-space  →  SDK = "Static"  →  name "good-morning"
# 2. From inside the app folder:cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/.../reachy-mini-good-morning"git initgit add .git commit -m "Initial commit"
# 3. Push to the Space (replace clementdelangue with your HF username if different)git remote add origin https://huggingface.co/spaces/clementdelangue/good-morninggit push -u origin main

You'll be prompted for credentials — username is your HF handle, password is an HF access token (not your password) from https://huggingface.co/settings/tokens. Pick write scope.

After publishing

1. Visit https://huggingface.co/spaces/<your-username>/good-morning — you should see the orange landing page.
2. On your Reachy Mini's dashboard, browse apps — Good Morning should show up because of the reachy_mini and reachy_mini_python_app tags in the README. One-click install from there, then launch it.
3. Pushing new commits to the Space updates the app for everyone who installs it.

What might go wrong, and the fix

• hf: command not found after uv pip install huggingface_hub → use huggingface-cli login instead (older CLI name).
• Space not appearing in the dashboard → double-check the README frontmatter has both reachy_mini and reachy_mini_python_app tags. Ours does.
• git push rejected for "LFS required" → your audio cache file got committed. Our .gitignore excludes good_morning.wav so it should be fine; if you generated it before adding the .gitignore, run git rm --cached src/good_morning_app/good_morning.wav and recommit.

Want me to also add a short demo video/GIF slot to the landing page (reserved spot you can drop a clip into later), or change the published Space name from good-morning to something else?

The reachy-mini-app-assistant package isn't on PyPI — it's an internal Pollen tool that's hard to get. Skip it. Path B (just git push to a Hugging Face Space) is actually simpler and gets the same result, since the "app directory" is just HF Spaces with the right tag.

Let's go straight to publishing. Run these in the same terminal where you still have (reachy-mini-good-morning) active:

1. Install only what you actually need

uv pip install huggingface_hub

2. Get a Hugging Face write token

Open https://huggingface.co/settings/tokens → New token → name it whatever, select Write access → copy the token (starts with hf_…). Keep it on your clipboard.

3. Log in

hf auth login

If that says "command not found", use the older name:

huggingface-cli login

Paste the token when prompted. Answer n to "Add token as git credential?" — we'll handle git auth manually below (cleaner).

4. Create the empty Space on the web

Open https://huggingface.co/new-space and:

• Owner: your account (clementdelangue)
• Space name: good-morning
• License: MIT
• SDK: pick Static
• Visibility: Public

Click Create Space. It'll show you a fresh empty repo page — leave it open.

5. Push our folder to it

Back in the terminal:

# you should still be in reachy-mini-good-morning/git init -b maingit add .git commit -m "Initial commit: Good Morning Reachy Mini app"
# Embed the token in the remote URL so git won't prompt — replace hf_xxx with your tokengit remote add origin https://clementdelangue:[REDACTED]/spaces/clementdelangue/good-morninggit push -u origin main

(After the push works, you can swap the remote back to a tokenless URL with git remote set-url origin https://huggingface.co/spaces/clementdelangue/good-morning so the token isn't sitting in .git/config.)

6. Verify

• Visit https://huggingface.co/spaces/clementdelangue/good-morning — you should see the orange landing page rendered.
• On your Reachy Mini's dashboard, the apps list scans HF for the reachy_mini tag — Good Morning should appear within a minute or two. Click install, then launch.

That's it — the app is now in the directory.

If git push errors out, paste me the exact message. The two common ones:

• remote: Invalid username or password → token is wrong or doesn't have write scope. Regenerate with the right scope.
• pre-receive hook declined with an LFS message → something big slipped in. Run git ls-files | xargs ls -la | sort -k5 -n | tail to see the largest file and git rm --cached <file> it before re-pushing.

Already logged in. Now the remaining steps. You're in ~ — first hop back into the project folder, then create the Space and push.

1. Create the empty Space directly from the CLI

You don't need the web UI, since huggingface_hub is installed. From anywhere:

python -c "from huggingface_hub import create_repo; print(create_repo('good-morning', repo_type='space', space_sdk='static').url)"

That should print something like https://huggingface.co/spaces/clementdelangue/good-morning. If it errors with "already exists", great, it's ready.

2. cd back into the project and push

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"
source .venv/bin/activate   # in case the shell is fresh
git init -b maingit add .git commit -m "Initial commit: Good Morning Reachy Mini app"git remote add origin https://huggingface.co/spaces/clementdelangue/good-morninggit push -u origin main

When git push prompts you:

• Username: clementdelangue
• Password: paste an HF token (hf_…) from https://huggingface.co/settings/tokens — needs Write scope. (Your normal HF password won't work.)

If it complains about credentials repeatedly, set the token inline in the URL once:

git remote set-url origin https://clementdelangue:[REDACTED]/spaces/clementdelangue/good-morninggit push -u origin main# then strip the token back out:git remote set-url origin https://huggingface.co/spaces/clementdelangue/good-morning

3. Done — verify

Open https://huggingface.co/spaces/clementdelangue/good-morning — you'll see the orange landing page render. The Reachy Mini dashboard scans HF for the reachy_mini tag, so the app shows up there too within a minute.

Paste the output of step 1 (or any error) if you hit a snag.

Same python vs python3 thing — on macOS the binary is python3, not python. Use this:

python3 -c "from huggingface_hub import create_repo; print(create_repo('good-morning', repo_type='space', space_sdk='static').url)"

If huggingface_hub was only installed inside the project's venv (likely), you'll get ModuleNotFoundError. Two fixes — pick one:

Option A — install it system-wide so any python works

python3 -m pip install --user --break-system-packages huggingface_hubpython3 -c "from huggingface_hub import create_repo; print(create_repo('good-morning', repo_type='space', space_sdk='static').url)"

Option B — re-activate the venv first

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"source .venv/bin/activatepython -c "from huggingface_hub import create_repo; print(create_repo('good-morning', repo_type='space', space_sdk='static').url)"

Inside the venv python exists; outside it, only python3 does. Either should print the new Space's URL. Paste me what it prints (or the error).

Space is live at https://huggingface.co/spaces/clem/good-morning (your HF username is clem, good to know — I'd assumed clementdelangue). The SSL warning is harmless.

Now push the code into it:

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"
git init -b maingit add .git commit -m "Initial commit: Good Morning Reachy Mini app"git remote add origin https://huggingface.co/spaces/clem/good-morninggit push -u origin main

When git prompts for credentials:

• Username: clem
• Password: an HF token (hf_…) from https://huggingface.co/settings/tokens with Write scope. Your normal password won't work — has to be a token.

If you'd rather skip the prompt entirely, embed the token in the remote once:

git remote set-url origin https://clem:[REDACTED]/spaces/clem/good-morninggit push -u origin main# then clean it back out so the token isn't sitting in .git/config:git remote set-url origin https://huggingface.co/spaces/clem/good-morning

After the push lands, refresh https://huggingface.co/spaces/clem/good-morning — you'll see the orange landing page render, and the app will start showing up in your Reachy Mini's app dashboard within a minute or two (it polls HF for spaces with the reachy_mini tag).

Paste the git push output if anything errors.

Hugging Face auto-generates a starter README.md when a Space is created, so the remote already has one commit. Your local repo doesn't know about it. Easiest fix is to force-push and overwrite — you want your README (the one with reachy_mini tags) to win anyway, not the auto-generated one.

git push -u origin main --force

That's it. Refresh https://huggingface.co/spaces/clem/good-morning and you should see the orange landing page.

(If you'd rather merge instead of overwrite — say, in case HF added something useful like LFS config — you'd run git pull origin main --rebase --allow-unrelated-histories first, but for a brand-new Space there's nothing worth keeping, so force-push is fine.)

Let me check what actually got pushed and compare it against an app that IS showing up.

Good news — your Space is correctly tagged. The HF API call confirms clem/good-morning is indexed under the reachy_mini and reachy_mini_python_app tags, identical setup to the apps that DO show up (e.g. gemini-config-helper):

"id": "clem/good-morning","tags": ["static","reachy_mini","reachy_mini_python_app","region:us"],"sdk": "static"

So the app store will see it. The reason the dashboard's search isn't finding it right now is just the dashboard's local cache. The "Discover Apps" widget pre-loaded its 176-app list before you pushed; it's not re-querying HF on every keystroke.

Three things to try, in order:

1. Force a refresh

Close the "Discover Apps" panel and reopen it (the X in the top right, then click Discover Apps again). On most builds that re-fetches the list. If that doesn't update it, fully quit and relaunch the Reachy Mini desktop app.

2. Wait a couple of minutes

HF's tag indexing can lag a minute or two behind a fresh push. Your space was created at 14:06 and last modified at 14:07 UTC — give it ~5 minutes from then and try again.

3. Filter by the "Robotics" tag

Click the Robotics (9) tag chip — your app has the right tags but might be filtered out of the default view by some other heuristic (likes/trending). Same goes for typing the exact owner: clem/good-morning instead of "Good".

If after a relaunch + 5 min wait it still doesn't appear, two things worth double-checking:

• The Space has to be public. Open https://huggingface.co/spaces/clem/good-morning in an incognito window — if it loads, it's public. The API showed "private": false, so this should be fine.
• The Space has to be Running, not Errored. Static SDK Spaces auto-build, but check the Space page for a red "Build error" badge. If you see one, paste me the build log.

I'd give it a relaunch + a minute and try again — 90% chance that's all it is.

That's the HF Space iframing GitHub, which GitHub refuses to be embedded in. Two-line fix in index.html: add target="_blank" to any link that leaves the page, and point "Get a Reachy Mini" at the Pollen product page instead of the SDK repo (more appropriate for that CTA anyway).

Push the update:

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"
git add index.htmlgit commit -m "Open external links in new tab; fix CTA destination"git push

Refresh the Space (the App tab usually needs a hard reload — Cmd+Shift+R) and the orange button now opens https://www.pollen-robotics.com/reachy-mini/ in a new tab. The footer links to GitHub/Pollen also pop out instead of trying to load inside the iframe.

For the bigger picture: any external link inside an HF Space's index.html will hit this — sites like github.com, twitter.com, openai.com all set X-Frame-Options: DENY. Always use target="_blank" rel="noopener" for outbound links from a Space.

Right — that landing page is the catalog listing (the orange page that shows up when someone browses the app store). The actual button only appears once the app is installed and running on a Reachy Mini — at that point it gets embedded in the dashboard's App tab. The HF Space is sdk: static so it can't talk to the robot directly; if it could host the live button, anyone visiting the page would be triggering your robot.

Let me make that obvious on the page — add an explicit "How to use" section, and a visual preview of what the in-robot button looks like:

Push the changes:

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"
git add index.html style.cssgit commit -m "Add preview button + clear install/use instructions on landing page"git push

Hard-refresh the Space (Cmd+Shift+R) and you'll now see:

1. The orange button right under the title — it's a preview of what the real button looks like, with a label saying so. Clicking it shows a friendly note instead of doing nothing silently.
2. A new "How to use it on your robot" section with a 4-step install guide pointing at the Reachy Mini dashboard.

The actual functional button only exists in two places:

• The robot's dashboard "App" tab, after you install and launch the app from "Discover Apps".
• http://localhost:7860/ if you're running the Python app directly on a machine connected to the robot.

The HF Space can't host the working button itself — it's a static page, has no way to reach your robot, and even if it could, it'd be triggering anyone's robot who happens to view the page.

The app is running (green border + stop button on the good_morning tile, "App Running" badge under the robot). Just need to find where the desktop app surfaces our web UI. Three things to try, in order — most likely the first one is enough.

1. Click the green good_morning tile

The running-app tile usually expands into a panel that embeds the app's web UI (custom_app_url). Click on the tile itself, not the red stop button.

2. Confirm the web server is actually up

Open this in any browser on the same machine:

http://localhost:7860/

If you see the orange "Good morning!" page, FastAPI is running fine and the only question is where the desktop app exposes it. If the page doesn't load, the FastAPI server didn't start — see step 4 below.

If localhost doesn't work, try the robot's hostname:

http://reachy-mini.local:7860/

Either of those is the real, live button. You can use it from a browser tab even if the desktop app never embeds it.

3. Look for an "App" tab or "Open in browser" link

In the desktop app, depending on the version, you'll see either:

• A separate App tab in the top nav (next to "Discover Apps"), or
• An "Open" / arrow-out icon on the running app tile — that pops the UI into a new window/tab.

The tab probably scrolled off the screenshot — try scrolling the right column or resizing the window.

4. If http://localhost:7860/ doesn't load

Check the app's logs for our app's output. In the LOGS panel of the dashboard, filter for good_morning — you should see a line like:

[good_morning] Good Morning app starting (web on :7860, antennas armed)

If you don't see that line at all, the app failed to start — paste the last 20 lines of logs and I'll diagnose. Most likely culprits: pyttsx3 couldn't synthesize on first run (macOS may need a permission prompt), or fastapi/uvicorn aren't in the dependencies the dashboard installed.

The quickest sanity check is step 2 — http://localhost:7860/ in your browser. Tell me what that shows and we'll go from there.

Excellent — the logs prove the app is working end-to-end:

[good_morning] INFO: Good Morning app starting (web on :7860, antennas armed)[good_morning] INFO: Triggered by web[good_morning] INFO: Saying 'Good morning!' (0.73s)

So the FastAPI server, the web button, and the audio playback to the speaker all work. The only remaining question is why the desktop app isn't iframing the UI in its window — the button is right there at localhost:7860, but the dashboard isn't embedding it.

Two things to try inside the desktop app:

Click the green good_morning tile itself (not the red stop button). On most builds, the running app tile is the clickable target — it expands to a panel or switches to a view that embeds custom_app_url. The screenshot you shared looks like the "Home" view; the embedded UI usually lives one click deeper.

Look for a top nav tab. v0.9.29 has tabs like "Home / Apps / Settings" along the top — your screenshot may have cropped them. The "Apps" tab is typically where the running app's UI gets iframed.

If neither does it, the desktop app on your version simply doesn't iframe custom_app_url from the home screen, and you're meant to open it in a browser. That's fine — http://localhost:7860/ (or http://reachy-mini.local:7860/ from any other device on the same network) is the real button. It's the exact same FastAPI route the dashboard would embed.

A small quality-of-life patch I can make: I can change the app to log a clickable URL when it starts, so the LOGS panel shows something like → Open the button at http://localhost:7860/ and you can click straight from there. Want me to push that?

For now though, you have a fully working Reachy Mini app. To recap what you've built:

• A published app at https://huggingface.co/spaces/clem/good-morning with a tagged Space, a landing page, and the right entry point so the dashboard discovers it.
• An installable Reachy Mini Python app that boots a FastAPI web button on port 7860 and listens for antenna presses.
• A working trigger path: web button → robot speaker says "Good morning!" — confirmed by your logs.

Push either antenna and check the logs — you should also see Triggered by antenna. That's the second button working.

Yes — let me add a guaranteed fallback that pops the localhost page in your default browser when the app starts. That way you don't depend on the dashboard iframing it correctly.

Got it — the cleanest fix is to have the app pop your default browser open to the URL when it starts. Then you don't depend on the desktop app's iframe behavior at all.

Compiles clean. Here's what to do:

1. Push the update

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"
git add src/good_morning_app/main.pygit commit -m "Auto-open the button page in the user's browser on app start"git push

2. Re-install on the robot

In the desktop app, hit Stop on the running good_morning tile, then in the Discover Apps panel uninstall + reinstall (or pull-update if the dashboard offers that — the check-updates line in your earlier logs suggests it does).

3. Start it again

When you press Start on good_morning, two things will happen:

• App boots normally — you'll see the same Good Morning app starting (web on :7860, antennas armed) line in LOGS.
• About a second later: Opening the button page in your browser → http://localhost:7860/ appears in LOGS, and your default browser pops a tab with the orange button. Click it → robot says good morning.

What this does under the hood: a small thread polls http://localhost:7860/healthz (the endpoint already in the FastAPI app) until it answers 200 — so it only opens the browser once the server is actually ready, never before — then calls Python's webbrowser.open(). That maps to open on macOS, so it pops your default browser straight to the button page. Independent of whether the desktop app iframes custom_app_url or not.

I also changed custom_app_url from http://0.0.0.0:7860/ to http://localhost:7860/. 0.0.0.0 is a valid bind address but not a valid URL for a browser to navigate to, which may be why the dashboard's iframe was silently failing on your version.

If after the update you'd rather the browser NOT open automatically (say, you've found where the dashboard iframes it), it's a one-line tweak — just delete the _open_browser_when_ready thread block in run(). Let me know how the next launch goes.

On it. Four files to update — phrase in the app, plus the README, landing page, and any antenna mentions across the board. I'll also make the audio cache auto-invalidate on phrase change so you don't have to clear it manually.

Now the landing page — remove all antenna mentions, add the Clem credit banner, and add the localhost callout:

Now strip the antennas out of the "How it works" and "Features" sections:

Now style the new "First!" credit banner:

Now the README — same edits, plus update the Space's short_description:

Now also clean up the in-app web page text — it still says "or push an antenna":

Quick syntax check, then push:

User-facing files (README, index.html, style.css) are clean — no antenna mentions. The 17 references in main.py are internal: the antenna-watching code path still exists silently in the background but isn't promoted anywhere visible. Let me also clean the top-level docstring in main.py since people will read it:

Compiles clean. Push everything:

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"
git add README.md index.html style.css src/good_morning_app/main.pygit commit -m "New phrase, Clem credit, drop antenna mentions, document localhost:7860"git push

Then on the robot: stop the app → reinstall (or update if the dashboard offers it) → start. On launch your browser will open to localhost:7860, click the button, and Reachy Mini will speak the new line.

Summary of what changed:

The spoken phrase is now "Good morning Clem. Today is a good day to help more people become AI builders, not just AI users." — about 5 seconds of audio. The cache file is hashed off the phrase content (good_morning.<hash>.wav) so the moment you change PHRASE, the old WAV is ignored and a fresh one gets synthesised on next start. No manual cache-clearing needed.

The HF Space landing page now leads with a "First!" credit banner crediting you as co-founder and CEO of Hugging Face, links to your HF profile, and the lede quotes the full new phrase. The "How to use it on your robot" steps now point at http://localhost:7860/ for the actual button instead of mentioning a non-working dashboard tab. Every antenna reference is gone from the README, the landing page, the in-app web UI status text, and the top-of-file docstring — antennas are no longer advertised anywhere a user will look.

HF Spaces caps short_description at 60 chars and ours was 64. Tighten it and amend the rejected commit:

51 chars, comfortably under the limit. Now amend and push:

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"
git add README.mdgit commit --amend --no-editgit push

--amend --no-edit rewrites the rejected commit with the fix and keeps the same message. The push should go through this time.

If the prompt about identity (git config --global --edit) was on screen earlier, it's a separate, unrelated nag — git is just letting you know it inferred your name/email from the system. You can ignore it for now, or set them explicitly later with:

git config --global user.name "Clem Delangue"git config --global user.email "[REDACTED]"

Doesn't block the push.

All three files updated and main.py compiles. Push:

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"
git add src/good_morning_app/main.py index.html README.mdgit commit -m "Update phrase: drop name, add open-source line"git push

Then on the robot: stop the app and start it again. Because the cache filename is hashed off the phrase, the old WAV is automatically ignored and a fresh one gets synthesised on first press — no manual cleanup. The Space's landing page will refresh as soon as the push lands.

Done — only the landing page changed. The PHRASE constant in main.py is untouched, so the robot still says the full open-source line. Push:

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"
git add index.htmlgit commit -m "Trim quote from landing page lede"git push

Let me find out where the dashboard icon actually comes from — the box default suggests our 👋 emoji in the README isn't getting picked up. Let me check an app that DOES show a proper icon (hand_tracker_v2 shows 👋 in the screenshot):

The dashboard reads the icon from the emoji field in the README's YAML frontmatter — same as hand_tracker_v2 (👋) and reachy_phone_home (📱). Yours has emoji: 👋 already, but the dashboard cached the box default at install time, so we need to bump the emoji and reinstall.

Also swap the 👋 in the landing page hero so the visual identity is consistent across the Space and the dashboard:

Make the animation suit a sun better — a gentle radiating pulse instead of a wave:

Push, then on the robot uninstall and reinstall the app — the dashboard caches the icon at install time, so re-pushing the README isn't enough on its own:

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"
git add README.md index.html style.cssgit commit -m "Switch icon to sun ☀️"git push

Then on your Reachy Mini desktop app:

1. Stop the running good_morning app (red square button).
2. Open Discover Apps → find good-morning.
3. Uninstall it.
4. Reinstall it — the dashboard re-fetches the README emoji from HF at install time, so the box default gets replaced with ☀️.
5. Start it again — same web UI behavior, just with a sunny icon in the app list.

If after reinstall it still shows 📦, the dashboard might cache via HF's own image CDN — give it a few minutes and try a force-refresh of the desktop app. The other apps in your screenshot (reachy_phone_home showing 📱, hand_tracker_v2 showing 👋) use the exact same emoji: frontmatter mechanism, so this approach is correct.

Let me check the SDK's movement API so I get the calls right:

Yes. I'll add a gentle wobble — head bob, antenna wiggle, and a slight body sway — synced to the audio duration, returning to neutral when it's done. Using set_target at 30 Hz for the live motion and goto_target for the return-to-rest pose, both wrapped in best-effort try/except so any SDK glitch doesn't prevent the greeting.

Now add the motion thread and wire it into _say():

Compiles clean. Push and reinstall:

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"
git add src/good_morning_app/main.pygit commit -m "Animate head, antennas, body sway while speaking"git push

On the robot: stop → uninstall → reinstall → start. Press the button and Reachy Mini should now bob gently, sway its body, and wiggle its antennas for the full duration of the phrase, then settle smoothly back to a neutral resting pose.

What's happening under the hood — a speak-motion thread runs alongside the audio. Every ~33 ms it computes three sinusoids and calls mini.set_target(head=..., antennas=..., body_yaw=...):

The head bobs vertically: a 5 mm baseline lift with ±3 mm bob at 1 Hz — gives the impression of "leaning into" the conversation. Antennas wiggle independently with a 90° phase offset between left and right, peaking at ±12° at 1.5 Hz — the asymmetry reads as expressive rather than mechanical. The body yaws gently ±4° at a slow 0.4 Hz — slow enough that it feels like a conversational sway, not a head shake.

When the phrase finishes, a goto_target smoothly interpolates everything back to zero over 0.6 s with a min-jerk profile, so the robot doesn't snap to rest.

If any of those motions is too much for your taste, the constants are at the top of main.py:

• More dramatic bob → bump HEAD_BOB_AMPLITUDE_MM from 3.0 to 5.0 or higher.
• Calmer antennas → drop ANTENNA_AMPLITUDE_DEG from 12.0 to 6.0.
• No body sway at all → set BODY_YAW_AMPLITUDE_DEG = 0.0.

Want me to add a more specific motif — e.g. a single nod on the word "morning," or have it look toward the microphone — instead of the continuous wobble?

I'll add a clear "Try it without a robot" section to the landing page with the actual install + daemon-sim commands:

Now style the new section so it stands out as a callout card:

Push:

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"
git add index.html style.cssgit commit -m "Add 'Try in simulation' section to landing page"git push

The Space now has a prominent "No robot? No problem" callout card right above "How it works." It walks through four steps: install reachy-mini[mujoco], start the daemon with --sim (with a separate command for macOS using mjpython), connect the desktop app, and install Good Morning. There are copy-pasteable code blocks for each command and links at the bottom to the official simulation guide and the SDK repo for anyone who wants more depth.

The visual style matches the rest of the page — orange accent pill, numbered steps in cards, dark code blocks. Hard-refresh https://huggingface.co/spaces/clem/good-morning after the push to see it.

Sources:

• Reachy Mini Simulation — Setup Guide
• Reachy Mini SDK installation docs
• reachy-mini on PyPI

Done — section is now three steps: install the desktop app (which bundles daemon + simulator), switch to sim mode, install & start Good Morning. The terminal commands are gone. Push:

cd "/Users/clem/Library/Application Support/Claude/local-agent-mode-sessions/60820195-31c6-4093-8c9e-37c09903f4a5/6e545699-813d-4c34-a80c-8667623c108d/local_8906e6df-1974-4b95-a48d-96cc2a2d91db/outputs/reachy-mini-good-morning"
git add index.htmlgit commit -m "Simplify simulation section: just install the desktop app"git push