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

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:

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).

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

If python3 -m venv complains, fall back to:

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).

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

Path B — manual, no extra tools, just git

Cleanest if the assistant gives you any trouble:

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

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

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

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:

(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:

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

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:

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:

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

Option B — re-activate the venv first

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:

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:

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.

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.)

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.

Push the update:

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.

Push the changes:

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.

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

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.

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:

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:

--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:

Doesn't block the push.

All three files updated and main.py compiles. 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:

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:

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.

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:

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: